moflo 4.10.24 → 4.10.25

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

@@ -164,17 +164,17 @@ Config is loaded from `moflo.yaml` at the project root — there is no env var t
 
 ```bash
 # Logging
-CLAUDE_FLOW_LOG_LEVEL=info               # debug | info | warn | error
+MOFLO_LOG_LEVEL=info               # debug | info | warn | error
 
 # MCP Server (stdio transport — no port)
-CLAUDE_FLOW_MCP_TRANSPORT=stdio
+MOFLO_MCP_TRANSPORT=stdio
 
 # Memory backend (legacy SystemConfig env vars — moflo.yaml `memory.backend` is the modern surface)
-CLAUDE_FLOW_MEMORY_BACKEND=sqlite        # informational only; not consumed by selectProvider
-CLAUDE_FLOW_MEMORY_TYPE=sqlite           # SystemConfig override (legacy)
+MOFLO_MEMORY_BACKEND=sqlite        # informational only; not consumed by selectProvider
+MOFLO_MEMORY_TYPE=sqlite           # SystemConfig override (legacy)
 ```
 
-Variable names retain the `CLAUDE_FLOW_` prefix for backward compatibility with consumers upgraded from claude-flow.
+These use the canonical `MOFLO_` prefix. The pre-rebrand `CLAUDE_FLOW_` names are still read as a fallback for one deprecation cycle, so consumers upgraded from `claude-flow` keep working without a manual rename.
 
 ---
 

package/.claude/skills/meditate/SKILL.md

