moflo 4.13.4 → 4.13.5

package/bin/generate-code-map.mjs

@@ -25,7 +25,7 @@
  *   flo-codemap                                              # Via PATH
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { resolve, dirname, relative, basename, extname } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync, execFileSync, spawn } from 'child_process';
@@ -33,6 +33,7 @@ import { memoryDbPath, MOFLO_DIR, findProjectRoot } from './lib/moflo-paths.mjs'
 import { openBackend } from './lib/get-backend.mjs';
 import { applyIncrementalChunks, schemeTaggedContentHash } from './lib/incremental-write.mjs';
 import { resolveMofloBin } from './lib/resolve-bin.mjs';
+import { listScopedSourceFiles } from './lib/source-scope.mjs';
 
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -50,13 +51,10 @@ const HASH_CACHE_PATH = resolve(projectRoot, MOFLO_DIR, 'code-map-hash.txt');
 // delegates here rather than shipping a second, divergent generator.
 // v2: unified scheme — invalidates every pre-#1260 cache (bare hash or the
 // old directory-level `flo memory code-map` output) exactly once on pickup.
-const SCHEME_VERSION = 2;
-
-// Directories to exclude from indexing
-const EXCLUDE_DIRS = [
-  'node_modules', 'dist', 'build', '.next', 'coverage',
-  '.claude', 'template', 'back-office-template',
-];
+// v3: #1497 — enumeration now honours code_map.directories/exclude on the git
+// path and drops test files, so every consumer's code-map rebuilds once and
+// the orphan sweep removes the out-of-scope rows.
+const SCHEME_VERSION = 3;
 
 // Heuristic descriptions for well-known directory names
 const DIR_DESCRIPTIONS = {
@@ -163,53 +161,6 @@ function countMissingEmbeddings(db) {
 // Source file enumeration — git ls-files with filesystem fallback
 // ---------------------------------------------------------------------------
 
-/** Read code_map config from moflo.yaml (directories, extensions, exclude). */
-function readCodeMapConfig() {
-  const defaults = {
-    directories: ['src'],
-    extensions: [
-      '.ts', '.tsx', '.js', '.mjs', '.cjs', '.jsx', // JS/TS
-      '.py', '.pyi',                                  // Python
-      '.go',                                           // Go
-      '.java', '.kt', '.kts',                         // JVM
-      '.cs',                                           // C#
-      '.rs',                                           // Rust
-      '.rb',                                           // Ruby
-      '.swift',                                        // Swift
-      '.php',                                          // PHP
-      '.c', '.h', '.cpp', '.hpp', '.cc',              // C/C++
-    ],
-    exclude: [...EXCLUDE_DIRS],
-  };
-  try {
-    const yamlPath = resolve(projectRoot, 'moflo.yaml');
-    if (!existsSync(yamlPath)) return defaults;
-    const content = readFileSync(yamlPath, 'utf-8');
-    // Simple YAML parsing for code_map block
-    const block = content.match(/code_map:\s*\n((?:\s+\w+:.*\n?|\s+- .*\n?)+)/);
-    if (!block) return defaults;
-    const lines = block[1].split('\n');
-    let currentKey = null;
-    const result = { ...defaults };
-    for (const line of lines) {
-      const keyMatch = line.match(/^\s+(\w+):/);
-      const itemMatch = line.match(/^\s+- (.+)/);
-      if (keyMatch) {
-        currentKey = keyMatch[1];
-        // Inline array: extensions: [".ts", ".tsx"]
-        const inlineArray = line.match(/\[([^\]]+)\]/);
-        if (inlineArray && (currentKey === 'extensions' || currentKey === 'exclude' || currentKey === 'directories')) {
-          result[currentKey] = inlineArray[1].split(',').map(s => s.trim().replace(/^["']|["']$/g, ''));
-        }
-      } else if (itemMatch && currentKey) {
-        if (!Array.isArray(result[currentKey])) result[currentKey] = [];
-        result[currentKey].push(itemMatch[1].trim().replace(/^["']|["']$/g, ''));
-      }
-    }
-    return result;
-  } catch { return defaults; }
-}
-
 /**
  * Extension of `p`, lowercased.
  *
@@ -222,75 +173,14 @@ function normExt(p) {
   return extname(p).toLowerCase();
 }
 
-/** Walk a directory tree collecting source files (filesystem fallback). */
-function walkDir(dir, extensions, excludeSet, maxDepth = 8, depth = 0) {
-  if (depth > maxDepth) return [];
-  const results = [];
-  let entries;
-  try {
-    entries = readdirSync(resolve(projectRoot, dir), { withFileTypes: true });
-  } catch { return []; }
-  for (const entry of entries) {
-    if (excludeSet.has(entry.name)) continue;
-    // Use forward slashes for consistent cross-platform paths
-    const rel = dir ? `${dir}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) {
-      results.push(...walkDir(rel, extensions, excludeSet, maxDepth, depth + 1));
-    } else if (entry.isFile()) {
-      if (extensions.has(normExt(entry.name))) results.push(rel);
-    }
-  }
-  return results;
-}
-
+/**
+ * In-scope source files (#1497): `code_map.directories` minus `code_map.exclude`,
+ * never gitignored, never a test file — on the git path and the fallback alike.
+ */
 function getSourceFiles() {
-  const config = readCodeMapConfig();
-  // Lowercase the configured list too, so `extensions: [".MJS"]` in a consumer's
-  // moflo.yaml still matches the normalised extension of a scanned file.
-  const extSet = new Set(config.extensions.map(e => e.toLowerCase()));
-  const excludeSet = new Set(config.exclude);
-
-  // Build git glob patterns from configured extensions.
-  // `:(icase)` is required, not cosmetic: git pathspec globs are case-sensitive
-  // regardless of `core.ignorecase` (verified on git 2.43 with the setting both
-  // on and off), so a bare `*.mjs` misses a committed `Foo.MJS` on every
-  // platform. This is the primary enumeration path — normalising `extname()` in
-  // the filesystem fallback alone would leave it broken. (#1337)
-  const gitGlobArgs = config.extensions.map(ext => `:(icase)*${ext}`);
-
-  // Try git ls-files first (fast, respects .gitignore)
-  try {
-    const raw = execFileSync(
-      'git', ['ls-files', '--', ...gitGlobArgs],
-      { cwd: projectRoot, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, windowsHide: true }
-    ).trim();
-
-    if (raw) {
-      const files = raw.split('\n')
-        .map(f => f.replace(/\\/g, '/'))  // normalize separators
-        .filter(f => {
-          for (const ex of EXCLUDE_DIRS) {
-            if (f.startsWith(ex + '/')) return false;
-          }
-          return true;
-        });
-      if (files.length > 0) return files;
-    }
-  } catch {
-    // git not available or not a git repo — fall through
-  }
-
-  // Fallback: walk configured directories from moflo.yaml
-  log('git ls-files returned no files — falling back to filesystem walk');
-  const files = [];
-
-  for (const dir of config.directories) {
-    if (existsSync(resolve(projectRoot, dir))) {
-      files.push(...walkDir(dir, extSet, excludeSet));
-    }
-  }
-
-  return files;
+  return listScopedSourceFiles(projectRoot, {
+    onFallback: () => log('git ls-files returned no files — falling back to filesystem walk'),
+  });
 }
 
 function isUnchanged(currentHash) {

package/bin/index-guidance.mjs

@@ -119,7 +119,18 @@ function loadGuidanceDirs() {
     resolve(bundledGuidanceDir) !== resolve(projectGuidanceDir) &&
     resolve(bundledGuidanceDir) !== resolve(projectGuidanceDir, 'shipped')
   ) {
-    dirs.push({ path: bundledGuidanceDir, prefix: 'moflo-bundled', absolute: true });
+    // #1497 — session-start syncs every shipped doc into `.claude/guidance/`,
+    // so once that copy exists the bundled one is a byte-identical twin that
+    // halves the distinct docs per search. Shadow it — but only when the
+    // project's `.claude/guidance` is itself a configured directory; otherwise
+    // the synced copy is never indexed and the bundled one is the only copy.
+    const projectGuidanceIndexed = userDirs.some(d => resolve(projectRoot, d) === projectGuidanceDir);
+    dirs.push({
+      path: bundledGuidanceDir,
+      prefix: 'moflo-bundled',
+      absolute: true,
+      shadowDir: projectGuidanceIndexed ? projectGuidanceDir : null,
+    });
   }
 
   // 3. CLAUDE.md files are NOT indexed — Claude loads them into context automatically.
@@ -134,7 +145,17 @@ function loadGuidanceDirs() {
   // 5. Bundled moflo skills — gated by isSelfRef to prevent double-indexing
   const bundledSkillsDir = resolve(mofloRoot, '.claude/skills');
   if (!isSelfRef && existsSync(bundledSkillsDir) && resolve(bundledSkillsDir) !== resolve(projectSkillsDir)) {
-    dirs.push({ path: bundledSkillsDir, prefix: 'skill-bundled', fileFilter: ['SKILL.md'], kind: 'skill', absolute: true });
+    // #1497 — skills synced into `.claude/skills/<name>/` are indexed by step 4;
+    // index a bundled skill only when the project holds no copy of it (e.g. a
+    // skill excluded by a `skills: categories` selection).
+    dirs.push({
+      path: bundledSkillsDir,
+      prefix: 'skill-bundled',
+      fileFilter: ['SKILL.md'],
+      kind: 'skill',
+      absolute: true,
+      shadowDir: projectSkillsDir,
+    });
   }
 
   // 6. SDD spec/plan artifacts are NOT indexed.
@@ -683,6 +704,17 @@ function walkMdFiles(dir, excludeRoots = []) {
   return files;
 }
 
+/**
+ * True when a bundled file's project-side copy (same relative path under
+ * `dirConfig.shadowDir`) exists and is therefore indexed by another entry.
+ * Skipping it here also drops it from the run's live prefix set, so the stale
+ * sweep removes rows a previous run wrote for the bundled twin.
+ */
+function isShadowed(dirConfig, dirPath, filePath) {
+  if (!dirConfig.shadowDir) return false;
+  return existsSync(resolve(dirConfig.shadowDir, relative(dirPath, filePath)));
+}
+
 function indexDirectory(db, dirConfig) {
   const dirPath = dirConfig.absolute ? dirConfig.path : resolve(projectRoot, dirConfig.path);
   const results = [];
@@ -693,9 +725,10 @@ function indexDirectory(db, dirConfig) {
   }
 
   const allMdFiles = walkMdFiles(dirPath, EXCLUDE_ROOTS);
-  const filtered = dirConfig.fileFilter
+  const filtered = (dirConfig.fileFilter
     ? allMdFiles.filter(f => dirConfig.fileFilter.includes(basename(f)))
-    : allMdFiles;
+    : allMdFiles
+  ).filter(f => !isShadowed(dirConfig, dirPath, f));
 
   for (const filePath of filtered) {
     let options = {};

package/bin/index-patterns.mjs

@@ -7,7 +7,6 @@
  *   - API route definitions and middleware usage
  *   - Error handling strategies per file
  *   - Export conventions per module
- *   - Test patterns (describe/it structure)
  *   - Configuration patterns
  *
  * Chunk types:
@@ -24,14 +23,15 @@
  *   flo-patterns                                           # Via PATH
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
-import { resolve, dirname, relative, basename, extname } from 'path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { resolve, dirname, relative } from 'path';
 import { fileURLToPath } from 'url';
 import { resolveMofloBin } from './lib/resolve-bin.mjs';
 import { memoryDbPath, MOFLO_DIR, findProjectRoot } from './lib/moflo-paths.mjs';
 import { openBackend } from './lib/get-backend.mjs';
 import { applyIncrementalChunks, computeContentListHash } from './lib/incremental-write.mjs';
 import { createProcessManager } from './lib/process-manager.mjs';
+import { listScopedSourceFiles } from './lib/source-scope.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -48,11 +48,7 @@ const statsOnly = args.includes('--stats');
 function log(msg) { console.log(`[index-patterns] ${msg}`); }
 function debug(msg) { if (verbose) console.log(`[index-patterns]   ${msg}`); }
 
-const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs']);
-const EXCLUDE_DIRS = new Set([
-  'node_modules', 'dist', 'build', '.next', 'coverage',
-  '.claude', '.swarm', '.moflo', '.git', 'template',
-]);
+const SOURCE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs'];
 
 // ---------------------------------------------------------------------------
 // Database helpers
@@ -113,21 +109,15 @@ function countNamespace(db) {
 // File collection
 // ---------------------------------------------------------------------------
 
-function collectSourceFiles(dir, maxDepth = 8, depth = 0) {
-  if (depth > maxDepth) return [];
-  const files = [];
-  let entries;
-  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return []; }
-  for (const entry of entries) {
-    if (EXCLUDE_DIRS.has(entry.name)) continue;
-    const fullPath = resolve(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...collectSourceFiles(fullPath, maxDepth, depth + 1));
-    } else if (entry.isFile() && SOURCE_EXTENSIONS.has(extname(entry.name).toLowerCase())) {
-      files.push(fullPath);
-    }
-  }
-  return files;
+/**
+ * Absolute paths of in-scope source files (#1497). Shares code-map's scope —
+ * `code_map.directories` minus `code_map.exclude`, never gitignored, never a
+ * test file — so a raw repo walk can no longer pull in build output such as
+ * `cdk.out/asset.<hash>/index.mjs` or re-index what the tests namespace owns.
+ */
+function collectSourceFiles() {
+  return listScopedSourceFiles(projectRoot, { extensions: SOURCE_EXTENSIONS })
+    .map(rel => resolve(projectRoot, rel));
 }
 
 // ---------------------------------------------------------------------------
@@ -259,14 +249,14 @@ async function main() {
   if (statsOnly) {
     const db = await getDb();
     const count = countNamespace(db);
-    const files = collectSourceFiles(projectRoot);
+    const files = collectSourceFiles();
     log(`${files.length} source files, ${count} chunks in patterns namespace`);
     db.close();
     return;
   }
 
   // Collect files
-  const files = collectSourceFiles(projectRoot);
+  const files = collectSourceFiles();
   log(`Found ${files.length} source files`);
 
   if (files.length === 0) {

package/bin/lib/index-fingerprint.mjs

@@ -189,6 +189,14 @@ function newestGuidanceMtime(projectRoot) {
   return newest;
 }
 
+function sourceScopeFingerprint(projectRoot) {
+  return {
+    sourceList: gitFileListHash(projectRoot, SOURCE_GLOBS),
+    config: safeMtime(resolve(projectRoot, 'moflo.yaml')),
+    mofloPkg: safeMtime(resolve(projectRoot, 'node_modules/moflo/package.json')),
+  };
+}
+
 /**
  * Per-step fingerprint computers. Each takes `projectRoot` and returns a flat
  * `{ input → value }` object. All MUST be sync, cheap (no sql.js loads), and
@@ -212,9 +220,14 @@ const STEP_FINGERPRINT_COMPUTERS = {
     mofloPkg: safeMtime(resolve(projectRoot, 'node_modules/moflo/package.json')),
   }),
 
-  'code-map':       (projectRoot) => ({ sourceList: gitFileListHash(projectRoot, SOURCE_GLOBS) }),
+  // Source edits, plus the two inputs that change WHICH files are in scope
+  // (#1497): `moflo.yaml` (code_map.directories / exclude) and a moflo upgrade
+  // (the scope rules ship with the package). Without them a scope fix or a
+  // config edit leaves out-of-scope rows in place until some unrelated source
+  // edit happens to invalidate the gate.
+  'code-map':       (projectRoot) => sourceScopeFingerprint(projectRoot),
   'test-index':     (projectRoot) => ({ testList:   gitFileListHash(projectRoot, TEST_GLOBS) }),
-  'patterns-index': (projectRoot) => ({ sourceList: gitFileListHash(projectRoot, SOURCE_GLOBS) }),
+  'patterns-index': (projectRoot) => sourceScopeFingerprint(projectRoot),
 
   // Library-docs grounding (#1184). Re-index when installed dependency versions
   // change — which rewrites the lockfile (npm/yarn/pnpm/bun) — or when the dep

package/bin/lib/source-scope.mjs

@@ -0,0 +1,219 @@
+/**
+ * Source-file scope shared by the code-map and patterns indexers (#1497).
+ *
+ * Both indexers used to enumerate the whole repository: code-map ran
+ * `git ls-files` over every tracked file and applied `code_map.directories` /
+ * `code_map.exclude` only in its filesystem fallback, and patterns walked the
+ * raw filesystem with no `.gitignore` handling at all — so gitignored build
+ * output (e.g. `cdk.out/asset.<hash>/index.mjs`) and every test file landed in
+ * semantic search. One scope, applied on every enumeration path, keeps them in
+ * step with each other and with what `moflo.yaml` says.
+ *
+ * Scope rules:
+ *   - Only files under a configured `code_map.directories` entry (`.` = repo).
+ *   - Never a gitignored file: enumeration is `git ls-files --cached --others
+ *     --exclude-standard`, i.e. tracked files plus untracked-but-not-ignored.
+ *   - Never a path matched by `code_map.exclude` — a bare name matches any
+ *     path segment, a name containing `/` matches a repo-relative path prefix.
+ *   - Never a test file — the `tests` namespace owns those.
+ *
+ * All returned paths are repo-relative with forward slashes on every platform.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { resolve, extname } from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+/**
+ * Top-level directories never indexed, whatever the config says. Kept as
+ * top-level prefixes (not segment matches) so a legitimate nested
+ * `src/template/` is not swallowed by the `template` entry.
+ */
+export const BASELINE_EXCLUDE_DIRS = [
+  'node_modules', 'dist', 'build', '.next', 'coverage',
+  '.claude', '.swarm', '.moflo', '.git', 'template', 'back-office-template',
+];
+
+/** Same shapes `bin/index-tests.mjs` and `moflo.yaml tests.patterns` treat as tests. */
+const TEST_FILE_PATTERNS = [/\.test\.\w+$/i, /\.spec\.\w+$/i, /\.test-\w+\.\w+$/i];
+
+const DEFAULT_EXTENSIONS = [
+  '.ts', '.tsx', '.js', '.mjs', '.cjs', '.jsx', // JS/TS
+  '.py', '.pyi',                                  // Python
+  '.go',                                           // Go
+  '.java', '.kt', '.kts',                         // JVM
+  '.cs',                                           // C#
+  '.rs',                                           // Rust
+  '.rb',                                           // Ruby
+  '.swift',                                        // Swift
+  '.php',                                          // PHP
+  '.c', '.h', '.cpp', '.hpp', '.cc',              // C/C++
+];
+
+/** Read the `code_map` block from moflo.yaml (directories, extensions, exclude). */
+export function readCodeMapConfig(projectRoot) {
+  // Unconfigured `directories` means the whole repo — the scope code-map's git
+  // path and the patterns walk both had before #1497. A consumer whose
+  // moflo.yaml predates `code_map` (or omits `directories`) must not silently
+  // drop to `src/` only, or to nothing at all when there is no `src/` (Rule #2).
+  const defaults = {
+    directories: ['.'],
+    extensions: [...DEFAULT_EXTENSIONS],
+    exclude: [...BASELINE_EXCLUDE_DIRS],
+  };
+  try {
+    const yamlPath = resolve(projectRoot, 'moflo.yaml');
+    if (!existsSync(yamlPath)) return defaults;
+    const content = readFileSync(yamlPath, 'utf-8');
+    // Simple YAML parsing for code_map block
+    // Indented `#` lines are allowed inside the block so a commented-out list
+    // entry does not end it early and drop every entry after it.
+    const block = content.match(/code_map:\s*\n((?:\s+\w+:.*\n?|\s+- .*\n?|[ \t]+#.*\n?)+)/);
+    if (!block) return defaults;
+    const lines = block[1].split(/\r?\n/);
+    let currentKey = null;
+    const result = { ...defaults };
+    for (const line of lines) {
+      const keyMatch = line.match(/^\s+(\w+):/);
+      const itemMatch = line.match(/^\s+- (.+)/);
+      if (keyMatch) {
+        currentKey = keyMatch[1];
+        // Inline array: extensions: [".ts", ".tsx"]
+        const inlineArray = line.match(/\[([^\]]+)\]/);
+        if (inlineArray && (currentKey === 'extensions' || currentKey === 'exclude' || currentKey === 'directories')) {
+          result[currentKey] = inlineArray[1].split(',').map(s => s.trim().replace(/^["']|["']$/g, ''));
+        } else if (currentKey === 'directories' || currentKey === 'exclude' || currentKey === 'extensions') {
+          // Block list follows — start from empty rather than appending to the defaults.
+          result[currentKey] = [];
+        }
+      } else if (itemMatch && currentKey) {
+        if (!Array.isArray(result[currentKey])) result[currentKey] = [];
+        result[currentKey].push(itemMatch[1].trim().replace(/^["']|["']$/g, ''));
+      }
+    }
+    return result;
+  } catch { return defaults; }
+}
+
+/** Normalise a config path to repo-relative forward-slash form ('' = repo root). */
+function normRel(p) {
+  return String(p).replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, '').replace(/^\.$/, '');
+}
+
+// Rule #1: NTFS and APFS are case-insensitive by default, so `Src/` in config
+// must still match git's `src/...` there. Linux compares exactly.
+const foldCase = process.platform === 'win32' || process.platform === 'darwin'
+  ? (s) => s.toLowerCase()
+  : (s) => s;
+
+const underPrefix = (path, prefix) => prefix === '' || path === prefix || path.startsWith(prefix + '/');
+
+export function isTestFile(relPath) {
+  const name = relPath.slice(relPath.lastIndexOf('/') + 1);
+  return TEST_FILE_PATTERNS.some(p => p.test(name));
+}
+
+/**
+ * Build the in-scope predicate for a repo-relative forward-slash path.
+ * Exported for tests; indexers should call {@link listScopedSourceFiles}.
+ */
+export function createScopeFilter(config) {
+  const dirs = (config.directories || []).map(d => foldCase(normRel(d)));
+  const exts = new Set((config.extensions || []).map(e => e.toLowerCase()));
+  const excludeNames = new Set();
+  const excludePrefixes = [];
+  for (const raw of config.exclude || []) {
+    const e = foldCase(normRel(raw));
+    if (!e) continue;
+    if (e.includes('/')) excludePrefixes.push(e);
+    else excludeNames.add(e);
+  }
+  const baseline = BASELINE_EXCLUDE_DIRS.map(foldCase);
+
+  return (relPath) => {
+    const p = foldCase(relPath);
+    if (!exts.has(extname(p).toLowerCase())) return false;
+    if (!dirs.some(d => underPrefix(p, d))) return false;
+    if (baseline.some(b => p.startsWith(b + '/'))) return false;
+    if (excludePrefixes.some(e => underPrefix(p, e))) return false;
+    const segments = p.split('/');
+    if (segments.some(s => excludeNames.has(s))) return false;
+    return !isTestFile(p);
+  };
+}
+
+/**
+ * Git enumeration: tracked files plus untracked-but-not-ignored files, so a
+ * gitignored build artefact is never returned and a brand-new source file is.
+ * Returns null when git is unavailable or this is not a work tree.
+ */
+function gitListFiles(projectRoot, extensions) {
+  // `:(icase)` — git pathspec globs are case-sensitive regardless of
+  // `core.ignorecase`, so a bare `*.mjs` would miss a committed `Foo.MJS` (#1337).
+  const pathspecGlobs = extensions.map(ext => `:(icase)*${ext}`);
+  try {
+    const raw = execFileSync(
+      'git', ['ls-files', '--cached', '--others', '--exclude-standard', '--', ...pathspecGlobs],
+      // stderr ignored: "not a git repository" is the expected fallback signal,
+      // not something to print into a consumer's session-start output.
+      {
+        cwd: projectRoot, encoding: 'utf-8', maxBuffer: 64 * 1024 * 1024, windowsHide: true,
+        stdio: ['ignore', 'pipe', 'ignore'],
+      },
+    ).trim();
+    if (!raw) return null;
+    // --cached + --others can list a path twice (e.g. mid-merge); the caller dedupes.
+    return raw.split(/\r?\n/).map(f => f.replace(/\\/g, '/'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Filesystem fallback: walk each configured directory. Only the two trees that
+ * are never source are pruned here (for speed); the scope filter decides the rest.
+ */
+const WALK_PRUNE = new Set(['node_modules', '.git']);
+
+function walkFiles(projectRoot, rel, maxDepth = 8, depth = 0, out = []) {
+  if (depth > maxDepth) return out;
+  let entries;
+  try {
+    entries = readdirSync(resolve(projectRoot, rel || '.'), { withFileTypes: true });
+  } catch { return out; }
+  for (const entry of entries) {
+    const child = rel ? `${rel}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      if (WALK_PRUNE.has(entry.name)) continue;
+      walkFiles(projectRoot, child, maxDepth, depth + 1, out);
+    } else if (entry.isFile()) {
+      out.push(child);
+    }
+  }
+  return out;
+}
+
+/**
+ * Every in-scope source file, repo-relative with forward slashes, sorted.
+ *
+ * @param {string} projectRoot
+ * @param {{ extensions?: string[], config?: object, onFallback?: () => void }} [opts]
+ *   `extensions` overrides `code_map.extensions` (patterns has its own list);
+ *   `config` bypasses the moflo.yaml read (tests).
+ */
+export function listScopedSourceFiles(projectRoot, opts = {}) {
+  const config = { ...(opts.config || readCodeMapConfig(projectRoot)) };
+  if (opts.extensions) config.extensions = opts.extensions;
+  const inScope = createScopeFilter(config);
+
+  let candidates = gitListFiles(projectRoot, config.extensions);
+  if (!candidates) {
+    opts.onFallback?.();
+    candidates = [];
+    for (const dir of config.directories) {
+      const rel = normRel(dir);
+      if (existsSync(resolve(projectRoot, rel || '.'))) walkFiles(projectRoot, rel, 8, 0, candidates);
+    }
+  }
+  return [...new Set(candidates.filter(inScope))].sort();
+}

package/dist/src/cli/memory/bridge-embedder.js

@@ -76,6 +76,11 @@ export const EMBEDDING_MODEL_LEGACY_DEFAULT = 'local';
  * `tasklist`, because the dashboard's Flo Runs tab
  * (`daemon-dashboard.ts handleSpells`) reads tasklist; purging it on every
  * session would empty the tab between sessions (#968).
+ *
+ * `verify` is deliberately NOT here (decided in #1497): `/verify` Step 0 runs a
+ * semantic `memory_search` over that namespace to surface prior verdicts for
+ * the area being changed, which needs embeddings. Its size is bounded by
+ * {@link VERIFY_RETENTION_CAP} instead.
  */
 export const EPHEMERAL_NAMESPACES = new Set([
     'hive-mind',

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.13.4",
+  "version": "4.13.5",
   "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",
@@ -99,7 +99,7 @@
     "@typescript-eslint/parser": "^8.65.0",
     "eslint": "^10.8.0",
     "glob": "^11.1.0",
-    "moflo": "^4.13.3",
+    "moflo": "^4.13.4",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"