moflo 4.10.5 → 4.10.7

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

@@ -670,4 +670,109 @@ export async function checkHookBlockDrift() {
         fix: 'set auto_update.hook_block_drift: regenerate in moflo.yaml, or claudeFlow.hooks.locked: true to suppress',
     };
 }
+// ============================================================================
+// 12. CLAUDE.md Injection Drift Check
+// ============================================================================
+/**
+ * Detect when the consumer's `<root>/CLAUDE.md` MoFlo-injected block has
+ * drifted from the canonical block the current `claudemd-generator` produces.
+ * Analogue of `Hook Block Drift` for CLAUDE.md content.
+ *
+ * The session-start launcher refreshes shipped guidance files on every
+ * version change, but the CLAUDE.md injection is only rewritten by explicit
+ * `flo init` / `flo-setup`. Without this check, consumers carry stale
+ * injection content (and stale guidance pointers) indefinitely.
+ *
+ * Five states map to four reportable statuses:
+ *   no-file       → warn  (run `flo init`)
+ *   no-marker     → warn  (run `flo init` / `flo-setup`)
+ *   legacy-marker → warn  (auto-fixable — replace legacy block)
+ *   in-sync       → pass
+ *   drifted       → warn  (auto-fixable — refresh block)
+ */
+export async function checkClaudeMdInjectionDrift() {
+    const projectDir = findConsumerProjectDir();
+    const claudeMdPath = join(projectDir, 'CLAUDE.md');
+    // Respect `auto_update.claudemd_injection_drift: off` for consumers who
+    // explicitly opt out (mirrors the launcher's behaviour and the Hook Block
+    // Drift check). Read the config first so the off-mode skip is cheap.
+    try {
+        const { loadMofloConfig } = await import('../config/moflo-config.js');
+        const cfg = loadMofloConfig(projectDir);
+        if (cfg.auto_update.claudemd_injection_drift === 'off') {
+            return {
+                name: 'CLAUDE.md Injection Drift',
+                status: 'pass',
+                message: 'drift check skipped — auto_update.claudemd_injection_drift: off',
+            };
+        }
+    }
+    catch { /* config read failure — fall through to drift check */ }
+    if (!existsSync(claudeMdPath)) {
+        return {
+            name: 'CLAUDE.md Injection Drift',
+            status: 'warn',
+            message: 'CLAUDE.md not found',
+            fix: 'npx moflo init',
+        };
+    }
+    let contents;
+    try {
+        contents = readFileSync(claudeMdPath, 'utf-8');
+    }
+    catch (e) {
+        return {
+            name: 'CLAUDE.md Injection Drift',
+            status: 'warn',
+            message: `cannot read CLAUDE.md: ${errorDetail(e)}`,
+        };
+    }
+    // Dynamic-import the generator + drift detector so the dist-vs-source
+    // path resolution stays consistent with the launcher.
+    const { generateClaudeMd } = await import('../init/claudemd-generator.js');
+    const { computeInjectionDrift } = await import('../services/claudemd-injection.js');
+    // Use `{}` (not DEFAULT_INIT_OPTIONS) to match the launcher's call —
+    // the generator ignores the argument, but matching call shape removes the
+    // possibility of a future generator change diverging the two surfaces.
+    const canonical = generateClaudeMd({});
+    const report = computeInjectionDrift(contents, canonical);
+    switch (report.state) {
+        case 'in-sync':
+            return {
+                name: 'CLAUDE.md Injection Drift',
+                status: 'pass',
+                message: 'CLAUDE.md injection block matches reference',
+            };
+        case 'no-marker':
+            return {
+                name: 'CLAUDE.md Injection Drift',
+                status: 'warn',
+                message: 'CLAUDE.md has no MOFLO:INJECTED:START block',
+                fix: 'npx flo-setup',
+            };
+        case 'legacy-marker':
+            return {
+                name: 'CLAUDE.md Injection Drift',
+                status: 'warn',
+                message: 'CLAUDE.md uses a legacy moflo marker pair (pre-MOFLO:INJECTED) — auto-fix replaces with current block',
+                fix: 'npx flo-setup --update',
+            };
+        case 'drifted':
+            return {
+                name: 'CLAUDE.md Injection Drift',
+                status: 'warn',
+                message: 'CLAUDE.md injection block has drifted from reference',
+                fix: 'npx flo-setup --update',
+            };
+        case 'no-file':
+            // Defensive — `existsSync` returned true above, so this branch is
+            // unreachable in practice. Return a sane status anyway.
+            return {
+                name: 'CLAUDE.md Injection Drift',
+                status: 'warn',
+                message: 'CLAUDE.md not found',
+                fix: 'npx moflo init',
+            };
+    }
+}
 //# sourceMappingURL=doctor-checks-deep.js.map

