moflo 4.11.7 → 4.11.9

package/.claude/guidance/shipped/moflo-cli-reference.md

@@ -13,7 +13,7 @@
 | `init`      | 4           | Project initialization with wizard, presets, skills, hooks               |
 | `agent`     | 8           | Agent lifecycle (spawn, list, status, stop, metrics, pool, health, logs) |
 | `swarm`     | 6           | Multi-agent swarm coordination and orchestration                         |
-| `memory`    | 11          | node:sqlite + HNSW vector search, 150x-12,500x faster                    |
+| `memory`    | 11          | node:sqlite + HNSW approximate-nearest-neighbor vector search            |
 | `mcp`       | 9           | MCP server management and tool execution                                 |
 | `task`      | 6           | Task creation, assignment, and lifecycle                                 |
 | `session`   | 7           | Session state management and persistence                                 |
@@ -174,12 +174,12 @@ a real findings UI, not a default-on background task.
 
 ## RuVector Integration (HNSW Vector Search)
 
-| Feature | Performance | Description |
-|---------|-------------|-------------|
-| **HNSW Index** | 150x–12,500x faster | Hierarchical Navigable Small World search |
-| **MicroLoRA** | <100µs adaptation | Fast model adaptation (508k+ ops/sec) |
-| **FlashAttention** | 2.49x–7.47x speedup | Optimized attention computation |
-| **Int8 Quantization** | 3.92x memory reduction | Compressed weight storage |
+| Feature | Description |
+|---------|-------------|
+| **HNSW Index** | Hierarchical Navigable Small World approximate-nearest-neighbor search — scales sub-linearly as the index grows, vs. a brute-force linear scan |
+| **MicroLoRA** | Lightweight rank-2 weight adaptation from successful patterns, without full retraining |
+| **FlashAttention** | Memory-efficient attention computation |
+| **Int8 Quantization** | Compressed 8-bit weight storage to reduce memory footprint |
 
 ---
 

package/.claude/guidance/shipped/moflo-guidance-rules.md

@@ -14,8 +14,8 @@ Claude processes guidance as part of a large context window alongside code, tool
 
 ```markdown
 ## Good
-**Always search memory before Glob/Grep.** Memory search is 150x faster and returns
-domain-aware results that Glob cannot provide.
+**Always search memory before Glob/Grep.** It returns domain-aware semantic matches
+from a prebuilt index that Glob cannot — one lookup, not a fresh filesystem scan.
 
 ## Bad
 Memory search uses HNSW indexing with domain-aware embeddings that provide much better

package/.claude/helpers/statusline.cjs

@@ -773,6 +773,10 @@ function generateStatusline() {
 function generateDashboard() {
   const git = getGitInfo();
   const session = getSessionStats();
+  // Hoisted to function scope: the embeddings block below also reads `system`,
+  // so it must not be scoped inside the show_swarm branch (fixed a ReferenceError
+  // when the swarm line was toggled off / the block ordering changed).
+  const system = getSystemMetrics();
   const lines = [];
 
   // Header: branding + dir + git
@@ -808,7 +812,6 @@ function generateDashboard() {
   // 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(

package/.claude/skills/fl/phases.md

@@ -224,6 +224,14 @@ gh issue edit <issue-number> --remove-label "in-progress" --add-label "ready-for
 gh issue comment <issue-number> --body "PR created: <pr-url>"
 ```
 
+If the story body carries an `Epic: #<n>` back-reference (decomposition writes it — `./ticket.md`) **and** `--epic-branch` is not set, sync the parent epic — check this story's box off and close the epic if it was the last:
+
+```bash
+flo epic checkoff <epic-number> <story-number>
+```
+
+Idempotent and safe to skip when there is no back-reference. `--epic-branch` runs skip it — the epic orchestrator owns checklist state there. The box flips when the work is delivered (PR opened), matching the orchestrator; if a PR is later rejected, reopen the epic manually.
+
 ### 5.5 Finalize run record (Flo Runs dashboard)
 
 Update the tasklist row written in Phase 0 with the terminal status. Same `runId`, `upsert: true`. On success:

package/.claude/skills/fl/ticket.md

@@ -35,25 +35,47 @@ When promoting to epic:
 2. Each story should be completable in a single PR.
 3. Stories should have clear boundaries (one concern per story).
 4. Order stories by dependency (independent ones first).
-5. Create each story as a GitHub issue with its own Description, Acceptance Criteria, and Test Cases.
-6. Convert the parent issue into an epic with a `## Stories` checklist.
+5. Establish the epic issue **first** so its number exists before the stories do (either the promoted parent issue or a freshly created epic).
+6. Create each story as a GitHub issue with its own Description, Acceptance Criteria, Test Cases, **and an `Epic: #<epic-number>` back-reference line at the top of the body**.
+7. Fill in the epic's `## Stories` checklist with a `- [ ] #<story-number>` line for every story.
+
+The **back-reference is load-bearing**, not decoration: a story is usually worked on later via a standalone `/flo <story>` run, not through `flo epic run`. That standalone run reads the `Epic: #<n>` line to find its parent, check its box off, and close the epic when it is the last story. Without the back-reference the epic silently drifts out of sync — the exact miss this step exists to prevent. See `./phases.md` Phase 5.6.
 
 ## Epic decomposition (score >= 7)
 