@@ -87,11 +87,11 @@ mcp__moflo__memory_store {
   namespace: "learnings",
   key: "<stable descriptive slug, e.g. pattern:daemon-port-resolver or gotcha:windows-spell-path>",
   value: "<the lesson> — Why: <why it matters>. How to apply: <what to do next time>.",
-  tags: ["<topic>", "<area>"]
+  tags: ["<topic>", "<area>", "source:meditate-manual"]
 }
 ```
 
-Keep keys stable and descriptive so the next `/meditate` updates rather than re-adds. In `--preview` mode, **stop here** — print the candidates and their would-be keys/dedup verdicts, write nothing.
+Always include the `source:meditate-manual` tag — it lets the Luminarium "Learnings" panel attribute each lesson to `/meditate` vs the automatic auto-meditate distill. Keep keys stable and descriptive so the next `/meditate` updates rather than re-adds. In `--preview` mode, **stop here** — print the candidates and their would-be keys/dedup verdicts, write nothing.
 
 ## Step 4 — Report
 

package/bin/cli-hooks/statusline.js

@@ -36,10 +36,10 @@ Usage:
   statusline --help       Show this help
 
 Environment Variables:
-  CLAUDE_FLOW_STATUSLINE_REFRESH   Refresh interval in ms
-  CLAUDE_FLOW_SHOW_HOOKS_METRICS   Show hooks metrics (true/false)
-  CLAUDE_FLOW_SHOW_SWARM_ACTIVITY  Show swarm activity (true/false)
-  CLAUDE_FLOW_SHOW_PERFORMANCE     Show performance targets (true/false)
+  MOFLO_STATUSLINE_REFRESH   Refresh interval in ms
+  MOFLO_SHOW_HOOKS_METRICS   Show hooks metrics (true/false)
+  MOFLO_SHOW_SWARM_ACTIVITY  Show swarm activity (true/false)
+  MOFLO_SHOW_PERFORMANCE     Show performance targets (true/false)
 
 Examples:
   statusline                       # Display formatted status
@@ -49,13 +49,17 @@ Examples:
     process.exit(0);
   }
 
-  // Create generator with environment-based config
+  // Create generator with environment-based config.
+  // #1209 — prefer MOFLO_* toggles, fall back to the pre-rebrand CLAUDE_FLOW_*
+  // names so consumers who set the old vars keep their statusline preferences.
+  const showEnv = (suffix) =>
+    process.env['MOFLO_' + suffix] ?? process.env['CLAUDE_' + 'FLOW_' + suffix];
   const generator = new StatuslineGenerator({
     enabled: true,
     refreshOnHook: true,
-    showHooksMetrics: process.env.CLAUDE_FLOW_SHOW_HOOKS_METRICS !== 'false',
-    showSwarmActivity: process.env.CLAUDE_FLOW_SHOW_SWARM_ACTIVITY !== 'false',
-    showPerformance: process.env.CLAUDE_FLOW_SHOW_PERFORMANCE !== 'false',
+    showHooksMetrics: showEnv('SHOW_HOOKS_METRICS') !== 'false',
+    showSwarmActivity: showEnv('SHOW_SWARM_ACTIVITY') !== 'false',
+    showPerformance: showEnv('SHOW_PERFORMANCE') !== 'false',
   });
 
   // Try to read from metrics database or files

package/bin/cli.js

@@ -2,7 +2,7 @@
 /**
  * @moflo/cli - CLI Entry Point
  *
- * Claude Flow V3 Command Line Interface
+ * MoFlo V3 Command Line Interface
  *
  * Auto-detects MCP mode when stdin is piped and no args provided.
  * This allows: echo '{"jsonrpc":"2.0",...}' | npx @moflo/cli

package/bin/hooks.mjs

@@ -510,7 +510,7 @@ function runBackgroundTraining() {
 // Falls back to a naive kill(0) check if the import fails (e.g. dist not built).
 let _getDaemonLockHolder = null;
 try {
-  const daemonLockPath = resolve(__dirname, '..', 'src', '@claude-flow', 'cli', 'dist', 'src', 'services', 'daemon-lock.js');
+  const daemonLockPath = resolve(projectRoot, 'node_modules/moflo/dist/src/cli/services/daemon-lock.js');
   if (existsSync(daemonLockPath)) {
     const mod = await import(pathToFileURL(daemonLockPath).href);
     _getDaemonLockHolder = mod.getDaemonLockHolder;

package/bin/lib/meditate.mjs

@@ -488,6 +488,7 @@ export function buildDistillPrompt(entries) {
     `1. For EACH candidate, call mcp__moflo__memory_search { namespace: "learnings", query: <bare keywords>, threshold: 0.6, limit: 5 }.`,
     `2. If the top hit is the SAME fact at similarity >= 0.80, call mcp__moflo__memory_store with that SAME key (upsert), merging any new nuance — do NOT create a near-duplicate.`,
     `3. Otherwise call mcp__moflo__memory_store { namespace: "learnings", key: <stable descriptive slug>, value: "<lesson> — Why: <why it matters>. How to apply: <what to do next time>.", tags: [<topic>, <area>] }.`,
+    `   PROVENANCE (#1203): every memory_store you make — both the step-2 upsert and the step-3 new write — MUST include the tag "source:auto-meditate" in its tags array, so the Luminarium "Learnings" panel can attribute these to the automatic distill pass.`,
     `4. Skip any candidate that does not clear the durability bar below, or that merely restates an existing entry.`,
     ``,
     DURABILITY_BAR,

package/bin/lib/pii-scrub.mjs

@@ -1,17 +1,14 @@
 /**
  * Credential / secret scrubber for the session-continuity persist path (#1185).
  *
- * THREAT MODEL — this is deliberately NOT the transfer/anonymization pipeline
- * (`src/cli/transfer/anonymization/index.ts`). That module makes a CFP safe to
- * publish *externally* (aggressive, lossy, deterministic pseudonymisation of
- * emails / home paths / IPs). This module has a narrower job: a session digest
+ * THREAT MODEL — this scrubber has a deliberately narrow job: a session digest
  * is written to the user's OWN local `.moflo/moflo.db`, so the only thing we
  * must never persist is a literal *secret* that happened to appear in the
  * session (an API key, a JWT, a private-key block). We intentionally KEEP
  * benign context like file paths and branch names — they're the whole point of
  * a "where you left off" digest and are not sensitive on the user's own disk.
  *
- * Two different purposes → two focused scrubbers, not one over-coupled one.
+ * Scope is intentionally minimal: persist useful context, never persist secrets.
  *
  * Pure + synchronous + dependency-free so a bin/*.mjs hook can call it on the
  * hot path without loading a model. Cross-platform (Rule #1): plain regex, no

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

@@ -14,6 +14,7 @@ import { spawn, execFileSync } from 'child_process';
 import { join, resolve } from 'path';
 import * as fs from 'fs';
 import { errorDetail } from '../shared/utils/error-detail.js';
+import { readMofloEnv } from '../services/env-compat.js';
 /**
  * Resolve the dashboard port from CLI flag and env, in that precedence order.
  *
@@ -68,7 +69,7 @@ const startCommand = {
         const noDashboard = ctx.flags.noDashboard;
         const rawDashboardPort = ctx.flags.dashboardPort;
         const projectRoot = process.cwd();
-        const isDaemonProcess = process.env.CLAUDE_FLOW_DAEMON === '1';
+        const isDaemonProcess = readMofloEnv('DAEMON') === '1';
         // Resolve dashboard port; see `resolveDashboardPort` for precedence.
         const portResult = resolveDashboardPort(rawDashboardPort, process.env.MOFLO_DAEMON_PORT);
         if (!portResult.ok) {
@@ -125,7 +126,7 @@ const startCommand = {
             // below).
             process.env.MOFLO_IS_DAEMON = '1';
             // Acquire atomic daemon lock (prevents duplicate daemons).
-            // Always acquire here — even when spawned as a child (CLAUDE_FLOW_DAEMON=1)
+            // Always acquire here — even when spawned as a child (MOFLO_DAEMON=1)
             // because on Windows the parent's child.pid is the shell PID (cmd.exe),
             // not the actual node process. The child must write its own real PID.
             const lockResult = acquireDaemonLock(projectRoot);
@@ -373,7 +374,7 @@ async function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemo
     }
     const daemonEnv = {
         ...process.env,
-        CLAUDE_FLOW_DAEMON: '1',
+        MOFLO_DAEMON: '1',
         // #981 — daemon process must skip its own write-routing client.
         MOFLO_IS_DAEMON: '1',
         // Prevent macOS SIGHUP kill when terminal closes

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

@@ -632,7 +632,7 @@ export async function checkHookBlockDrift() {
         return {
             name: 'Hook Block Drift',
             status: 'pass',
-            message: 'drift check skipped — claudeFlow.hooks.locked: true',
+            message: 'drift check skipped — moflo.hooks.locked: true',
         };
     }
     // #896: respect `auto_update.hook_block_drift: off` — opt-out for consumers
@@ -667,7 +667,7 @@ export async function checkHookBlockDrift() {
         name: 'Hook Block Drift',
         status: 'warn',
         message: parts.join(', '),
-        fix: 'set auto_update.hook_block_drift: regenerate in moflo.yaml, or claudeFlow.hooks.locked: true to suppress',
+        fix: 'set auto_update.hook_block_drift: regenerate in moflo.yaml, or moflo.hooks.locked: true to suppress',
     };
 }
 // ============================================================================

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

@@ -11,6 +11,7 @@
  * moflo package root via `import.meta.url`, so checks behave identically in
  * the dev tree and in `node_modules/moflo/...` consumer installs.
  */
+import { errorDetail } from '../shared/utils/error-detail.js';
 import { loadToolArrays, getTool, safeInvoke, summarizeFunctional, } from './doctor-checks-functional-shared.js';
 const SWARM_FUNCTIONAL_CHECK = 'Swarm Functional';
 const HIVE_FUNCTIONAL_CHECK = 'Hive-Mind Functional';
@@ -202,6 +203,120 @@ export async function checkSwarmFunctional() {
     return summarize(SWARM_FUNCTIONAL_CHECK, details);
 }
 // ============================================================================
+// Hive-Mind write-through propagation race (#1206)
+// ============================================================================
+/**
+ * Standard bounded backoff (ms) for the `hive-mind_memory` set→get
+ * write-through propagation retry. Same budget as the project-wide transient
+ * retry pattern (see `feedback_transient_retry_circuit_breaker.md`).
+ */
+const HIVE_MEMORY_GET_RETRY_DELAYS_MS = [50, 200, 800];
+const backoffSleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const HIVE_MEMORY_GET_META = {
+    id: 'hive-mind_memory.get',
+    mcpTool: 'hive-mind_memory',
+    expected: 'memory get returns previously-set value (proves shared store, not in-memory only)',
+};
+/**
+ * #1206: probe `hive-mind_memory` get after a successful set, tolerating async
+ * write-through propagation lag. Mirrors the #1111/#1120 fix on the
+ * `Memory Access Functional` check: an immediate `exists=false` right after a
+ * successful set is most often a propagation race (slow disk / fork contention
+ * / 429-throttled cold start on a stressed CI runner), not a genuine
+ * write-through break.
+ *
+ * Classification:
+ *   - `exists=true` + matching sentinel on the first read → **pass**.
+ *   - `exists=false` (or a transient throw) → **retry** with bounded backoff
+ *     (50/200/800ms). A late landing → **warn** (write-through works, just
+ *     lagged). Budget exhausted with no landing → **fail** (a real
+ *     write-through break is a protected-surface regression and MUST stay a
+ *     hard fail — ⛔ swarm/hive-mind rule; never hide a real disconnect).
+ *   - `exists=true` + wrong sentinel → **fail** immediately, no retries: a
+ *     value clobber is a real bug, not a propagation race.
+ *
+ * `opts` injects the backoff schedule + sleep so the regression test exercises
+ * the classification without real delays.
+ */
+async function probeHiveMemoryGet(hiveMindTools, probeKey, sentinel, details, opts) {
+    const tool = getTool(hiveMindTools, 'hive-mind_memory');
+    if (!tool?.handler) {
+        details.push({
+            ...HIVE_MEMORY_GET_META, status: 'fail',
+            observed: { reason: 'tool-not-registered' },
+            message: 'MCP tool "hive-mind_memory" not registered in the loaded tool array',
+        });
+        return;
+    }
+    const handler = tool.handler;
+    const delays = opts?.delaysMs ?? HIVE_MEMORY_GET_RETRY_DELAYS_MS;
+    const sleep = opts?.sleep ?? backoffSleep;
+    const getOnce = async () => {
+        try {
+            const raw = (await handler({ action: 'get', key: probeKey }));
+            if (!raw?.exists)
+                return { kind: 'missing' };
+            if (raw.value?.sentinel !== sentinel) {
+                return { kind: 'mismatch', message: `value mismatch: expected sentinel="${sentinel}", got ${JSON.stringify(raw.value)}` };
+            }
+            return { kind: 'landed' };
+        }
+        catch (err) {
+            return { kind: 'threw', message: errorDetail(err, { firstLineOnly: true }) };
+        }
+    };
+    let attempts = 1;
+    let result = await getOnce();
+    if (result.kind === 'landed') {
+        details.push({ ...HIVE_MEMORY_GET_META, status: 'pass', observed: { exists: true, attempts } });
+        return;
+    }
+    if (result.kind === 'mismatch') {
+        details.push({ ...HIVE_MEMORY_GET_META, status: 'fail', observed: { exists: true, attempts }, message: result.message });
+        return;
+    }
+    // exists=false (or a transient throw) — retry with bounded backoff to absorb
+    // async write-through propagation lag.
+    for (const delay of delays) {
+        await sleep(delay);
+        result = await getOnce();
+        attempts++;
+        if (result.kind === 'landed') {
+            const retries = attempts - 1;
+            details.push({
+                ...HIVE_MEMORY_GET_META, status: 'warn',
+                observed: { exists: true, attempts, retriedAfterMs: delays.slice(0, retries) },
+                message: `hive-mind write-through propagation race — get returned exists=false immediately after a successful set, but the value landed after ${retries} bounded retr${retries === 1 ? 'y' : 'ies'} (write-through works, propagation just lagged; expected under slow disk / fork contention / throttled cold start on a stressed runner)`,
+            });
+            return;
+        }
+        if (result.kind === 'mismatch') {
+            details.push({ ...HIVE_MEMORY_GET_META, status: 'fail', observed: { exists: true, attempts }, message: result.message });
+            return;
+        }
+    }
+    // Budget exhausted and the value never landed — a genuine write-through break
+    // is a protected-surface regression and must stay a hard fail. The threw case
+    // never observed an `exists` value, so don't report a misleading exists=false.
+    const message = result.kind === 'threw'
+        ? `get threw on every attempt over ${attempts} tries (last: ${result.message})`
+        : `get returned exists=false after a successful set and ${attempts} bounded attempts — write-through to Memory DB is broken`;
+    const observed = result.kind === 'threw'
+        ? { threw: true, attempts }
+        : { exists: false, attempts };
+    details.push({ ...HIVE_MEMORY_GET_META, status: 'fail', observed, message });
+}
+/**
+ * #1206 regression-test seam. Drives {@link probeHiveMemoryGet} with a
+ * synthetic `hiveMindTools` array and an injectable sleep so the test
+ * exercises the bounded-retry → warn/fail/pass classification without real
+ * backoff delays. Not part of the public doctor surface — real callers use
+ * {@link checkHiveMindFunctional}.
+ */
+export async function _probeHiveMemoryGetForTest(hiveMindTools, probeKey, sentinel, details, opts) {
+    return probeHiveMemoryGet(hiveMindTools, probeKey, sentinel, details, opts);
+}
+// ============================================================================
 // Hive-Mind Functional Check
 // ============================================================================
 export async function checkHiveMindFunctional() {
@@ -338,19 +453,13 @@ export async function checkHiveMindFunctional() {
         assert: () => null,
     });
     if (setOut?.success === true) {
-        await safeInvoke(hiveMindTools, 'hive-mind_memory', { action: 'get', key: probeKey }, details, {
-            id: 'hive-mind_memory.get',
-            mcpTool: 'hive-mind_memory',
-            expected: 'memory get returns previously-set value (proves shared store, not in-memory only)',
-            assert: (raw) => {
-                const out = raw;
-                if (!out?.exists)
-                    return 'get returned exists=false after a successful set — write-through to Memory DB is broken';
-                if (out.value?.sentinel !== sentinel)
-                    return `value mismatch: expected sentinel="${sentinel}", got ${JSON.stringify(out.value)}`;
-                return null;
-            },
-        });
+        // #1206: a get returning exists=false immediately after a successful set is
+        // most often async write-through propagation lag, not a genuine
+        // write-through break (mirrors the #1111/#1120 fix on Memory Access).
+        // Retry with bounded backoff: a late landing demotes to warn; never
+        // landing stays a hard fail (⛔ a real write-through break is a
+        // protected-surface regression and must not be hidden).
+        await probeHiveMemoryGet(hiveMindTools, probeKey, sentinel, details);
     }
     // 7. Cleanup — graceful shutdown (best-effort; failures here aren't a regression signal).
     try {

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

@@ -6,7 +6,6 @@ import { output } from '../output.js';
 import { formatStatus } from '../services/cli-formatters.js';
 import { confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import { storeCommand } from './transfer-store.js';
 import { memoryDbCandidatePaths } from '../services/moflo-paths.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 // Hook types
@@ -851,8 +850,6 @@ const metricsCommand = {
         }
     }
 };
-// Pattern Store command (imported from transfer-store.ts)
-// storeCommand is imported at the top
 // Transfer from project subcommand
 const transferFromProjectCommand = {
     name: 'from-project',
@@ -951,38 +948,25 @@ const transferFromProjectCommand = {
         }
     }
 };