package/dist/src/cli/commands/doctor-fixes.js

@@ -255,6 +255,30 @@ export async function autoFixCheck(check) {
         'Gate Health': async () => {
             return fixGateHealthHooks();
         },
+        // Refresh the consumer's CLAUDE.md MoFlo block in place using the
+        // shared `applyInjectionReplacement` service. Idempotent: a re-run sees
+        // `state === 'in-sync'` and the autoFix dispatcher skips this entry.
+        'CLAUDE.md Injection Drift': async () => {
+            const projectRoot = findProjectRoot();
+            const claudeMdPath = join(projectRoot, 'CLAUDE.md');
+            try {
+                const { generateClaudeMd } = await import('../init/claudemd-generator.js');
+                const { applyInjectionReplacement } = await import('../services/claudemd-injection.js');
+                const canonical = generateClaudeMd({});
+                const existing = existsSync(claudeMdPath) ? readFileSync(claudeMdPath, 'utf-8') : null;
+                const result = applyInjectionReplacement(existing, canonical);
+                if (!result.changed || !result.contents)
+                    return false;
+                // atomicWriteFileSync guards against a concurrent reader (Claude Code
+                // re-scanning CLAUDE.md mid-fix) seeing a truncated file.
+                atomicWriteFileSync(claudeMdPath, result.contents);
+                return true;
+            }
+            catch (e) {
+                output.writeln(output.warning(`  CLAUDE.md repair failed: ${errorDetail(e)}`));
+                return false;
+            }
+        },
         'Embedding hygiene': async () => {
             // The session-start launcher already runs the same migration BEFORE
             // daemon/MCP boot — that's where consumer autoheal happens. Running

package/dist/src/cli/commands/doctor-registry.js

@@ -4,7 +4,7 @@
  * Kept separate from `doctor.ts` so the orchestration file stays small and the
  * registry can be inspected/extended without re-touching command-action code.
  */
-import { checkSubagentHealth, checkSpellExecution, checkMcpToolInvocation, checkHookExecution, checkMcpSpellIntegration, checkGateHealth, checkHookBlockDrift, checkMofloDbBridge, } from './doctor-checks-deep.js';
+import { checkSubagentHealth, checkSpellExecution, checkMcpToolInvocation, checkHookExecution, checkMcpSpellIntegration, checkGateHealth, checkHookBlockDrift, checkClaudeMdInjectionDrift, checkMofloDbBridge, } from './doctor-checks-deep.js';
 import { checkEmbeddingHygiene } from './doctor-embedding-hygiene.js';
 import { checkDaemonVersionSkew } from './doctor-checks-version-skew.js';
 import { checkEmbeddingCoverageTruth } from './doctor-checks-coverage-truth.js';
@@ -63,6 +63,7 @@ export const allChecks = [
     checkHookExecution,
     checkGateHealth,
     checkHookBlockDrift,
+    checkClaudeMdInjectionDrift,
     checkMofloDbBridge,
     // Issue #818 / epic #798 — coordinator-path tripwires. They share the
     // singleton coordinator with checkSubagentHealth above and assert by
@@ -127,6 +128,9 @@ export const componentMap = {
     'gate': checkGateHealth,
     'hook-drift': checkHookBlockDrift,
     'drift': checkHookBlockDrift,
+    'claudemd-drift': checkClaudeMdInjectionDrift,
+    'claudemd': checkClaudeMdInjectionDrift,
+    'injection-drift': checkClaudeMdInjectionDrift,
     'sandbox': checkSandboxTier,
     'sandbox-tier': checkSandboxTier,
     'moflodb': checkMofloDbBridge,

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

@@ -42,7 +42,7 @@ function findMofloRepoRoot(start) {
 }
 export const retireCommand = {
     name: 'retire',
-    description: 'Record a retired shipped file in retired-files.json (moflo dev only) — usage: flo retire <path> [--retired-by #nnn]',
+    description: 'Record a retired shipped file in retired-files.json (moflo dev only) — usage: flo retire <path> [--retired-by #nnn] | flo retire --rebuild-hashes',
     hidden: true,
     options: [
         {
@@ -56,15 +56,16 @@ export const retireCommand = {
             type: 'string',
         },
         {
-            name: 'hashes',
-            description: 'Maximum number of historical content hashes to record (default 3)',
-            type: 'number',
-            default: 3,
+            name: 'rebuild-hashes',
+            description: 'Recompute knownContentHashes[] for every existing entry from full git history (#1133 backfill)',
+            type: 'boolean',
+            default: false,
         },
     ],
     examples: [
         { command: 'flo retire .claude/agents/v3/performance-engineer.md --retired-by #932', description: 'Record a retirement' },
         { command: 'flo retire .claude/skills/skill-builder/SKILL.md --retired-by #945 --retired-in 4.9.21', description: 'Pin retiredIn' },
+        { command: 'flo retire --rebuild-hashes', description: 'Backfill every entry from full git history' },
     ],
     action: async (ctx) => {
         const repoRoot = findMofloRepoRoot(__filename) || findMofloRepoRoot(ctx.cwd);
@@ -73,11 +74,6 @@ export const retireCommand = {
             output.printInfo('retired-files.json lives at the moflo package root and does not ship to consumer projects');
             return { success: false, message: 'not in moflo repo', exitCode: 1 };
         }
-        const path = ctx.args[0];
-        if (!path) {
-            output.printError('Missing required argument: <path>');
-            return { success: false, message: 'missing path', exitCode: 2 };
-        }
         const scriptPath = resolve(repoRoot, 'scripts', 'build-retired-files.mjs');
         if (!existsSync(scriptPath)) {
             output.printError(`scripts/build-retired-files.mjs not found at ${scriptPath}`);
@@ -86,13 +82,22 @@ export const retireCommand = {
         // Parser normalises kebab-case flag names to camelCase before storing
         // (#787). Read as ctx.flags.<camelCase> — bracket-with-kebab is always
         // undefined and ESLint blocks that pattern.
-        const args = ['--add', path];
-        if (ctx.flags.retiredBy)
-            args.push('--retired-by', String(ctx.flags.retiredBy));
-        if (ctx.flags.retiredIn)
-            args.push('--retired-in', String(ctx.flags.retiredIn));
-        if (ctx.flags.hashes)
-            args.push('--hashes', String(ctx.flags.hashes));
+        let args;
+        if (ctx.flags.rebuildHashes) {
+            args = ['--rebuild-hashes'];
+        }
+        else {
+            const path = ctx.args[0];
+            if (!path) {
+                output.printError('Missing required argument: <path> (or pass --rebuild-hashes)');
+                return { success: false, message: 'missing path', exitCode: 2 };
+            }
+            args = ['--add', path];
+            if (ctx.flags.retiredBy)
+                args.push('--retired-by', String(ctx.flags.retiredBy));
+            if (ctx.flags.retiredIn)
+                args.push('--retired-in', String(ctx.flags.retiredIn));
+        }
         const result = spawnSync('node', [scriptPath, ...args], {
             cwd: repoRoot,
             stdio: 'inherit',

package/dist/src/cli/config/moflo-config.js

@@ -83,6 +83,7 @@ const DEFAULT_CONFIG = {
         scripts: true,
         helpers: true,
         hook_block_drift: 'warn',
+        claudemd_injection_drift: 'regenerate',
     },
     sandbox: {
         enabled: false,
@@ -212,6 +213,12 @@ function mergeConfig(raw, root) {
                     ? v
                     : DEFAULT_CONFIG.auto_update.hook_block_drift;
             })(),
+            claudemd_injection_drift: (() => {
+                const v = raw.auto_update?.claudemd_injection_drift ?? raw.autoUpdate?.claudemdInjectionDrift;
+                return v === 'regenerate' || v === 'off' || v === 'warn'
+                    ? v
+                    : DEFAULT_CONFIG.auto_update.claudemd_injection_drift;
+            })(),
         },
         sandbox: {
             enabled: raw.sandbox?.enabled ?? DEFAULT_CONFIG.sandbox.enabled,
@@ -409,6 +416,10 @@ auto_update:
                                  # warn = print drift summary on session start (default)
                                  # regenerate = auto-add missing hooks (only when no customisations)
                                  # off = skip detection entirely
+  claudemd_injection_drift: regenerate  # warn | regenerate | off
+                                 # regenerate = auto-refresh CLAUDE.md MoFlo block on drift (default)
+                                 # warn = print drift summary on session start
+                                 # off = skip detection entirely
 
 # OS-level sandbox for spell bash steps
 # Denylist always runs regardless of this setting

package/dist/src/cli/init/claudemd-generator.js

@@ -60,8 +60,12 @@ ${MARKER_END}`;
 export { MARKER_START, MARKER_END, LEGACY_MARKER_STARTS, LEGACY_MARKER_ENDS };
 /**
  * Generate the MoFlo section to inject into CLAUDE.md.
- * Template parameter is accepted for backward compatibility but ignored —
- * all templates now produce the same minimal injection.
+ *
+ * Both parameters are accepted for backward compatibility but ignored — all
+ * templates produce the same minimal injection and the options shape is no
+ * longer consulted. Optional so callers from both the dev tree (TS) and the
+ * dogfood launcher (plain JS) can invoke as `generateClaudeMd()` /
+ * `generateClaudeMd({})` interchangeably.
  */
 export function generateClaudeMd(_options, _template) {
     return mofloSection() + '\n';

package/dist/src/cli/init/helpers-generator.js

@@ -277,6 +277,10 @@ var command = process.argv[2];
 
 var EXEMPT = ['.claude/', '.claude\\\\', 'CLAUDE.md', 'MEMORY.md', 'workflow-state', 'node_modules', 'moflo.yaml'];
 var DANGEROUS = ['rm -rf /', 'format c:', 'del /s /q c:\\\\', ':(){:|:&};:', 'mkfs.', '> /dev/sda'];
+// #1132 — Bash memory-first gate regexes. See bin/gate.cjs for documentation.
+var CREDIT_MEMORY_SEARCH_RE = /semantic-search|memory search|memory retrieve|memory-search/;
+var READ_LIKE_BASH_RE = /^\\s*(?:cat|head|tail|less|more|bat|xxd|od|hexdump)\\b|^\\s*(?:grep|rg|ag|fgrep|egrep|find|fd)\\b|^\\s*sed\\s+-n\\b|^\\s*awk\\s+(?!.*<<)|^\\s*type\\s+\\S*[\\\\/.]|^\\s*(?:Get-Content|gc|Select-String|sls)\\b/i;
+var BASH_CARVE_OUT_RE = /^\\s*(npm|npx|pnpm|yarn|bun|node|deno|tsx|ts-node)\\s|^\\s*(git|gh|hub)\\s|^\\s*(docker|kubectl|helm|terraform)\\s|^\\s*(curl|wget|http|fetch)\\s|^\\s*(jq|yq|xq)\\s|^\\s*(echo|printf|true|false|sleep|test|\\[)\\s|^\\s*cat\\s+(<<|<<<)|^\\s*cat\\s+[^|]*\\s*>|^\\s*tee\\b|^\\s*find\\s+.+?-(delete|exec\\s+rm)\\b/;
 var DIRECTIVE_RE = /^(yes|no|yeah|yep|nope|sure|ok|okay|correct|right|exactly|perfect)\\b/i;
 var TASK_RE = /\\b(fix|bug|error|implement|add|create|build|write|refactor|debug|test|feature|issue|security|optimi)\\b/i;
 
@@ -340,6 +344,19 @@ function classifyNamespaceHint(promptText) {
   return '';
 }
 
+// #1132 — command-shape namespace classifier for the bash-BLOCK message.
+// SYNC: duplicated verbatim in bin/gate.cjs. See that file for rationale.
+function classifyBashNamespaceHint(cmd) {
+  if (/^\\s*(?:grep|rg|ag|fgrep|egrep|find|fd|Select-String|sls)\\b/i.test(cmd)) {
+    return 'Memory namespace hint: use "code-map" for codebase navigation.';
+  }
+  if (/^\\s*(?:cat|head|tail|less|more|bat|type|Get-Content|gc)\\b.*\\.(?:md|mdx|rst|txt)\\b/i.test(cmd)
+   || /^\\s*(?:cat|head|tail|less|more|bat|type|Get-Content|gc)\\b.*\\b(?:README|CLAUDE|CHANGELOG|CONTRIBUTING|LICENSE)\\b/i.test(cmd)) {
+    return 'Memory namespace hint: search "guidance" and "learnings" for project rules and decisions.';
+  }
+  return '';
+}
+
 function applyPromptStateReset(state, promptText) {
   state.memorySearched = false;
   state.memorySearchedBy = {};
@@ -467,11 +484,29 @@ switch (command) {
     break;
   }
   case 'check-bash-memory': {
+    // #1132 — credit + block. See bin/gate.cjs for full documentation.
     var cmd = process.env.TOOL_INPUT_command || '';
-    if (/semantic-search|memory search|memory retrieve|memory-search/.test(cmd)) {
+    if (CREDIT_MEMORY_SEARCH_RE.test(cmd)) {
       var s = readState();
       if (markMemorySearched(s)) writeState(s);
+      break;
     }
+    if (!config.memory_first) break;
+    if (!READ_LIKE_BASH_RE.test(cmd)) break;
+    if (BASH_CARVE_OUT_RE.test(cmd)) break;
+    var s2 = readState();
+    if (!s2.memoryRequired || isMemorySearchedFor(s2)) break;
+    // Hint precedence: prompt classification → command-shape classification.
+    // See bin/gate.cjs check-bash-memory for full rationale.
+    var hint = s2.lastNamespaceHint || classifyBashNamespaceHint(cmd) || '';
+    process.stderr.write(
+      'BLOCKED: Search memory before reading files via Bash.\\n' +
+      'Example: mcp__moflo__memory_search { query: "<topic>", namespace: "<one of: guidance | code-map | patterns | learnings | tests>" }\\n' +
+      (hint ? hint + '\\n' : '') +
+      'On chunk hits, traverse via mcp__moflo__memory_get_neighbors — see .claude/guidance/moflo-memory-protocol.md\\n' +
+      'Disable per-gate via moflo.yaml: gates: memory_first: false\\n'
+    );
+    process.exit(2);
     break;
   }
   case 'check-task-transition': {

package/dist/src/cli/init/moflo-init.js

@@ -15,7 +15,8 @@ import { execSync } from 'child_process';
 import { locateMofloRootPath } from '../services/moflo-require.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 import { discoverGuidanceDirs, discoverSrcDirs, discoverTestDirs, detectExtensions, renderMofloYaml, } from './moflo-yaml-template.js';
-import { generateClaudeMd as generateMofloSection, MARKER_START, MARKER_END, LEGACY_MARKER_STARTS, LEGACY_MARKER_ENDS, } from './claudemd-generator.js';
+import { generateClaudeMd as generateMofloSection } from './claudemd-generator.js';
+import { applyInjectionReplacement } from '../services/claudemd-injection.js';
 import { DEFAULT_INIT_OPTIONS } from './types.js';
 export { discoverTestDirs };
 // ============================================================================
@@ -400,29 +401,20 @@ function generateSkill(root, force) {
 // ============================================================================
 function generateClaudeMd(root, _force) {
     const claudeMdPath = path.join(root, 'CLAUDE.md');
-    let existing = '';
-    if (fs.existsSync(claudeMdPath)) {
-        existing = fs.readFileSync(claudeMdPath, 'utf-8');
-        // Strip current or legacy MoFlo block so we can re-inject the latest content.
-        const allStartMarkers = [MARKER_START, ...LEGACY_MARKER_STARTS];
-        const allEndMarkers = [MARKER_END, ...LEGACY_MARKER_ENDS];
-        for (let i = 0; i < allStartMarkers.length; i++) {
-            if (existing.includes(allStartMarkers[i])) {
-                const startIdx = existing.indexOf(allStartMarkers[i]);
-                const endIdx = existing.indexOf(allEndMarkers[i]);
-                if (endIdx > startIdx) {
-                    existing = existing.substring(0, startIdx) + existing.substring(endIdx + allEndMarkers[i].length);
-                }
-            }
-        }
-    }
-    // Single source of truth: claudemd-generator.ts owns the section content.
+    const existed = fs.existsSync(claudeMdPath);
+    const existing = existed ? fs.readFileSync(claudeMdPath, 'utf-8') : null;
+    // Single source of truth: claudemd-generator.ts owns the section content,
+    // claudemd-injection.ts owns the marker-replace logic. Replaces in place
+    // when a marker pair (current or legacy) already exists; otherwise creates
+    // a fresh CLAUDE.md or appends to a non-moflo one.
     const canonical = generateMofloSection(DEFAULT_INIT_OPTIONS);
-    const finalContent = existing.trimEnd() + '\n\n' + canonical;
-    fs.writeFileSync(claudeMdPath, finalContent, 'utf-8');
+    const result = applyInjectionReplacement(existing, canonical);
+    if (result.contents !== null && (result.changed || !existed)) {
+        fs.writeFileSync(claudeMdPath, result.contents, 'utf-8');
+    }
     return {
         name: 'CLAUDE.md',
-        status: existing ? 'updated' : 'created',
+        status: existed ? 'updated' : 'created',
         detail: 'MoFlo section injected (~22 lines)',
     };
 }

package/dist/src/cli/init/settings-generator.js

@@ -233,6 +233,9 @@ function generateHooksConfig(config) {
                 hooks: [
                     { type: 'command', command: gateHookCmd('check-dangerous-command'), timeout: 2000 },
                     { type: 'command', command: gateHookCmd('check-before-pr'), timeout: 2000 },
+                    // #1132 — moved from PostToolUse so process.exit(2) actually blocks
+                    // read-like Bash that bypasses the Read/Glob/Grep gates via the shell.
+                    { type: 'command', command: gateHookCmd('check-bash-memory'), timeout: 2000 },
                 ],
             },
             // #931 — TaskCreate REMINDER + namespace hint moved here from
@@ -272,7 +275,7 @@ function generateHooksConfig(config) {
             {
                 matcher: '^Bash$',
                 hooks: [
-                    { type: 'command', command: gateHookCmd('check-bash-memory'), timeout: 2000 },
+                    // #1132 — check-bash-memory moved to PreToolUse (above).
                     { type: 'command', command: gateHookCmd('record-test-run'), timeout: 2000 },
                 ],
             },

package/dist/src/cli/services/claudemd-injection.js

@@ -0,0 +1,173 @@
+/**
+ * CLAUDE.md injection drift detection + replacement (#1142).
+ *
+ * Detects when a consumer's `<root>/CLAUDE.md` carries a MoFlo-injected block
+ * whose content has drifted from what the current generator produces. Catches
+ * the case where a consumer upgrades moflo (so guidance files refresh) but the
+ * CLAUDE.md injection — only rewritten by explicit `flo init` / `flo-setup` —
+ * stays frozen at the prior version's content, sometimes pointing at paths
+ * that no longer exist (e.g. `.claude/guidance/shipped/...` before the
+ * flat-layout cleanup).
+ *
+ * IMPORTANT: This module must remain self-contained with ZERO imports from
+ * other moflo modules (mirrors the constraint on `services/hook-block-hash.ts`
+ * and `services/hook-wiring.ts`). It is dynamically imported at runtime by
+ * `bin/session-start-launcher.mjs` in consumer projects, where transitive
+ * dependencies may not resolve.
+ *
+ * The MoFlo block markers are duplicated from `init/claudemd-generator.ts` on
+ * purpose — the launcher cannot pull in TS dist of init/types.js at runtime,
+ * and a unit test asserts the two stay in sync.
+ */
+// ────────────────────────────────────────────────────────────────────────────
+// Marker constants — kept in sync with init/claudemd-generator.ts
+// ────────────────────────────────────────────────────────────────────────────
+export const MARKER_START = '<!-- MOFLO:INJECTED:START -->';
+export const MARKER_END = '<!-- MOFLO:INJECTED:END -->';
+// Legacy markers from earlier moflo versions — detected on drift checks so we
+// can offer to replace the legacy block with the current marker pair.
+export const LEGACY_MARKER_STARTS = [
+    '<!-- MOFLO:START -->',
+    '<!-- MOFLO:SUBAGENT-PROTOCOL:START -->',
+];
+export const LEGACY_MARKER_ENDS = [
+    '<!-- MOFLO:END -->',
+    '<!-- MOFLO:SUBAGENT-PROTOCOL:END -->',
+];
+// ────────────────────────────────────────────────────────────────────────────
+// Block extraction
+// ────────────────────────────────────────────────────────────────────────────
+/**
+ * Locate the MoFlo-injected block in `claudeMdContents`, normalising line
+ * endings so a CRLF file matches an LF canonical block (Windows consumers
+ * regularly hit this — git autocrlf can flip the source bytes on checkout).
+ *
+ * Returns null when `contents` is null/undefined/empty, or when no marker
+ * pair is found. Includes the marker strings themselves in the extracted
+ * block, matching `MARKER_START…MARKER_END` exactly so a byte-for-byte
+ * compare against the canonical block works.
+ */
+export function extractInjectedBlock(claudeMdContents) {
+    if (!claudeMdContents)
+        return null;
+    const normalised = claudeMdContents.replace(/\r\n/g, '\n');
+    // Try the current marker pair first, then each legacy pair. markerIndex:
+    //   0  → current MARKER_START/MARKER_END
+    //   1+ → LEGACY_MARKER_STARTS[markerIndex - 1] / LEGACY_MARKER_ENDS[markerIndex - 1]
+    const starts = [MARKER_START, ...LEGACY_MARKER_STARTS];
+    const ends = [MARKER_END, ...LEGACY_MARKER_ENDS];
+    for (let i = 0; i < starts.length; i++) {
+        const startIdx = normalised.indexOf(starts[i]);
+        if (startIdx < 0)
+            continue;
+        const endIdx = normalised.indexOf(ends[i], startIdx + starts[i].length);
+        if (endIdx <= startIdx)
+            continue;
+        const endInclusive = endIdx + ends[i].length;
+        return {
+            block: normalised.substring(startIdx, endInclusive),
+            start: startIdx,
+            end: endInclusive,
+            markerIndex: i,
+        };
+    }
+    return null;
+}
+// ────────────────────────────────────────────────────────────────────────────
+// Drift detection
+// ────────────────────────────────────────────────────────────────────────────
+/**
+ * Trim `canonical` to the bytes between (and including) the current MoFlo
+ * markers. `generateClaudeMd()` appends a trailing newline that callers
+ * commonly include in the result; the in-file block does not carry that
+ * newline, so we strip trailing whitespace before comparing.
+ */
+function canonicalBlock(canonical) {
+    return canonical.replace(/\r\n/g, '\n').trimEnd();
+}
+/**
+ * Classify a consumer's CLAUDE.md against the canonical injected block.
+ *
+ * `claudeMdContents` should be the result of `readFileSync(<root>/CLAUDE.md)`
+ * or null/undefined when the file is absent. `canonical` is the output of
+ * `generateClaudeMd({})` from `init/claudemd-generator.ts`.
+ */
+export function computeInjectionDrift(claudeMdContents, canonical) {
+    if (claudeMdContents === null || claudeMdContents === undefined) {
+        return { state: 'no-file' };
+    }
+    const extracted = extractInjectedBlock(claudeMdContents);
+    if (!extracted) {
+        return { state: 'no-marker' };
+    }
+    if (extracted.markerIndex > 0) {
+        return { state: 'legacy-marker', legacyMarkerIndex: extracted.markerIndex - 1 };
+    }
+    const currentBlock = extracted.block;
+    const wantBlock = canonicalBlock(canonical);
+    if (currentBlock === wantBlock) {
+        return { state: 'in-sync' };
+    }
+    return { state: 'drifted' };
+}
+// ────────────────────────────────────────────────────────────────────────────
+// Replacement
+// ────────────────────────────────────────────────────────────────────────────
+/**
+ * Apply the canonical block to `claudeMdContents`, returning the new
+ * contents and a `changed` flag indicating whether any bytes differ. The
+ * caller writes the file (or persists in-memory state) — this function does
+ * no I/O so it's safe to call from any execution context.
+ *
+ * Behavior by input state:
+ *  - `no-file` → returns `{ contents: canonical, changed: true }` so the
+ *    caller can write a fresh CLAUDE.md (e.g. `flo init` first-run).
+ *  - `no-marker` → APPENDS the canonical block to the end of the existing
+ *    contents (matches `bin/setup-project.mjs:updateClaudeMd` append path).
+ *  - `legacy-marker` → REPLACES the legacy block in-place with the canonical block.
+ *  - `in-sync` → no change.
+ *  - `drifted` → REPLACES the existing block in-place with the canonical block.
+ */
+export function applyInjectionReplacement(claudeMdContents, canonical) {
+    const want = canonicalBlock(canonical);
+    if (claudeMdContents === null || claudeMdContents === undefined) {
+        return { contents: `# Project Configuration\n\n${want}\n`, changed: true, state: 'in-sync' };
+    }
+    const extracted = extractInjectedBlock(claudeMdContents);
+    if (!extracted) {
+        // No marker — append the canonical block to the end (idempotent for
+        // future runs because the appended block will then be located on
+        // subsequent extractions).
+        const sep = claudeMdContents.endsWith('\n') ? '\n' : '\n\n';
+        const next = claudeMdContents + sep + want + '\n';
+        return { contents: next, changed: true, state: 'in-sync' };
+    }
+    // We located a marker pair (current or legacy). If content already matches
+    // the canonical block, nothing to do.
+    if (extracted.markerIndex === 0 && extracted.block === want) {
+        return { contents: claudeMdContents, changed: false, state: 'in-sync' };
+    }
+    // Operate on the line-ending-normalised view so the byte offsets we record
+    // line up with the actual replacement window. The output keeps LF endings
+    // — the launcher and setup-project both write LF.
+    const normalised = claudeMdContents.replace(/\r\n/g, '\n');
+    const next = normalised.substring(0, extracted.start) + want + normalised.substring(extracted.end);
+    return { contents: next, changed: true, state: 'in-sync' };
+}
+// ────────────────────────────────────────────────────────────────────────────
+// Human-readable status for healer + launcher output
+// ────────────────────────────────────────────────────────────────────────────
+/**
+ * Short one-line summary describing a drift state. Used by `flo doctor` and
+ * the session-start launcher when reporting status to the user.
+ */
+export function formatInjectionDriftStatus(report) {
+    switch (report.state) {
+        case 'no-file': return 'CLAUDE.md not found';
+        case 'no-marker': return 'CLAUDE.md has no moflo injection block';
+        case 'legacy-marker': return 'CLAUDE.md uses a legacy moflo marker pair';
+        case 'in-sync': return 'CLAUDE.md injection block matches reference';
+        case 'drifted': return 'CLAUDE.md injection block has drifted from reference';
+    }
+}
+//# sourceMappingURL=claudemd-injection.js.map

package/dist/src/cli/services/hook-block-hash.js

@@ -57,7 +57,12 @@ export function getReferenceHookBlock() {
             { matcher: '^Read$', hooks: [gateHook('check-before-read', 3000)] },
             {
                 matcher: '^Bash$',
-                hooks: [gateHook('check-dangerous-command', 2000), gateHook('check-before-pr', 2000)],
+                hooks: [
+                    gateHook('check-dangerous-command', 2000),
+                    gateHook('check-before-pr', 2000),
+                    // #1132 — moved from PostToolUse so process.exit(2) actually blocks.
+                    gateHook('check-bash-memory', 2000),
+                ],
             },
             // #931 — TaskCreate REMINDER + namespace hint advisory at Agent-spawn time.
             // Routed via gate-hook.mjs so HOOK_SESSION_ID is forwarded for per-actor
@@ -72,8 +77,9 @@ export function getReferenceHookBlock() {
             { matcher: '^Agent$', hooks: [handler('post-task', 5000)] },
             { matcher: '^TaskCreate$', hooks: [gateCjs('record-task-created', 2000)] },
             {
+                // #1132 — check-bash-memory moved to PreToolUse (above).
                 matcher: '^Bash$',
-                hooks: [gateHook('check-bash-memory', 2000), gateHook('record-test-run', 2000)],
+                hooks: [gateHook('record-test-run', 2000)],
             },
             { matcher: '^Skill$', hooks: [gateHook('record-skill-run', 2000)] },
             { matcher: '^mcp__moflo__memory_(search|retrieve|list|stats|store)$', hooks: [gateHook('record-memory-searched', 3000)] },

package/dist/src/cli/services/subagent-bootstrap.js

@@ -21,7 +21,7 @@ const BOOTSTRAP_JSON_REL = '.claude/helpers/subagent-bootstrap.json';
 // Defense-in-depth copy of the canonical directive in subagent-bootstrap.json.
 // Kept as a single-line literal so the parity test can verify it matches the
 // JSON via plain substring containment.
-const FALLBACK_DIRECTIVE = 'MANDATORY FIRST ACTION: Your very first tool call MUST be mcp__moflo__memory_search (any query, any namespace). The memory-first gate WILL BLOCK all Glob, Grep, and Read calls until you do this. After memory search, follow `.claude/guidance/moflo-subagents.md` protocol. When a search hit carries `navigation`, you MUST call mcp__moflo__memory_get_neighbors to traverse — calling mcp__moflo__memory_retrieve on every hit is a protocol violation. See `.claude/guidance/moflo-memory-protocol.md`.';
+const FALLBACK_DIRECTIVE = 'MANDATORY FIRST ACTION: Your very first tool call MUST be mcp__moflo__memory_search (any query, any namespace). The memory-first gate WILL BLOCK all Glob, Grep, Read, and read-like Bash (cat/head/tail/grep/find/sed/awk and the Windows/PowerShell equivalents) calls until you do this. Pick the namespace by task: `guidance` for rules and conventions, `code-map` for file structure, `patterns` for proven solutions, `learnings` for past corrections, `tests` for test inventory. After memory search, follow `.claude/guidance/moflo-subagents.md` protocol. When a search hit carries `navigation`, you MUST call mcp__moflo__memory_get_neighbors to traverse — calling mcp__moflo__memory_retrieve on every hit is a protocol violation. See `.claude/guidance/moflo-memory-protocol.md`.';
 function loadDirective() {
     const jsonPath = locateMofloRootPath(BOOTSTRAP_JSON_REL);
     if (!jsonPath) {

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.10.5';
+export const VERSION = '4.10.7';
 //# sourceMappingURL=version.js.map