+The order matters: the epic must exist before the stories so each story can carry the `Epic: #<n>` back-reference, and the epic's checklist is filled in last.
+
+Pass multi-line bodies as a single literal `--body "..."` string (portable — no `printf`/heredoc, which are not guaranteed on every consumer OS; Rule #1). For very large bodies write the text to a file with the Write tool and use `--body-file <path>`.
+
 ```bash
-# Step 1: create each sub-issue
-gh issue create --title "Story: <story-title>" --body "<## Description + ## Acceptance Criteria + ## Suggested Test Cases>" --label "story"
-# capture the new issue number from output
+# Step 1: establish the epic issue and capture its number (EPIC).
+#   Promoting an existing issue — it *is* the epic; add the label now:
+gh issue edit <parent-number> --add-label "epic"            # EPIC = <parent-number>
+#   Or create a fresh epic with an empty Stories section:
+gh issue create --title "Epic: <title>" --label "epic" --body "<## Overview + empty ## Stories section>"
+# capture EPIC = the epic issue number from whichever path above
+
+# Step 2: create each story WITH the Epic back-reference as the first line; capture each number.
+#   (repeat for all stories, typically 2–6)
+gh issue create --title "Story: <story-title>" --label "story" --body "<Epic: #<EPIC> + ## Description + ## Acceptance Criteria + ## Suggested Test Cases>"
+
+# Step 3: fill the epic's ## Stories checklist with a - [ ] #<story> line per story.
+gh issue edit <EPIC> --body "<epic body with the ## Stories checklist filled in>"
+```
+
+**Story body format** — the first line is the back-reference; the standalone `/flo <story>` run (`./phases.md` Phase 5.6) parses `Epic: #<n>` from it:
 
-# Step 2: repeat for all stories (typically 2–6)
+```markdown
+Epic: #<epic-number>
 
-# Step 3: build the epic body with a checklist referencing every story number
+## Description
+<what and why>
 
-# Step 4: update an existing issue into an epic
-gh issue edit <parent-number> --add-label "epic" --body "<epic body with ## Stories checklist>"
+## Acceptance Criteria
+- [ ] ...
 
-# Step 5: or create a new epic
-gh issue create --title "Epic: <title>" --label "epic" --body "<epic body>"
+## Suggested Test Cases
+- ...
 ```
 
 **Epic body format** — the `## Stories` checklist with `- [ ] #<number>` is what enables epic detection, story extraction, and progress tracking:

package/README.md

@@ -49,7 +49,7 @@ MoFlo makes deliberate choices so you don't have to:
 - **Neural embeddings by default** — 384-dimensional embeddings using `all-MiniLM-L6-v2`. No hash fallback, no peer-optional setup, no install prompts — real semantic search works out of the box. A `postinstall` step trims the embedding runtime to your platform and strips GPU-only libraries the runtime never loads, reclaiming roughly 340 MB on Linux and 150 MB on Windows from a fresh install. Set `MOFLO_NO_PRUNE=1` to skip the trim, or `ONNXRUNTIME_NODE_INSTALL_CUDA=true` to keep CUDA GPU support.
 - **Full learning stack wired up OOTB** — All configured and functional from `flo init`, no manual setup:
   - **SONA** (Self-Optimizing Neural Architecture) — learns from task trajectories
-  - **MicroLoRA** — fast rank-2 weight adaptations (~1µs per adapt)
+  - **MicroLoRA** — fast rank-2 weight adaptations from successful patterns
   - **EWC++** (Elastic Weight Consolidation) — prevents catastrophic forgetting across sessions
   - **HNSW Vector Search** — fast nearest-neighbor search over your knowledge base
   - **Semantic Routing** — maps tasks to the right agent via learned patterns (ReasoningBank)
@@ -751,7 +751,7 @@ These are the backend systems that hooks and commands interact with.
 | **Semantic Routing** | Matches task descriptions to agent types using vector similarity against 12 built-in patterns | Routes work to the right specialist (security-architect, tester, coder, etc.) automatically | Yes |
 | **Learned Routing** | Records task outcomes (agent type + success/failure) and feeds them back into routing | Routing gets smarter over time — successful patterns are weighted higher in future recommendations | Yes |
 | **SONA Learning** | Self-Optimizing Neural Architecture that learns from task trajectories | Adapts routing weights based on actual outcomes, not just keyword matching | Yes |
-| **MicroLoRA Adaptation** | Rank-2 LoRA weight updates from successful patterns (~1µs per adapt) | Fine-grained model adaptation without full retraining | Yes |
+| **MicroLoRA Adaptation** | Rank-2 LoRA weight updates from successful patterns | Fine-grained model adaptation without full retraining | Yes |
 | **EWC++ Consolidation** | Elastic Weight Consolidation that prevents catastrophic forgetting | New learning doesn't overwrite patterns from earlier sessions | Yes |
 | **Session Persistence** | Stop hook exports session metrics; SessionStart hook restores prior state | Patterns learned on Monday are available on Friday | Yes |
 | **Auto-Meditate** | Recognizes durable lessons in the live session and distills them into the `learnings` namespace in a background pass at the next session start | The high-signal lessons from each session are kept automatically — no need to remember to run `/meditate` | Yes |

package/dist/src/cli/aidefence/domain/services/threat-learning-service.js

@@ -5,7 +5,7 @@
  * and ReasoningBank-style pattern storage.
  *
  * Features:
- * - HNSW-indexed threat pattern search (150x-12,500x faster)
+ * - HNSW-indexed threat pattern search (approximate-nearest-neighbor)
  * - Pattern learning from successful detections
  * - Effectiveness tracking for adaptive mitigation
  * - Integration with agentic-flow attention mechanisms
@@ -73,7 +73,7 @@ export class ThreatLearningService {
     }
     /**
      * Search for similar threat patterns using HNSW
-     * When connected to AgentDB, achieves 150x-12,500x speedup
+     * When connected to AgentDB, uses HNSW approximate-nearest-neighbor (ANN) search
      */
     async searchSimilarThreats(query, options = {}) {
         const results = await this.vectorStore.search({

package/dist/src/cli/aidefence/index.js

@@ -3,7 +3,7 @@
  *
  * Features:
  * - 50+ prompt injection patterns
- * - HNSW-indexed threat pattern search (150x-12,500x faster with MofloDb)
+ * - HNSW-indexed threat pattern search (approximate-nearest-neighbor with MofloDb)
  * - ReasoningBank-style pattern learning
  * - Adaptive mitigation with effectiveness tracking
  *

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

@@ -452,12 +452,7 @@ const metricsCommand = {
                 { type: 'coder', count: 2, tasks: 45, successRate: '97%' },
                 { type: 'researcher', count: 1, tasks: 32, successRate: '95%' },
                 { type: 'tester', count: 1, tasks: 50, successRate: '98%' }
-            ],
-            performance: {
-                flashAttention: '2.8x speedup',
-                memoryReduction: '52%',
-                searchImprovement: '150x faster'
-            }
+            ]
         };
         if (ctx.flags.format === 'json') {
             output.printJson(metrics);
@@ -491,13 +486,6 @@ const metricsCommand = {
             ],
             data: metrics.byType
         });
-        output.writeln();
-        output.writeln(output.bold('V3 Performance Gains'));
-        output.printList([
-            `Flash Attention: ${output.success(metrics.performance.flashAttention)}`,
-            `Memory Reduction: ${output.success(metrics.performance.memoryReduction)}`,
-            `Search: ${output.success(metrics.performance.searchImprovement)}`
-        ]);
         return { success: true, data: metrics };
     }
 };

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

@@ -726,7 +726,7 @@ const providersCommand = {
             ],
         });
         output.writeln();
-        output.writeln(output.dim('Agentic Flow provider uses WASM SIMD for 75x faster inference'));
+        output.writeln(output.dim('Agentic Flow provider uses WASM SIMD for lightweight pure-TS inference'));
         return { success: true };
     },
 };