-// Parent transfer command combining all transfer methods
+// Parent transfer command for local pattern transfer
 const transferCommand = {
     name: 'transfer',
-    description: 'Transfer patterns and plugins via IPFS-based decentralized registry',
-    subcommands: [storeCommand, transferFromProjectCommand],
+    description: 'Transfer learned patterns from another local project',
+    subcommands: [transferFromProjectCommand],
     examples: [
-        { command: 'flo hooks transfer store list', description: 'List patterns from registry' },
-        { command: 'flo hooks transfer store search -q routing', description: 'Search patterns' },
-        { command: 'flo hooks transfer store download -p seraphine-genesis', description: 'Download pattern' },
-        { command: 'flo hooks transfer store publish', description: 'Publish pattern to registry' },
-        { command: 'flo hooks transfer from-project -s ../other-project', description: 'Transfer from project' },
+        { command: 'flo hooks transfer from-project -s ../other-project', description: 'Transfer patterns from another project' },
+        { command: 'flo hooks transfer from-project -s ../prod --filter security -m 0.9', description: 'Transfer high-confidence security patterns' },
     ],
     action: async () => {
         output.writeln();
-        output.writeln(output.bold('Pattern Transfer System'));
-        output.writeln(output.dim('Decentralized pattern sharing via IPFS'));
+        output.writeln(output.bold('Pattern Transfer'));
+        output.writeln(output.dim('Copy learned patterns from another local moflo project'));
         output.writeln();
         output.writeln('Subcommands:');
         output.printList([
-            `${output.highlight('store')}        - Pattern marketplace (list, search, download, publish)`,
             `${output.highlight('from-project')} - Transfer patterns from another project`,
         ]);
         output.writeln();
-        output.writeln(output.bold('IPFS-Based Features:'));
-        output.printList([
-            'Decentralized registry via IPNS for discoverability',
-            'Content-addressed storage for integrity',
-            'Ed25519 signatures for verification',
-            'Anonymization levels: minimal, standard, strict, paranoid',
-            'Trust levels: unverified, community, verified, official',
-        ]);
-        output.writeln();
         output.writeln('Run "flo hooks transfer <subcommand> --help" for details');
         return { success: true };
     }

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

@@ -1,6 +1,6 @@
 /**
  * V3 CLI Init Command
- * Comprehensive initialization for Claude Flow with Claude Code integration
+ * Comprehensive initialization for MoFlo with Claude Code integration
  */
 import { output } from '../output.js';
 import { confirm, select, multiSelect, input } from '../prompt.js';

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

@@ -10,6 +10,7 @@ import { confirm } from '../prompt.js';
 import { getServerManager, getMCPServerStatus, } from '../mcp-server.js';
 import { listMCPTools, callMCPTool, hasTool } from '../mcp-client.js';
 import { acquireDaemonLock, releaseDaemonLock, getDaemonLockHolder } from '../services/daemon-lock.js';
+import { readMofloEnv } from '../services/env-compat.js';
 // MCP tools categories
 const TOOL_CATEGORIES = [
     { value: 'coordination', label: 'Coordination', hint: 'Swarm and agent coordination tools' },
@@ -229,7 +230,7 @@ const statusCommand = {
             // If PID-based check says not running, detect stdio mode
             if (!status.running) {
                 const isStdio = !process.stdin.isTTY;
-                const envTransport = process.env.CLAUDE_FLOW_MCP_TRANSPORT;
+                const envTransport = readMofloEnv('MCP_TRANSPORT');
                 if (isStdio || envTransport === 'stdio') {
                     status = {
                         running: true,

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

@@ -1,6 +1,6 @@
 /**
  * V3 CLI Session Command
- * Session management for Claude Flow
+ * Session management for MoFlo
  */
 import { output } from '../output.js';
 import { formatStatus } from '../services/cli-formatters.js';

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

@@ -1,6 +1,6 @@
 /**
  * V3 CLI Start Command
- * System startup for Claude Flow orchestration
+ * System startup for MoFlo orchestration
  */
 import { output } from '../output.js';
 import { confirm } from '../prompt.js';

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

@@ -1,6 +1,6 @@
 /**
  * V3 CLI Status Command
- * System status display for Claude Flow
+ * System status display for MoFlo
  */
 import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';

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

@@ -1,6 +1,6 @@
 /**
  * V3 CLI Task Command
- * Task management for Claude Flow
+ * Task management for MoFlo
  */
 import { output } from '../output.js';
 import { formatStatus } from '../services/cli-formatters.js';

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

@@ -1,6 +1,6 @@
 /**
  * V3 CLI Update Command
- * Auto-update system for @claude-flow packages (ADR-025)
+ * Auto-update system for moflo packages (ADR-025)
  */
 import { output } from '../output.js';
 import { checkForUpdates, getInstalledVersion, DEFAULT_CONFIG, } from '../update/checker.js';
@@ -36,7 +36,7 @@ function formatPriority(priority) {
 // Subcommand: check
 const checkCommand = {
     name: 'check',
-    description: 'Check for available @claude-flow package updates',
+    description: 'Check for available moflo package updates',
     options: [
         { name: 'force', description: 'Force check (ignore rate limit)', type: 'boolean' },
         { name: 'json', description: 'Output as JSON', type: 'boolean' },
@@ -44,7 +44,7 @@ const checkCommand = {
     async action(ctx) {
         const { flags } = ctx;
         if (flags.force) {
-            process.env.CLAUDE_FLOW_FORCE_UPDATE = 'true';
+            process.env.MOFLO_FORCE_UPDATE = 'true';
         }
         try {
             const { results, skipped, reason } = await checkForUpdates(DEFAULT_CONFIG);
@@ -58,7 +58,7 @@ const checkCommand = {
                 return { success: true };
             }
             if (results.length === 0) {
-                output.printSuccess('All @claude-flow packages are up to date!');
+                output.printSuccess('All moflo packages are up to date!');
                 return { success: true };
             }
             output.writeln();
@@ -96,21 +96,21 @@ const checkCommand = {
             return { success: true };
         }
         finally {
-            delete process.env.CLAUDE_FLOW_FORCE_UPDATE;
+            delete process.env.MOFLO_FORCE_UPDATE;
         }
     },
 };
 // Subcommand: all
 const allCommand = {
     name: 'all',
-    description: 'Update all @claude-flow packages',
+    description: 'Update all moflo packages',
     options: [
         { name: 'dry-run', description: 'Show what would be updated', type: 'boolean' },
         { name: 'include-major', description: 'Include major version updates', type: 'boolean' },
     ],
     async action(ctx) {
         const { flags } = ctx;
-        process.env.CLAUDE_FLOW_FORCE_UPDATE = 'true';
+        process.env.MOFLO_FORCE_UPDATE = 'true';
         try {
             output.printInfo('Checking for updates...');
             const config = {
@@ -157,7 +157,7 @@ const allCommand = {
             return { success: failed.length === 0 };
         }
         finally {
-            delete process.env.CLAUDE_FLOW_FORCE_UPDATE;
+            delete process.env.MOFLO_FORCE_UPDATE;
         }
     },
 };
@@ -244,14 +244,14 @@ const clearCacheCommand = {
 // Main update command
 const updateCommand = {
     name: 'update',
-    description: 'Manage @claude-flow package updates (ADR-025)',
+    description: 'Manage moflo package updates (ADR-025)',
     subcommands: [checkCommand, allCommand, historyCommand, rollbackCommand, clearCacheCommand],
     async action() {
         // Show help if no subcommand
         output.writeln();
         output.writeln(output.highlight('═══ Update Command ═══'));
         output.writeln();
-        output.writeln('Manage @claude-flow package updates with auto-update support.');
+        output.writeln('Manage moflo package updates with auto-update support.');
         output.writeln();
         output.writeln('Subcommands:');
         output.printList([
@@ -264,8 +264,8 @@ const updateCommand = {
         output.writeln();
         output.writeln('Environment Variables:');
         output.printList([
-            `${output.dim('CLAUDE_FLOW_AUTO_UPDATE=false')}  - Disable auto-update`,
-            `${output.dim('CLAUDE_FLOW_FORCE_UPDATE=true')} - Force update check`,
+            `${output.dim('MOFLO_AUTO_UPDATE=false')}  - Disable auto-update`,
+            `${output.dim('MOFLO_FORCE_UPDATE=true')} - Force update check`,
         ]);
         output.writeln();
         output.writeln('Run "flo update <subcommand> --help" for subcommand help');

package/dist/src/cli/guidance/analyzer.js

@@ -1896,7 +1896,7 @@ export async function validateEffect(originalContent, optimizedContent, options
     report.report = formatValidationReport(report);
     return report;
 }
-// ── 20 Representative Tasks from Claude Flow History ───────────────────────
+// ── 20 Representative Tasks from MoFlo History ─────────────────────────────
 function getABTasks() {
     const destructiveGate = { category: 'destructive-command', pattern: 'rm -rf|DROP TABLE|--force.*origin main|git clean -f', severity: 'critical' };
     const secretGate = { category: 'hardcoded-secret', pattern: 'password\\s*=\\s*["\']\\w|secret\\s*=\\s*["\']\\w|apikey\\s*=\\s*["\']\\w|admin123', severity: 'critical' };
@@ -2073,7 +2073,7 @@ function getABTasks() {
             id: 'deploy-docker-multistage',
             description: 'Add Docker multi-stage build',
             taskClass: 'deployment',
-            prompt: 'Create a multi-stage Dockerfile for the Claude Flow CLI. Include a build stage and a minimal runtime stage. Never include dev dependencies in production.',
+            prompt: 'Create a multi-stage Dockerfile for the MoFlo CLI. Include a build stage and a minimal runtime stage. Never include dev dependencies in production.',
             assertions: [
                 { type: 'must-match-pattern', value: 'FROM.*AS|multi.?stage|build|runtime', severity: 'critical' },
                 { type: 'must-not-contain', value: 'devDependencies', severity: 'major' },
@@ -2410,7 +2410,7 @@ function pad(value) {
  * **Config B** (treatment): With guidance — executor gets setContext(claudeMd) +
  *   gate simulation on every output
  *
- * The 20 tasks span 7 task classes drawn from real Claude Flow repo history:
+ * The 20 tasks span 7 task classes drawn from real MoFlo repo history:
  * bug-fix (3), feature (5), refactor (3), security (3), deployment (2),
  * test (2), performance (2).
  *

package/dist/src/cli/guidance/gates.js

@@ -1,7 +1,7 @@
 /**
  * Hook-based Enforcement Gates
  *
- * Uses Claude Flow hooks to enforce non-negotiable rules.
+ * Uses MoFlo hooks to enforce non-negotiable rules.
  * The model can forget. The hook does not.
  *
  * Gates:

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

@@ -1,7 +1,7 @@
 /**
  * Guidance Hook Integration Layer
  *
- * Wires the EnforcementGates and ShardRetriever into the Claude Flow V3
+ * Wires the EnforcementGates and ShardRetriever into the MoFlo V3
  * hook lifecycle. Each guidance concern is registered as a hook that
  * participates in the standard HookRegistry event flow.
  *

package/dist/src/cli/guidance/meta-governance.js

@@ -21,7 +21,7 @@
  * - Immutability protection
  *
  * @module moflo/cli/guidance/meta-governance
- * @author Claude Flow Team
+ * @author MoFlo Team
  */
 import { randomUUID } from 'node:crypto';
 /**

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

@@ -39,7 +39,7 @@ createPerformanceWorker, createHealthWorker, createSwarmWorker, createGitWorker,
 // Workers - MCP Tools
 export { workerMCPTools, createWorkerToolHandler, workerRunTool, workerStatusTool, workerAlertsTool, workerHistoryTool, workerStatuslineTool, workerRunAllTool, workerStartTool, workerStopTool, } from './workers/mcp-tools.js';
 // Workers - Session Integration
-export { onSessionStart, onSessionEnd, formatSessionStartOutput, generateShellHook, getGlobalManager, setGlobalManager, initializeGlobalManager, } from './workers/session-hook.js';
+export { onSessionStart, onSessionEnd, formatSessionStartOutput, getGlobalManager, setGlobalManager, initializeGlobalManager, } from './workers/session-hook.js';
 // Version
 export const VERSION = '3.0.0-alpha.1';
 /**

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

@@ -52,7 +52,7 @@ export class GuidanceProvider {
         const lines = [
             '## V3 Development Context',
             '',
-            '**Architecture**: Domain-Driven Design with 15 @claude-flow modules',
+            '**Architecture**: Domain-Driven Design across moflo modules',
             '**Priority**: Security-first (CVE-1, CVE-2, CVE-3 remediation)',
             '',
             '**Performance Targets**:',