@@ -1035,7 +1035,7 @@ const neuralCommand = {
                 },
                 {
                     component: 'Flash Attention',
-                    description: '2.49x-7.47x attention speedup',
+                    description: 'memory-efficient attention',
                     status: neural.flashAttention ? output.success('Enabled') : output.dim('Disabled')
                 },
                 {
@@ -1547,8 +1547,8 @@ export const embeddingsCommand = {
         output.writeln();
         output.writeln('Performance:');
         output.printList([
-            'HNSW indexing: 150x-12,500x faster search',
-            'Agentic Flow: 75x faster than Transformers.js (~3ms)',
+            'HNSW indexing: approximate-nearest-neighbor (ANN) search',
+            'Agentic Flow: lightweight pure-TS inference',
             'Persistent cache: SQLite-backed, survives restarts',
             'Hyperbolic: Better hierarchical representation',
         ]);

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

@@ -12,11 +12,12 @@
  *   flo epic run 42 --verbose                Echo each step's stdout/stderr after it completes
  *   flo epic status <epic-number>            Check progress via memory
  *   flo epic reset <epic-number>             Clear epic memory state
+ *   flo epic checkoff <epic> <story>         Check a story off; close the epic if it was the last
  */
 import { readFileSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { join } from 'node:path';
-import { isEpicIssue, fetchEpicIssue, extractStories, enrichStoryNames, } from '../epic/index.js';
+import { isEpicIssue, fetchEpicIssue, extractStories, enrichStoryNames, checkOffStoryInEpic, } from '../epic/index.js';
 import { runEpicSpell, } from '../epic/runner-adapter.js';
 import { locateMofloModulePath } from '../services/moflo-require.js';
 import { select } from '../prompt.js';
@@ -362,6 +363,36 @@ async function resetEpic(epicNumber) {
     return { success: true };
 }
 // ============================================================================
+// Subcommand: checkoff
+// ============================================================================
+async function checkOffStory(epicArg, storyArg) {
+    const epic = parseInt(epicArg, 10);
+    const story = parseInt(storyArg, 10);
+    if (isNaN(epic) || isNaN(story)) {
+        return { success: false, message: 'Usage: flo epic checkoff <epic-number> <story-number>' };
+    }
+    try {
+        const { checked, epicClosed, alreadyClosed } = await checkOffStoryInEpic(epic, story);
+        const parts = [];
+        parts.push(checked
+            ? `Checked off story #${story} in epic #${epic}.`
+            : `Story #${story} was already checked (or not listed) in epic #${epic}.`);
+        if (epicClosed)
+            parts.push(`All stories complete — closed epic #${epic}.`);
+        else if (alreadyClosed)
+            parts.push(`Epic #${epic} was already closed.`);
+        const message = parts.join(' ');
+        console.log(`[epic] ${message}`);
+        return { success: true, message };
+    }
+    catch (err) {
+        return {
+            success: false,
+            message: buildFailureSummary(err.message, { stepId: 'checkoff' }),
+        };
+    }
+}
+// ============================================================================
 // Preflight warning interactive resolver
 // ============================================================================
 function isInteractive() {
@@ -461,6 +492,7 @@ const epicCommand = {
         { command: 'flo epic run 42', description: 'Explicit run subcommand (same as above)' },
         { command: 'flo epic status 42', description: 'Check epic progress' },
         { command: 'flo epic reset 42', description: 'Reset epic state for re-run' },
+        { command: 'flo epic checkoff 42 43', description: 'Check story #43 off in epic #42; close #42 if it was the last story' },
     ],
     action: async (ctx) => {
         const subcommand = ctx.args?.[0];
@@ -469,10 +501,11 @@ const epicCommand = {
             console.log('       flo epic <command> [args] [flags]');
             console.log('');
             console.log('Commands:');
-            console.log('  <issue-number>           Execute epic (shorthand for "run")');
-            console.log('  run <issue-number>       Execute a GitHub epic via spell engine');
-            console.log('  status <epic-number>     Check epic progress');
-            console.log('  reset <epic-number>      Reset epic state for re-run');
+            console.log('  <issue-number>              Execute epic (shorthand for "run")');
+            console.log('  run <issue-number>          Execute a GitHub epic via spell engine');
+            console.log('  status <epic-number>        Check epic progress');
+            console.log('  reset <epic-number>         Reset epic state for re-run');
+            console.log('  checkoff <epic> <story>     Check a story off in its epic; close the epic if it was the last');
             console.log('');
             console.log('Flags:');
             console.log('  --strategy <name>        single-branch (default) or auto-merge');
@@ -518,8 +551,10 @@ const epicCommand = {
                 return showStatus(commandArgs[0] || '');
             case 'reset':
                 return resetEpic(commandArgs[0] || '');
+            case 'checkoff':
+                return checkOffStory(commandArgs[0] || '', commandArgs[1] || '');
             default:
-                return { success: false, message: `Unknown subcommand: ${subcommand}. Available: run, status, reset` };
+                return { success: false, message: `Unknown subcommand: ${subcommand}. Available: run, status, reset, checkoff` };
         }
     },
 };

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

@@ -826,17 +826,6 @@ const metricsCommand = {
                     { metric: 'Avg Risk Score', value: result.commands.avgRiskScore.toFixed(2) }
                 ]
             });
-            if (v3Dashboard && result.performance) {
-                const p = result.performance;
-                output.writeln();
-                output.writeln(output.bold('🚀 V3 Performance Gains'));
-                output.printList([
-                    `Flash Attention: ${output.success(p.flashAttention ?? 'N/A')}`,
-                    `Memory Reduction: ${output.success(p.memoryReduction ?? 'N/A')}`,
-                    `Search Improvement: ${output.success(p.searchImprovement ?? 'N/A')}`,
-                    `Token Reduction: ${output.success(p.tokenReduction ?? 'N/A')}`
-                ]);
-            }
             return { success: true, data: result };
         }
         catch (error) {
@@ -1412,7 +1401,7 @@ const sessionRestoreCommand = {
 // Intelligence subcommand (SONA, MoE, HNSW)
 const intelligenceCommand = {
     name: 'intelligence',
-    description: 'MoVector intelligence system (SONA, MoE, HNSW 150x faster)',
+    description: 'MoVector intelligence system (SONA, MoE, HNSW ANN search)',
     options: [
         {
             name: 'mode',
@@ -1436,7 +1425,7 @@ const intelligenceCommand = {
         },
         {
             name: 'enable-hnsw',
-            description: 'Enable HNSW 150x faster search',
+            description: 'Enable HNSW approximate-nearest-neighbor (ANN) search',
             type: 'boolean',
             default: true
         },
@@ -1584,7 +1573,7 @@ const intelligenceCommand = {
             }
             // HNSW Component
             output.writeln();
-            output.writeln(output.bold('🔍 HNSW (150x Faster Search)'));
+            output.writeln(output.bold('🔍 HNSW (ANN Search)'));
             const hnsw = result.components?.hnsw;
             if (hnsw?.enabled) {
                 output.printTable({
@@ -1625,19 +1614,6 @@ const intelligenceCommand = {
             else {
                 output.writeln(output.dim('  Not initialized'));
             }
-            // V3 Performance
-            const perf = result.performance;
-            if (perf) {
-                output.writeln();
-                output.writeln(output.bold('🚀 V3 Performance Gains'));
-                output.printList([
-                    `Flash Attention: ${output.success(perf.flashAttention ?? 'N/A')}`,
-                    `Memory Reduction: ${output.success(perf.memoryReduction ?? 'N/A')}`,
-                    `Search Improvement: ${output.success(perf.searchImprovement ?? 'N/A')}`,
-                    `Token Reduction: ${output.success(perf.tokenReduction ?? 'N/A')}`,
-                    `SWE-Bench Score: ${output.success(perf.sweBenchScore ?? 'N/A')}`
-                ]);
-            }
             return { success: true, data: result };
         }
         catch (error) {
@@ -2888,10 +2864,9 @@ const statuslineCommand = {
         }
         const domainsColor = progress.domainsCompleted >= 3 ? c.brightGreen : progress.domainsCompleted > 0 ? c.yellow : c.red;
         // Dynamic perf indicator based on patterns/HNSW
-        let perfIndicator = `${c.dim}⚡ target: 150x-12500x${c.reset}`;
+        let perfIndicator = `${c.dim}⚡ HNSW${c.reset}`;
         if (agentdbStats.hasHnsw && agentdbStats.vectorCount > 0) {
-            const speedup = agentdbStats.vectorCount > 10000 ? '12500x' : agentdbStats.vectorCount > 1000 ? '150x' : '10x';
-            perfIndicator = `${c.brightGreen}⚡ HNSW ${speedup}${c.reset}`;
+            perfIndicator = `${c.brightGreen}⚡ HNSW (ANN)${c.reset}`;
         }
         else if (progress.patternsLearned > 0) {
             const patternsK = progress.patternsLearned >= 1000 ? `${(progress.patternsLearned / 1000).toFixed(1)}k` : String(progress.patternsLearned);
@@ -3742,11 +3717,8 @@ export const hooksCommand = {
         output.writeln(output.bold('V3 Features:'));
         output.printList([
             '🧠 ReasoningBank adaptive learning',
-            '⚡ Flash Attention (2.49x-7.47x speedup)',
-            '🔍 AgentDB integration (150x faster search)',
-            '📊 84.8% SWE-Bench solve rate',
-            '🎯 32.3% token reduction',
-            '🚀 2.8-4.4x speed improvement',
+            '⚡ Flash Attention (memory-efficient attention)',
+            '🔍 AgentDB integration (HNSW ANN search)',
             '👥 Agent Teams integration (auto task assignment)'
         ]);
         return { success: true };

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

@@ -426,7 +426,7 @@ const wizardCommand = {
                 message: 'Select memory backend:',
                 options: [
                     { value: 'hybrid', label: 'Hybrid', hint: 'SQLite + AgentDB (recommended)' },
-                    { value: 'agentdb', label: 'AgentDB', hint: '150x faster vector search' },
+                    { value: 'agentdb', label: 'AgentDB', hint: 'HNSW approximate-nearest-neighbor (ANN) vector search' },
                     { value: 'sqlite', label: 'SQLite', hint: 'Standard SQL storage' },
                     { value: 'memory', label: 'In-Memory', hint: 'Fast but non-persistent' },
                 ],

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

@@ -15,7 +15,7 @@ import { resolveBridgeDbPath } from '../memory/bridge-core.js';
 import { findProjectRoot } from '../services/project-root.js';
 // Memory backends
 const BACKENDS = [
-    { value: 'agentdb', label: 'AgentDB', hint: 'Vector database with HNSW indexing (150x-12,500x faster)' },
+    { value: 'agentdb', label: 'AgentDB', hint: 'Vector database with HNSW approximate-nearest-neighbor (ANN) indexing' },
     { value: 'sqlite', label: 'SQLite', hint: 'Lightweight local storage' },
     { value: 'hybrid', label: 'Hybrid', hint: 'SQLite + AgentDB (recommended)' },
     { value: 'memory', label: 'In-Memory', hint: 'Fast but non-persistent' }
@@ -257,7 +257,7 @@ const searchCommand = {
         },
         {
             name: 'build-hnsw',
-            description: 'Build/rebuild HNSW index before searching (enables 150x-12,500x speedup)',
+            description: 'Build/rebuild HNSW index before searching (enables approximate-nearest-neighbor search)',
             type: 'boolean',
             default: false
         }
@@ -291,7 +291,6 @@ const searchCommand = {
                     const status = getHNSWStatus();
                     output.printSuccess(`HNSW index built (${status.entryCount} vectors, ${buildTime}ms)`);
                     output.writeln(output.dim(`  Dimensions: ${status.dimensions}, Metric: cosine`));
-                    output.writeln(output.dim(`  Search speedup: ${status.entryCount > 10000 ? '12,500x' : status.entryCount > 1000 ? '150x' : '10x'}`));
                 }
                 else {
                     output.printWarning('HNSW index not available (will be initialized on first use)');
@@ -583,7 +582,7 @@ const statsCommand = {
                 ]
             });
             output.writeln();
-            output.printInfo('V3 Performance: 150x-12,500x faster search with HNSW indexing');
+            output.printInfo('V3 Performance: HNSW approximate-nearest-neighbor (ANN) search');
             return { success: true, data: stats };
         }
         catch (error) {

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

@@ -21,7 +21,7 @@ const trainCommand = {
         { name: 'batch-size', short: 'b', type: 'number', description: 'Batch size', default: '32' },
         { name: 'dim', type: 'number', description: 'Embedding dimension (max 256)', default: '256' },
         { name: 'wasm', short: 'w', type: 'boolean', description: 'Use MoVector WASM acceleration', default: 'true' },
-        { name: 'flash', type: 'boolean', description: 'Enable Flash Attention (2.49x-7.47x speedup)', default: 'true' },
+        { name: 'flash', type: 'boolean', description: 'Enable Flash Attention (memory-efficient attention)', default: 'true' },
         { name: 'moe', type: 'boolean', description: 'Enable Mixture of Experts routing', default: 'false' },
         { name: 'hyperbolic', type: 'boolean', description: 'Enable hyperbolic attention for hierarchical patterns', default: 'false' },
         { name: 'contrastive', type: 'boolean', description: 'Use contrastive learning (InfoNCE)', default: 'true' },
@@ -722,7 +722,7 @@ const optimizeCommand = {
                         { metric: 'Pattern Count', before: String(patterns.length), after: String(patterns.length) },
                         { metric: 'Storage Size', before: `${(beforeSize / 1024).toFixed(1)} KB`, after: `${(afterSize / 1024).toFixed(1)} KB` },
                         { metric: 'Embedding Memory', before: `${((memoryReduction * 4) / 1024).toFixed(1)} KB`, after: `${(memoryReduction / 1024).toFixed(1)} KB` },
-                        { metric: 'Memory Reduction', before: '-', after: `~${(3.92).toFixed(2)}x (Int8)` },
+                        { metric: 'Memory Reduction', before: '-', after: 'compressed 8-bit storage' },
                         { metric: 'Precision', before: 'Float32', after: 'Int8 (±0.5%)' },
                     ],
                 });

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

@@ -118,7 +118,7 @@ const benchmarkCommand = {
                 }
                 const mean = searchTimes.reduce((a, b) => a + b, 0) / searchTimes.length;
                 // Brute force baseline: ~0.5μs per vector comparison, 1000 vectors = 0.5ms
-                // HNSW should be O(log n) ~150x faster
+                // HNSW is O(log n) approximate-nearest-neighbor (ANN) search
                 const baselineBruteForce = hnswStatus.entryCount * 0.0005;
                 const speedup = baselineBruteForce / (mean / 1000);
                 results.push({
@@ -492,9 +492,9 @@ const optimizeCommand = {
                 { key: 'impact', header: 'Impact', width: 15 },
             ],
             data: [
-                { priority: output.error('P0'), area: 'Memory', recommendation: 'Enable HNSW index quantization', impact: '+50% reduction' },
+                { priority: output.error('P0'), area: 'Memory', recommendation: 'Enable HNSW index quantization', impact: 'Int8 quantized' },
                 { priority: output.warning('P1'), area: 'CPU', recommendation: 'Enable WASM SIMD acceleration', impact: '+4x speedup' },
-                { priority: output.warning('P1'), area: 'Latency', recommendation: 'Enable Flash Attention', impact: '+2.49x speedup' },
+                { priority: output.warning('P1'), area: 'Latency', recommendation: 'Enable Flash Attention', impact: 'memory-efficient' },
                 { priority: output.info('P2'), area: 'Cache', recommendation: 'Increase pattern cache size', impact: '+15% hit rate' },
                 { priority: output.info('P2'), area: 'Network', recommendation: 'Enable request batching', impact: '-30% latency' },
             ],
@@ -564,11 +564,11 @@ export const performanceCommand = {
             'bottleneck - Identify performance bottlenecks',
         ]);
         output.writeln();
-        output.writeln('Performance Targets:');
+        output.writeln('Capabilities:');
         output.printList([
-            'HNSW Search: 150x-12,500x faster than brute force',
-            'Flash Attention: 2.49x-7.47x speedup',
-            'Memory: 50-75% reduction with quantization',
+            'HNSW Search: approximate-nearest-neighbor (ANN), scales sub-linearly as the index grows',
+            'Flash Attention: memory-efficient attention',
+            'Memory: Int8 quantized weight storage',
         ]);
         output.writeln();
         output.writeln(output.dim('Created with ❤️ by motailz.com'));

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

@@ -110,9 +110,7 @@ async function getSystemStatus() {
             tasks: taskStatus,
             performance: {
                 cpuUsage: getProcessCpuUsage(),
-                memoryUsage: getProcessMemoryUsage(),
-                flashAttention: '2.8x speedup',
-                searchSpeed: '150x faster'
+                memoryUsage: getProcessMemoryUsage()
             }
         };
     }
@@ -138,9 +136,7 @@ async function getSystemStatus() {
             tasks: { total: 0, pending: 0, running: 0, completed: 0, failed: 0 },
             performance: {
                 cpuUsage: 0,
-                memoryUsage: 0,
-                flashAttention: 'N/A',
-                searchSpeed: 'N/A'
+                memoryUsage: 0
             }
         };
     }
@@ -231,10 +227,8 @@ function displayStatus(status) {
     output.writeln();
     // Performance section
     if (status.running) {
-        output.writeln(output.bold('V3 Performance Gains'));
+        output.writeln(output.bold('Performance'));
         output.printList([
-            `Flash Attention: ${output.success(status.performance.flashAttention)}`,
-            `Vector Search: ${output.success(status.performance.searchSpeed)}`,
             `CPU Usage: ${status.performance.cpuUsage.toFixed(1)}%`,
             `Memory Usage: ${status.performance.memoryUsage.toFixed(1)}%`
         ]);
@@ -522,12 +516,6 @@ const memoryCommand = {
                     { metric: 'Cache Hit Rate', value: `${(result.performance.cacheHitRate * 100).toFixed(1)}%` }
                 ]
             });
-            output.writeln();
-            output.writeln(output.bold('V3 Performance Gains'));
-            output.printList([
-                `Search Speed: ${output.success(result.v3Gains.searchImprovement)}`,
-                `Memory Usage: ${output.success(result.v3Gains.memoryReduction)}`
-            ]);
             return { success: true, data: result };
         }
         catch (error) {

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

@@ -224,8 +224,8 @@ const initCommand = {
             output.writeln(output.dim('  Initializing memory namespace...'));
             output.writeln(output.dim('  Setting up communication channels...'));
             if (v3Mode) {
-                output.writeln(output.dim('  Enabling Flash Attention (2.49x-7.47x speedup)...'));
-                output.writeln(output.dim('  Configuring AgentDB integration (150x faster)...'));
+                output.writeln(output.dim('  Enabling Flash Attention (memory-efficient attention)...'));
+                output.writeln(output.dim('  Configuring AgentDB integration (HNSW ANN search)...'));
                 output.writeln(output.dim('  Initializing SONA learning system...'));
             }
             output.writeln();
@@ -617,11 +617,11 @@ const coordinateCommand = {
             data: v3Agents
         });
         output.writeln();
-        output.printInfo('Performance Targets:');
+        output.printInfo('Capabilities:');
         output.printList([
-            `Flash Attention: ${output.success('2.49x-7.47x speedup')}`,
-            `AgentDB Search: ${output.success('150x-12,500x improvement')}`,
-            `Memory Reduction: ${output.success('50-75%')}`,
+            `Flash Attention: ${output.success('memory-efficient attention')}`,
+            `AgentDB Search: ${output.success('HNSW (ANN)')}`,
+            `Memory: ${output.success('Int8 quantized')}`,
             `Code Reduction: ${output.success('<5,000 lines')}`
         ]);
         return { success: true, data: { agents: v3Agents, count: agentCount } };

package/dist/src/cli/epic/detection.js

@@ -6,7 +6,7 @@
  *
  * Story #195: Shared epic detection & extraction module.
  */
-import { exec } from 'node:child_process';
+import { exec, spawnSync } from 'node:child_process';
 import { promisify } from 'node:util';
 const execAsync = promisify(exec);
 // ============================================================================
@@ -138,4 +138,59 @@ export async function findPrForIssue(issueNumber) {
         return null;
     }
 }
+// ============================================================================
+// Story checkoff (standalone `/flo <story>` runs)
+// ============================================================================
+/**
+ * Pure core of the story-checkoff operation — no I/O, unit-testable.
+ *
+ * Flips a story's `- [ ] #<n>` checkbox to `- [x] #<n>` in an epic body and
+ * reports whether the epic is now complete (it has story checkboxes and none
+ * remain unchecked). Word-boundary guarded so #12 never matches inside #123.
+ */
+export function computeEpicCheckoff(body, storyNumber) {
+    const pattern = new RegExp(`- \\[ \\] #${storyNumber}(?!\\d)`);
+    const updated = body.replace(pattern, `- [x] #${storyNumber}`);
+    const checked = updated !== body;
+    const hasStoryCheckboxes = /- \[[ x]\] #\d+/.test(updated);
+    const hasUnchecked = /- \[ \] #\d+/.test(updated);
+    const allComplete = hasStoryCheckboxes && !hasUnchecked;
+    return { updated, checked, allComplete };
+}
+/**
+ * Check a story off in its parent epic's checklist, and close the epic when no
+ * unchecked stories remain. Used by standalone `/flo <story>` runs via
+ * `flo epic checkoff`; the orchestrated `flo epic run` path does its own
+ * checkoff inside the spell (epic-single-branch.yaml).
+ *
+ * Cross-platform (Rule #1): drives `gh` through `spawnSync` arg arrays (no
+ * shell string to escape) and pipes the rewritten body over stdin
+ * (`--body-file -`), the same pattern proven on Windows CI in the spell.
+ */
+export async function checkOffStoryInEpic(epicNumber, storyNumber) {
+    const issue = await fetchEpicIssue(epicNumber);
+    const { updated, checked, allComplete } = computeEpicCheckoff(issue.body || '', storyNumber);
+    if (checked) {
+        const edit = spawnSync('gh', ['issue', 'edit', String(epicNumber), '--body-file', '-'], {
+            input: updated,
+            encoding: 'utf8',
+        });
+        if (edit.status !== 0) {
+            throw new Error(`gh issue edit failed: ${(edit.stderr || edit.error?.message || 'unknown').toString().trim()}`);
+        }
+    }
+    const alreadyClosed = issue.state.toUpperCase() === 'CLOSED';
+    const epicClosed = allComplete && !alreadyClosed;
+    if (epicClosed) {
+        const close = spawnSync('gh', [
+            'issue', 'close', String(epicNumber),
+            '--reason', 'completed',
+            '--comment', `All stories complete — closed automatically after story #${storyNumber}.`,
+        ], { encoding: 'utf8' });
+        if (close.status !== 0) {
+            throw new Error(`gh issue close failed: ${(close.stderr || close.error?.message || 'unknown').toString().trim()}`);
+        }
+    }
+    return { checked, epicClosed, alreadyClosed };
+}
 //# sourceMappingURL=detection.js.map

package/dist/src/cli/epic/index.js

@@ -3,5 +3,5 @@
  *
  * Story #195: Shared epic detection & extraction module.
  */
-export { isEpicIssue, extractStories, extractUncheckedStories, fetchEpicIssue, enrichStoryNames, findPrForIssue, } from './detection.js';
+export { isEpicIssue, extractStories, extractUncheckedStories, fetchEpicIssue, enrichStoryNames, findPrForIssue, computeEpicCheckoff, checkOffStoryInEpic, } from './detection.js';
 //# sourceMappingURL=index.js.map

package/dist/src/cli/hooks/reasoningbank/guidance-provider.js

@@ -55,10 +55,10 @@ export class GuidanceProvider {
             '**Architecture**: Domain-Driven Design across moflo modules',
             '**Priority**: Security-first (CVE-1, CVE-2, CVE-3 remediation)',
             '',
-            '**Performance Targets**:',
-            '- HNSW search: 150x-12,500x faster (<1ms)',
-            '- Flash Attention: 2.49x-7.47x speedup',
-            '- Memory: 50-75% reduction',
+            '**Performance Characteristics**:',
+            '- HNSW approximate-nearest-neighbor (ANN) search: scales sub-linearly as the index grows',
+            '- Flash Attention: memory-efficient attention',
+            '- Memory: Int8 quantized weight storage',
             '',
             '**Active Patterns**:',
             '- Use TDD London School (mock-first)',

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

@@ -5,7 +5,7 @@
  * No JSON - all patterns stored as vectors in memory.db
  *
  * Features:
- * - Real HNSW indexing (M=16, efConstruction=200) for 150x+ faster search
+ * - Real HNSW indexing (M=16, efConstruction=200) for approximate-nearest-neighbor (ANN) search
  * - ONNX embeddings via cli/src/embeddings (MiniLM-L6 384-dim)
  * - MofloDb backend for persistence
  * - Pattern promotion from short-term to long-term memory
@@ -275,7 +275,7 @@ export class ReasoningBank extends EventEmitter {
             ? await this.embeddingService.embed(query)
             : query;
         let results = [];
-        // Try HNSW search first (150x+ faster)
+        // Try HNSW search first (approximate-nearest-neighbor)
         if (this.hnswIndex && this.useRealBackend) {
             const hnswStart = performance.now();
             try {

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

@@ -7,7 +7,7 @@
  * Format matches the working .claude/statusline.sh output:
  * ▊ MoFlo ● <user>  │  ⎇ <branch>  │  Opus 4.8
  * ─────────────────────────────────────────────────────
- * 🏗️  DDD Domains    [●●●●●]  5/5    ⚡ 1.0x → 2.49x-7.47x
+ * 🏗️  DDD Domains    [●●●●●]  5/5
  * 🤖 Swarm  ◉ [58/15]  👥 0    🟢 CVE 3/3    💾 22282MB    📂  47%    🧠  10%
  * 🔧 Architecture    DDD ● 98%  │  Security ●CLEAN  │  Memory ●AgentDB  │  Integration ●
  */
@@ -113,9 +113,8 @@ export class StatuslineGenerator {
         const progressBar = this.generateProgressBar(data.v3Progress.domainsCompleted, data.v3Progress.totalDomains);
         const domainsColor = data.v3Progress.domainsCompleted >= 3 ? c.brightGreen :
             data.v3Progress.domainsCompleted > 0 ? c.yellow : c.red;
-        const speedup = `${c.brightYellow}⚡ 1.0x${c.reset} ${c.dim}→${c.reset} ${c.brightYellow}${data.performance.flashAttentionTarget}${c.reset}`;
         lines.push(`${c.brightCyan}🏗️  DDD Domains${c.reset}    ${progressBar}  ` +
-            `${domainsColor}${data.v3Progress.domainsCompleted}${c.reset}/${c.brightWhite}${data.v3Progress.totalDomains}${c.reset}    ${speedup}`);
+            `${domainsColor}${data.v3Progress.domainsCompleted}${c.reset}/${c.brightWhite}${data.v3Progress.totalDomains}${c.reset}`);
         // Line 2: Swarm + CVE + Memory + Context + Intelligence
         const swarmIndicator = data.swarm.coordinationActive ? `${c.brightGreen}◉${c.reset}` : `${c.dim}○${c.reset}`;
         const agentsColor = data.swarm.activeAgents > 0 ? c.brightGreen : c.red;
@@ -237,9 +236,8 @@ export class StatuslineGenerator {
         const progressBar = this.generateProgressBar(data.v3Progress.domainsCompleted, data.v3Progress.totalDomains);
         const domainsColor = data.v3Progress.domainsCompleted >= 3 ? c.brightGreen :
             data.v3Progress.domainsCompleted > 0 ? c.yellow : c.red;
-        const speedup = `${c.brightYellow}⚡ 1.0x${c.reset} ${c.dim}→${c.reset} ${c.brightYellow}${data.performance.flashAttentionTarget}${c.reset}`;
         lines.push(`${c.brightCyan}🏗️  DDD Domains${c.reset}    ${progressBar}  ` +
-            `${domainsColor}${data.v3Progress.domainsCompleted}${c.reset}/${c.brightWhite}${data.v3Progress.totalDomains}${c.reset}    ${speedup}`);
+            `${domainsColor}${data.v3Progress.domainsCompleted}${c.reset}/${c.brightWhite}${data.v3Progress.totalDomains}${c.reset}`);
         // Line 4: COLLISION ZONE LINE - restructure to avoid cols 15-25
         // We add padding after the emoji to push content past the collision zone
         const swarmIndicator = data.swarm.coordinationActive ? `${c.brightGreen}◉${c.reset}` : `${c.dim}○${c.reset}`;
@@ -425,9 +423,9 @@ export class StatuslineGenerator {
             return this.dataSources.getPerformanceTargets();
         }
         return {
-            flashAttentionTarget: '2.49x-7.47x',
-            searchImprovement: '150x-12,500x',
-            memoryReduction: '50-75%',
+            flashAttentionTarget: 'flash',
+            searchImprovement: 'HNSW (ANN)',
+            memoryReduction: 'int8',
         };
     }
     /**
@@ -588,7 +586,7 @@ export function parseStatuslineData(json) {
             security: data.security ?? { status: 'PENDING', cvesFixed: 0, totalCves: 3 },
             swarm: data.swarm ?? { activeAgents: 0, maxAgents: 15, coordinationActive: false },
             hooks: data.hooks ?? { status: 'INACTIVE', patternsLearned: 0, routingAccuracy: 0, totalOperations: 0 },
-            performance: data.performance ?? { flashAttentionTarget: '2.49x-7.47x', searchImprovement: '150x', memoryReduction: '50%' },
+            performance: data.performance ?? { flashAttentionTarget: 'flash', searchImprovement: 'HNSW (ANN)', memoryReduction: 'int8' },
             lastUpdated: data.lastUpdated ? new Date(data.lastUpdated) : new Date(),
         };
     }

package/dist/src/cli/index.js

@@ -362,8 +362,8 @@ export class CLI {
         this.output.writeln(this.output.bold('V3 FEATURES:'));
         this.output.printList([
             '15-agent hierarchical mesh coordination',
-            'AgentDB with HNSW indexing (150x-12,500x faster)',
-            'Flash Attention (2.49x-7.47x speedup)',
+            'AgentDB with HNSW approximate-nearest-neighbor (ANN) indexing',
+            'Flash Attention (memory-efficient attention)',
             'Unified SwarmCoordinator engine',
             'Event-sourced state management',
             'Domain-Driven Design architecture'

package/dist/src/cli/init/executor.js

@@ -1472,7 +1472,7 @@ async function writeCapabilitiesDoc(targetDir, options, result) {
 MoFlo V4 is a domain-driven design architecture for multi-agent AI coordination with:
 
 - **15-Agent Swarm Coordination** with hierarchical and mesh topologies
-- **HNSW Vector Search** - 150x-12,500x faster pattern retrieval
+- **HNSW Vector Search** - approximate-nearest-neighbor (ANN) pattern retrieval
 - **SONA Neural Learning** - Self-optimizing with <0.05ms adaptation
 - **Byzantine Fault Tolerance** - Queen-led consensus mechanisms
 - **MCP Server Integration** - Model Context Protocol support
@@ -1662,10 +1662,10 @@ npx moflo doctor --fix
 ### MoVector Intelligence System
 - **SONA**: Self-Optimizing Neural Architecture (<0.05ms)
 - **MoE**: Mixture of Experts routing
-- **HNSW**: 150x-12,500x faster search
+- **HNSW**: approximate-nearest-neighbor (ANN) search
 - **EWC++**: Prevents catastrophic forgetting
-- **Flash Attention**: 2.49x-7.47x speedup
-- **Int8 Quantization**: 3.92x memory reduction
+- **Flash Attention**: memory-efficient attention
+- **Int8 Quantization**: compressed 8-bit weight storage
 
 ### 4-Step Intelligence Pipeline
 1. **RETRIEVE** - HNSW pattern search
@@ -1751,10 +1751,10 @@ npx moflo hive-mind consensus --propose "task"
 
 | Metric | Target | Status |
 |--------|--------|--------|
-| HNSW Search | 150x-12,500x faster | ✅ Implemented |
-| Memory Reduction | 50-75% | ✅ Implemented (3.92x) |
+| HNSW Search | ANN (sub-linear scaling) | ✅ Implemented |
+| Memory Reduction | Int8 quantized | ✅ Implemented |
 | SONA Integration | Pattern learning | ✅ Implemented |
-| Flash Attention | 2.49x-7.47x | 🔄 In Progress |
+| Flash Attention | memory-efficient | 🔄 In Progress |
 | MCP Response | <100ms | ✅ Achieved |
 | CLI Startup | <500ms | ✅ Achieved |
 | SONA Adaptation | <0.05ms | 🔄 In Progress |

package/dist/src/cli/mcp-tools/aidefence-moflodb-store.js

@@ -3,7 +3,7 @@
  *
  * Wraps the CLI memory-bridge (MofloDb v3 + HNSW + embeddings) so the
  * 6 aidefence_* MCP tools persist learned threat patterns and mitigation
- * strategies across process restarts with 150x-12,500x faster search.
+ * strategies across process restarts with HNSW approximate-nearest-neighbor (ANN) search.
  *
  * The aidefence facade itself stays pure-lib (no MofloDb import); this
  * adapter is the seam where the bridge is plugged in. Arbitrary values are

package/dist/src/cli/mcp-tools/hooks-tools.js

@@ -830,10 +830,9 @@ export const hooksMetrics = {
                 avgRiskScore: 0.15,
             },
             performance: {
-                flashAttention: '2.49x-7.47x speedup',
-                memoryReduction: '50-75% reduction',
-                searchImprovement: '150x-12,500x faster',
-                tokenReduction: '32.3% fewer tokens',
+                flashAttention: 'flash',
+                memoryReduction: 'int8',
+                searchImprovement: 'HNSW (ANN)',
             },
             status: 'healthy',
             lastUpdated: new Date().toISOString(),
@@ -2039,13 +2038,13 @@ export const hooksIntelligence = {
                     implemented: true,
                     indexSize: realStats.memory.indexSize,
                     memorySizeBytes: realStats.memory.memorySizeBytes,
-                    note: 'HNSW vector indexing with 150x-12,500x speedup',
+                    note: 'HNSW approximate-nearest-neighbor (ANN) vector indexing',
                 },
                 flashAttention: {
                     enabled: true,
                     status: flashAvailable ? 'active' : 'loading',
                     implemented: true, // NOW IMPLEMENTED in alpha.102
-                    note: flashAvailable ? 'Flash Attention with O(N) memory (2.49x-7.47x speedup)' : 'Flash Attention loading...',
+                    note: flashAvailable ? 'Flash Attention with O(N) memory-efficient attention' : 'Flash Attention loading...',
                 },
                 ewc: {
                     enabled: true,

package/dist/src/cli/mcp-tools/memory-tools.js

@@ -339,7 +339,7 @@ export const memoryTools = [
     },
     {
         name: 'memory_search',
-        description: 'Semantic vector search using HNSW index (150x-12,500x faster than keyword search). On chunk hits (non-null `navigation`) you MUST get adjacent context via chunk traversal, never a full-doc `Read`: prefer `expand: "neighbors"` in THIS call (cheapest — inlines prev/next), else `memory_get_neighbors`. Bulk `memory_retrieve` per hit is a protocol violation. See `.claude/guidance/moflo-memory-protocol.md`.',
+        description: 'Semantic vector search using HNSW approximate-nearest-neighbor (ANN) index. On chunk hits (non-null `navigation`) you MUST get adjacent context via chunk traversal, never a full-doc `Read`: prefer `expand: "neighbors"` in THIS call (cheapest — inlines prev/next), else `memory_get_neighbors`. Bulk `memory_retrieve` per hit is a protocol violation. See `.claude/guidance/moflo-memory-protocol.md`.',
         category: 'memory',
         inputSchema: {
             type: 'object',

package/dist/src/cli/memory/entries-read.js

@@ -21,7 +21,7 @@ import { searchCandidateCap } from './bridge-core.js';
 import { cosineSim, logRoutingFault } from './entries-shared.js';
 /**
  * Search entries via node:sqlite with vector similarity.
- * Uses HNSW index for 150x faster search when available.
+ * Uses HNSW approximate-nearest-neighbor (ANN) index for search when available.
  */
 export async function searchEntries(options) {
     // #1058 — read-side routing preamble. When a daemon is reachable AND we're
@@ -76,7 +76,7 @@ export async function searchEntries(options) {
         // Generate query embedding
         const queryEmb = await generateEmbedding(query);
         const queryEmbedding = queryEmb.embedding;
-        // Try HNSW search first (150x faster)
+        // Try HNSW search first (approximate-nearest-neighbor)
         const hnswResults = await searchHNSWIndex(queryEmbedding, { k: limit, namespace });
         if (hnswResults && hnswResults.length > 0) {
             // Filter by threshold

package/dist/src/cli/memory/hnsw-index.js

@@ -2,7 +2,7 @@
  * V3 HNSW Vector Index
  *
  * High-performance Hierarchical Navigable Small World (HNSW) index for
- * 150x-12,500x faster vector similarity search compared to brute force.
+ * Approximate-nearest-neighbor (ANN) vector similarity search that scales sub-linearly vs. a brute-force linear scan.
  *
  * OPTIMIZATIONS:
  * - BinaryMinHeap/BinaryMaxHeap for O(log n) operations (vs O(n log n) Array.sort)

package/dist/src/cli/memory/hnsw-singleton.js

@@ -1,5 +1,5 @@
 /**
- * Process-wide HNSW vector-index singleton (150x faster vector search).
+ * Process-wide HNSW vector-index singleton (approximate-nearest-neighbor search).
  *
  * Extracted from `memory-initializer.ts` (#1203 decomposition). Owns the
  * lazy HNSW index built from the SQLite `embedding` column (or a binary
@@ -162,7 +162,7 @@ export async function addToHNSWIndex(id, embedding, entry) {
     }
 }
 /**
- * Search HNSW index (150x faster than brute-force)
+ * Search HNSW index (approximate-nearest-neighbor; scales sub-linearly vs. brute-force)
  * Returns results sorted by similarity (highest first)
  */
 export async function searchHNSWIndex(queryEmbedding, options) {

package/dist/src/cli/memory/index.js

@@ -2,7 +2,7 @@
  * moflo/cli/memory - V3 Unified Memory System
  *
  * Provides a unified memory interface backed by MofloDb with HNSW indexing
- * for 150x-12,500x faster vector search compared to brute-force approaches.
+ * for HNSW approximate-nearest-neighbor (ANN) vector search that scales sub-linearly as the index grows.
  *
  * @module moflo/cli/memory
  *

package/dist/src/cli/memory/moflo-db-adapter.js

@@ -1,7 +1,7 @@
 /**
  * MofloDb Adapter
  *
- * Moflo-owned in-memory backend with HNSW indexing for 150x-12,500x faster
+ * Moflo-owned in-memory backend with HNSW approximate-nearest-neighbor (ANN)
  * vector search. Implements IMemoryBackend interface. Backed by Map + HNSW
  * with optional sql.js persistence; has no external agentdb dependency.
  *
@@ -29,7 +29,7 @@ const DEFAULT_CONFIG = {
  * MofloDb Memory Backend Adapter
  *
  * Provides unified memory storage with:
- * - HNSW-based vector search (150x-12,500x faster than brute force)
+ * - HNSW-based approximate-nearest-neighbor (ANN) vector search
  * - LRU caching with TTL support
  * - Namespace-based organization
  * - Full-text and metadata filtering

package/dist/src/cli/memory/types.js

@@ -2,7 +2,7 @@
  * V3 Unified Memory Types
  *
  * Type definitions for the unified memory system based on sql.js with HNSW indexing.
- * Supports 150x-12,500x faster vector search compared to brute-force approaches.
+ * Supports HNSW approximate-nearest-neighbor (ANN) vector search that scales sub-linearly as the index grows.
  *
  * @module v3/memory/types
  */

package/dist/src/cli/movector/vector-db.js

@@ -3,7 +3,7 @@
  *
  * Provides optional WASM-accelerated vector operations for:
  * - Semantic similarity search
- * - HNSW indexing (150x faster)
+ * - HNSW indexing (approximate-nearest-neighbor)
  * - Embedding generation
  *
  * Gracefully degrades when native backend is not available.

package/dist/src/cli/neural/reasoning-bank.js

@@ -105,7 +105,7 @@ export class ReasoningBank {
     /**
      * Retrieve relevant memories using Maximal Marginal Relevance (MMR)
      *
-     * Uses MofloDb HNSW index for 150x faster retrieval when available.
+     * Uses MofloDb HNSW approximate-nearest-neighbor (ANN) index for retrieval when available.
      *
      * @param queryEmbedding - Query vector for similarity search
      * @param k - Number of results to return (default: config.retrievalK)

package/dist/src/cli/swarm/attention-coordinator.js

@@ -3,17 +3,12 @@
  *
  * Implements attention-based coordination mechanisms from agentic-flow@alpha:
  * - multi-head: Standard multi-head attention
- * - flash: 2.49x-7.47x speedup, 75% memory reduction
+ * - flash: memory-efficient attention (Int8 quantized weight storage)
  * - linear: For long sequences
  * - hyperbolic: Hierarchical data
  * - moe: Mixture of Experts routing
  * - graph-rope: Graph-aware positional embeddings
  *
- * Performance Targets:
- * - Flash Attention: 2.49x-7.47x speedup
- * - Memory Reduction: 50-75%
- * - MoE Routing: <5ms
- *
  * @module v3/swarm/attention-coordinator
  */
 import { EventEmitter } from 'events';
@@ -55,8 +50,6 @@ export class AttentionCoordinator extends EventEmitter {
     performanceStats = {
         totalCoordinations: 0,
         totalLatency: 0,
-        flashSpeedup: 0,
-        memoryReduction: 0,
     };
     constructor(embeddingProvider, config = {}) {
         super();
@@ -197,7 +190,7 @@ export class AttentionCoordinator extends EventEmitter {
     // Attention Mechanism Implementations
     // ===========================================================================
     /**
-     * Flash Attention - 2.49x-7.47x speedup
+     * Flash Attention - memory-efficient attention
      */
     async flashAttentionCoordination(agentOutputs) {
         await this.ensureEmbeddings(agentOutputs);
@@ -235,8 +228,6 @@ export class AttentionCoordinator extends EventEmitter {
             memoryUsed,
             participatingAgents: agentOutputs.map(o => o.agentId),
             metadata: {
-                speedup: '2.49x-7.47x',
-                memoryReduction: '75%',
                 blockSize,
             },
         };
@@ -669,12 +660,6 @@ export class AttentionCoordinator extends EventEmitter {
     updateStats(latency, mechanism, result) {
         this.performanceStats.totalCoordinations++;
         this.performanceStats.totalLatency += latency;
-        if (mechanism === 'flash') {
-            // Track Flash Attention performance
-            // In production, compare against baseline
-            this.performanceStats.flashSpeedup = 2.49 + Math.random() * 4.98; // 2.49x-7.47x
-            this.performanceStats.memoryReduction = 0.75;
-        }
     }
     // ===========================================================================
     // Public Getters

package/dist/src/cli/swarm/coordination/agent-registry.js

@@ -293,7 +293,7 @@ export class AgentRegistry {
                 id: 'agent-7',
                 role: 'memory-specialist',
                 domain: 'core',
-                description: 'Memory system unification with AgentDB (150x-12500x improvement)',
+                description: 'Memory system unification with AgentDB (HNSW ANN search)',
                 capabilities: [
                     { name: 'memory-optimization', description: 'Optimize memory systems', supportedTaskTypes: ['memory-optimization', 'implementation'] }
                 ],
@@ -370,7 +370,7 @@ export class AgentRegistry {
                 id: 'agent-14',
                 role: 'performance-engineer',
                 domain: 'performance',
-                description: 'Benchmarking and performance optimization (2.49x-7.47x target)',
+                description: 'Benchmarking and performance optimization',
                 capabilities: [
                     { name: 'benchmarking', description: 'Run performance benchmarks', supportedTaskTypes: ['benchmark'] }
                 ],

package/dist/src/cli/swarm/coordination/swarm-hub.js

@@ -406,7 +406,7 @@ export class SwarmHub {
             activeAgents: ['agent-1', 'agent-5', 'agent-6', 'agent-7', 'agent-8', 'agent-9', 'agent-13'],
             goals: [
                 'Complete core module implementation',
-                'Unify memory system with AgentDB (150x improvement)',
+                'Unify memory system with AgentDB (HNSW ANN search)',
                 'Merge 4 coordination systems into single SwarmCoordinator',
                 'Optimize MCP server',
                 'Implement TDD London School tests'
@@ -439,8 +439,8 @@ export class SwarmHub {
                 'agent-13', 'agent-14', 'agent-15'
             ],
             goals: [
-                'Achieve 2.49x-7.47x Flash Attention speedup',
-                'Verify 150x-12,500x AgentDB search improvement',
+                'Enable Flash Attention (memory-efficient attention)',
+                'Verify AgentDB HNSW (ANN) search',
                 'Complete deployment pipeline',
                 'Final test coverage push (>90%)',
                 'Release v3.0.0'
@@ -479,10 +479,10 @@ export class SwarmHub {
             {
                 id: 'ms-memory-unification',
                 name: 'Memory Unification Complete',
-                description: 'Single memory service with AgentDB backend achieving 150x improvement',
+                description: 'Single memory service with AgentDB HNSW (ANN) backend',
                 criteria: [
                     { description: 'AgentDB integrated', met: false, evidence: null },
-                    { description: '150x search improvement verified', met: false, evidence: null },
+                    { description: 'HNSW (ANN) search verified', met: false, evidence: null },
                     { description: 'Hybrid backend working', met: false, evidence: null }
                 ],
                 status: 'pending',
@@ -517,9 +517,9 @@ export class SwarmHub {
                 name: 'Performance Targets Met',
                 description: 'All performance targets achieved and verified',
                 criteria: [
-                    { description: '2.49x-7.47x Flash Attention speedup', met: false, evidence: null },
-                    { description: '150x-12,500x AgentDB search', met: false, evidence: null },
-                    { description: '50-75% memory reduction', met: false, evidence: null },
+                    { description: 'Flash Attention (memory-efficient attention)', met: false, evidence: null },
+                    { description: 'AgentDB HNSW (ANN) search', met: false, evidence: null },
+                    { description: 'Int8 quantized memory', met: false, evidence: null },
                     { description: '<500ms startup time', met: false, evidence: null }
                 ],
                 status: 'pending',

package/dist/src/cli/version.js

@@ -2,5 +2,5 @@
  * Auto-generated by build. Do not edit manually.
  * Source of truth: root package.json → scripts/sync-version.mjs
  */
-export const VERSION = '4.11.7';
+export const VERSION = '4.11.9';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.11.7",
+  "version": "4.11.9",
   "description": "MoFlo — AI agent orchestration for Claude Code. A standalone, opinionated toolkit with semantic memory, learned routing, gates, spells, and the /flo issue-execution skill.",
   "main": "dist/src/cli/index.js",
   "type": "module",
@@ -94,7 +94,7 @@
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
     "eslint": "^8.0.0",
-    "moflo": "^4.11.6",
+    "moflo": "^4.11.8",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"