moflo 4.13.2 → 4.13.3

package/bin/build-embeddings.mjs

@@ -20,7 +20,7 @@ import { existsSync, readFileSync } from 'fs';
 import { mofloInternalURL } from './lib/moflo-resolve.mjs';
 import { memoryDbPath, hnswIndexPath, findProjectRoot } from './lib/moflo-paths.mjs';
 import { openBackend } from './lib/get-backend.mjs';
-import { PENDING_EMBEDDING_WHERE } from './lib/embedding-backlog.mjs';
+import { DELIBERATELY_UNEMBEDDED_WHERE, EMBEDDABLE_WHERE, PENDING_EMBEDDING_WHERE } from './lib/embedding-backlog.mjs';
 const FASTEMBED_INLINE = 'dist/src/cli/embeddings/fastembed-inline/index.js';
 const BRIDGE_CORE = 'dist/src/cli/memory/bridge-core.js';
 const HNSW_PERSISTENCE = 'dist/src/cli/memory/hnsw-persistence.js';
@@ -100,12 +100,12 @@ function saveDb(db) {
 // The backlog clause is imported, not restated (#1383): the indexer gate asks
 // this exact question to decide whether to run this script at all, and a gate
 // that approximates its step's own query is how new chunks got left unembedded
-// in the first place. `PENDING_EMBEDDING_WHERE` already carries `status =
-// 'active'`, so the non-forced branch below replaces the base clause rather
-// than appending to it.
+// in the first place. Both clauses carry `status = 'active'` and exclude rows
+// deliberately left unembedded (ephemeral namespaces, opt-outs — #1492), so
+// `--force` re-embeds everything embeddable without resurrecting those.
 function getEntriesNeedingEmbeddings(db, namespace, forceAll) {
   let sql = `SELECT id, key, namespace, content FROM memory_entries WHERE `
-    + (forceAll ? `status = 'active'` : PENDING_EMBEDDING_WHERE);
+    + (forceAll ? EMBEDDABLE_WHERE : PENDING_EMBEDDING_WHERE);
   const params = [];
 
   if (namespace) {
@@ -136,7 +136,7 @@ function getNamespaceStats(db) {
       namespace,
       COUNT(*) as total,
       SUM(CASE WHEN embedding IS NOT NULL AND embedding != '' THEN 1 ELSE 0 END) as vectorized,
-      SUM(CASE WHEN embedding IS NULL OR embedding = '' THEN 1 ELSE 0 END) as missing
+      SUM(CASE WHEN (embedding IS NULL OR embedding = '') AND NOT ${DELIBERATELY_UNEMBEDDED_WHERE} THEN 1 ELSE 0 END) as missing
     FROM memory_entries
     WHERE status = 'active'
     GROUP BY namespace

package/bin/lib/embedding-backlog.mjs

@@ -26,16 +26,65 @@ import { existsSync } from 'node:fs';
 import { openBackendSync } from './get-backend.mjs';
 import { memoryDbPath } from './moflo-paths.mjs';
 
-/**
- * Rows `build-embeddings` will pick up on its next run. Active rows whose
- * embedding is absent — either NULL (never written) or empty string (a
- * producer that failed and wrote a placeholder).
- */
 /** Retry budget for the probe's read-only open. See {@link hasPendingEmbeddings}. */
 const PROBE_BUSY_TIMEOUT_MS = 2000;
 
+/**
+ * Mirrors of `EPHEMERAL_NAMESPACES` / `EPHEMERAL_NAMESPACE_PREFIXES` /
+ * `EMBEDDING_MODEL_OPT_OUT` in `src/cli/memory/bridge-embedder.ts`. `bin/`
+ * cannot import TypeScript source, so the values are restated here and
+ * `tests/bin/embedding-backfill-ephemeral-1492.test.ts` fails if the two
+ * copies drift.
+ */
+export const EPHEMERAL_NAMESPACES = Object.freeze([
+  'hive-mind',
+  'tasklist',
+  'epic-state',
+  'test-bridge-fix',
+  'swarm-agents',
+  'swarm-topology',
+  'swarm-tasks',
+  'swarm-consensus',
+]);
+export const EPHEMERAL_NAMESPACE_PREFIXES = Object.freeze([]);
+export const EMBEDDING_MODEL_OPT_OUT = 'none';
+
+const sqlString = (s) => `'${s.replace(/'/g, "''")}'`;
+
+/**
+ * Rows written deliberately without an embedding — ephemeral run state and
+ * explicit opt-outs. The writers leave `embedding` NULL for these, which is
+ * indistinguishable from "not embedded yet" unless every backfill excludes
+ * them (#1492). Inlined literals rather than bindings so the clause drops into
+ * any statement unchanged; every value is a compile-time constant above.
+ */
+export const DELIBERATELY_UNEMBEDDED_WHERE = (() => {
+  const clauses = [];
+  if (EPHEMERAL_NAMESPACES.length > 0) {
+    clauses.push(`namespace IN (${EPHEMERAL_NAMESPACES.map(sqlString).join(', ')})`);
+  }
+  for (const prefix of EPHEMERAL_NAMESPACE_PREFIXES) clauses.push(`namespace LIKE ${sqlString(`${prefix}%`)}`);
+  clauses.push(`COALESCE(embedding_model, '') = ${sqlString(EMBEDDING_MODEL_OPT_OUT)}`);
+  // COALESCE to a strict 0/1: `namespace` is nullable and `NULL IN (...)` is
+  // NULL, so every negated use below would silently drop a NULL-namespace row.
+  return `COALESCE((${clauses.join(' OR ')}), 0)`;
+})();
+
+/**
+ * Every row a backfill may embed: active, and not deliberately unembedded.
+ * `build-embeddings --force` selects on this alone.
+ */
+export const EMBEDDABLE_WHERE = `status = 'active' AND NOT ${DELIBERATELY_UNEMBEDDED_WHERE}`;
+
+/**
+ * Rows `build-embeddings` will pick up on its next run. Embeddable rows whose
+ * embedding is absent — either NULL (never written) or empty string (a
+ * producer that failed and wrote a placeholder). The embedding test leads so
+ * the steady-state probe — nearly every row embedded — rejects each row before
+ * evaluating the exclusion.
+ */
 export const PENDING_EMBEDDING_WHERE =
-  `status = 'active' AND (embedding IS NULL OR embedding = '')`;
+  `(embedding IS NULL OR embedding = '') AND ${EMBEDDABLE_WHERE}`;
 
 /**
  * Does the memory DB hold rows that still need embedding?

package/bin/session-start-launcher.mjs

@@ -2438,6 +2438,12 @@ try {
         `${plural(result.superseded, 'stale learnings row')} whose verdict already exists in the verify namespace`,
       );
     }
+    if (result?.stripped > 0) {
+      emitMutation(
+        'unindexed run records',
+        `${plural(result.stripped, 'row')} of run state removed from semantic search`,
+      );
+    }
   }
 } catch (err) {
   // Non-fatal — leftover rows just sit until the next session retries.

package/dist/src/cli/commands/doctor-embedding-hygiene.js

@@ -17,7 +17,7 @@
  *      row on the canonical label; this check verifies it actually did.
  *
  * Story #729 carve-out: ephemeral-namespace rows (tasklist, hive-mind,
- * epic-state, test-bridge-fix, plus EPHEMERAL_NAMESPACE_PREFIXES) are
+ * epic-state, swarm-*, …, plus EPHEMERAL_NAMESPACE_PREFIXES) are
  * intentionally written with `embedding IS NULL AND embedding_model IS
  * NULL`. They are excluded from the count so they don't trip branch (4)
  * "unrecognised embedding_model" on every publish — see bridge-embedder.ts
@@ -33,7 +33,7 @@ import { existsSync } from 'fs';
 import { CANONICAL_EMBEDDING_MODEL } from '../embeddings/migration/types.js';
 import { memoryDbCandidatePaths } from '../services/moflo-paths.js';
 import { openDaemonDatabase } from '../memory/daemon-backend.js';
-import { EPHEMERAL_NAMESPACES, EPHEMERAL_NAMESPACE_PREFIXES, } from '../memory/bridge-embedder.js';
+import { ephemeralNamespaceSql } from '../memory/bridge-embedder.js';
 import { resolveStateRoot } from '../services/project-root.js';
 /**
  * Known neural-model labels that all share the all-MiniLM-L6-v2 384-dim
@@ -183,21 +183,9 @@ async function loadModelGroups(dbPath) {
         // embedding_model IS NULL`. Without this exclusion every spell run that
         // logs to `tasklist` re-trips branch (4) "unrecognised embedding_model"
         // on the next publish, even though the writer is doing the right thing.
-        const ephemeralNames = [...EPHEMERAL_NAMESPACES];
-        const ephemeralPrefixes = [...EPHEMERAL_NAMESPACE_PREFIXES];
-        const matchClauses = [];
-        const params = [];
-        if (ephemeralNames.length > 0) {
-            matchClauses.push(`namespace IN (${ephemeralNames.map(() => '?').join(', ')})`);
-            params.push(...ephemeralNames);
-        }
-        for (const prefix of ephemeralPrefixes) {
-            matchClauses.push(`namespace LIKE ?`);
-            params.push(`${prefix}%`);
-        }
-        const ephemeralExclusion = matchClauses.length > 0
-            ? `AND NOT (embedding IS NULL AND embedding_model IS NULL AND (${matchClauses.join(' OR ')}))`
-            : '';
+        const ephemeral = ephemeralNamespaceSql();
+        const params = ephemeral.params;
+        const ephemeralExclusion = `AND NOT (embedding IS NULL AND embedding_model IS NULL AND ${ephemeral.sql})`;
         const sql = `SELECT
          COALESCE(embedding_model, 'NULL') AS model,
          COUNT(*) AS n,

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

@@ -1888,9 +1888,13 @@ const rebuildIndexCommand = {
         output.writeln(output.bold('Rebuilding Embedding Index'));
         output.writeln(output.dim('─'.repeat(50)));
         const { db, dbPath } = await openDb(cwd);
-        // Build query
-        let sql = `SELECT id, key, namespace, content FROM memory_entries WHERE status = 'active'`;
-        const params = [];
+        // Build query. Rows deliberately left unembedded (ephemeral namespaces,
+        // explicit opt-outs) are excluded even under --force: NULL there means
+        // "never embed", not "not embedded yet" (#1492).
+        const { backfillExclusionSql } = await import('../memory/bridge-embedder.js');
+        const exclusion = backfillExclusionSql();
+        let sql = `SELECT id, key, namespace, content FROM memory_entries WHERE status = 'active' ${exclusion.sql}`;
+        const params = [...exclusion.params];
         if (!forceAll) {
             sql += ` AND (embedding IS NULL OR embedding = '')`;
         }

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

@@ -53,6 +53,18 @@ export const EMBEDDING_MODEL_LEGACY_DEFAULT = 'local';
  * - `tasklist`      — Spell run records (sp-*) written by spells/core/runner.ts + daemon-dashboard.ts
  * - `epic-state`    — Epic progress (epic-N, story-M) written by commands/epic.ts
  * - `test-bridge-fix` — Single 2026-04-23 row left over from a one-off test
+ * - `swarm-agents`, `swarm-topology`, `swarm-tasks`, `swarm-consensus` —
+ *   coordinator state written through by `swarm/swarm-persistence.ts` and
+ *   read back by key on hydrate, never by similarity (#1492). Embed-skip
+ *   ONLY: they are deliberately absent from the purge sets below, because the
+ *   swarm must survive an MCP-server restart (Story #806).
+ *
+ * The rule is enforced at write time AND at backfill time. The writers leave
+ * `embedding` NULL; every backfill selector (`bin/build-embeddings.mjs`, the
+ * backlog probe in `bin/lib/embedding-backlog.mjs`, `flo memory rebuild-index`)
+ * excludes these rows via {@link backfillExclusionSql} or its `bin/` mirror —
+ * otherwise NULL reads as "not embedded yet" and the backfill embeds them
+ * anyway (#1492). The `bin/` copy is parity-guarded against this set.
  *
  * Membership is also extended by {@link EPHEMERAL_NAMESPACE_PREFIXES} for
  * dynamic-name namespaces (e.g. `doctor-memprobe-<persona>`). Most callers
@@ -70,6 +82,10 @@ export const EPHEMERAL_NAMESPACES = new Set([
     'tasklist',
     'epic-state',
     'test-bridge-fix',
+    'swarm-agents',
+    'swarm-topology',
+    'swarm-tasks',
+    'swarm-consensus',
 ]);
 /**
  * Prefix patterns that extend {@link EPHEMERAL_NAMESPACES} for namespaces
@@ -146,6 +162,47 @@ export function isEphemeralNamespace(namespace) {
     }
     return false;
 }
+/**
+ * SQL match for a namespace set: exact `names` or any `prefixes` (as
+ * `LIKE 'p%'`). Returned parenthesised with positional bindings so callers can
+ * wrap it in `NOT (...)` or use it as a positive filter; an empty set matches
+ * nothing.
+ */
+export function namespaceMatchSql(names, prefixes) {
+    const exact = [...names];
+    const likes = [...prefixes].map((p) => `${p}%`);
+    const clauses = [];
+    // Bare column, not COALESCE'd, so positive filters (the session-start purge)
+    // keep using the namespace index. Negate via `NOT COALESCE(match, 0)`.
+    if (exact.length > 0)
+        clauses.push(`namespace IN (${exact.map(() => '?').join(', ')})`);
+    for (let i = 0; i < likes.length; i++)
+        clauses.push('namespace LIKE ?');
+    return {
+        sql: clauses.length > 0 ? `(${clauses.join(' OR ')})` : '(0)',
+        params: [...exact, ...likes],
+    };
+}
+/** {@link namespaceMatchSql} over the ephemeral (embed-skip) namespaces. */
+export function ephemeralNamespaceSql() {
+    return namespaceMatchSql(EPHEMERAL_NAMESPACES, EPHEMERAL_NAMESPACE_PREFIXES);
+}
+/**
+ * `AND ...` fragment every embedding backfill appends to its selector (#1492):
+ * skip ephemeral namespaces and rows a writer explicitly opted out of
+ * (`embedding_model = 'none'`). Both write a NULL `embedding` that means
+ * "deliberately unembedded", which the backfill must not read as "pending".
+ * Mirrored in `bin/lib/embedding-backlog.mjs` (parity-guarded).
+ */
+export function backfillExclusionSql() {
+    const ephemeral = ephemeralNamespaceSql();
+    return {
+        // COALESCE: `namespace` is nullable and `NOT (NULL IN (...))` is NULL,
+        // which would silently drop a NULL-namespace row from the backfill.
+        sql: `AND NOT COALESCE(${ephemeral.sql}, 0) AND COALESCE(embedding_model, '') <> ?`,
+        params: [...ephemeral.params, EMBEDDING_MODEL_OPT_OUT],
+    };
+}
 /**
  * Return `true` if a namespace should be hard-purged on session start —
  * either an exact member of {@link PURGE_ON_SESSION_START_NAMESPACES} or one

package/dist/src/cli/services/ephemeral-namespace-purge.js

@@ -26,6 +26,16 @@
  *    it on every session start, leaving the tab permanently empty. Trim
  *    instead so users see recent history without unbounded growth.
  *
+ * 4. **Strip vectors** from surviving rows in any ephemeral namespace
+ *    ({@link ephemeralNamespaceSql} — `tasklist`, `swarm-*`, …). Their writers
+ *    leave `embedding` NULL, but until #1492 the background backfill read that
+ *    NULL as "pending" and embedded them, so run records ranked in ordinary
+ *    `memory_search` results. The backfill no longer does; this heals the rows
+ *    every existing install already carries, and re-heals if anything embeds
+ *    them again. Rows are kept — only their vector is cleared, back to the
+ *    shape the writer produced. The next index chain drops them from the HNSW
+ *    sidecar (the DB write invalidates the `hnsw-rebuild` fingerprint).
+ *
  * All passes share the file open + final VACUUM + atomic write, so disk I/O
  * is the same as before. Writes back to disk only when something changed.
  *
@@ -38,7 +48,7 @@
  * @module cli/services/ephemeral-namespace-purge
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { PURGE_ON_SESSION_START_NAMESPACES, PURGE_ON_SESSION_START_PREFIXES, TASKLIST_RETENTION_CAP, VERIFY_RECORD_NAMESPACE, VERIFY_RETENTION_CAP, } from '../memory/bridge-embedder.js';
+import { ephemeralNamespaceSql, namespaceMatchSql, PURGE_ON_SESSION_START_NAMESPACES, PURGE_ON_SESSION_START_PREFIXES, TASKLIST_RETENTION_CAP, VERIFY_RECORD_NAMESPACE, VERIFY_RETENTION_CAP, } from '../memory/bridge-embedder.js';
 import { memoryDbPath } from './moflo-paths.js';
 import { openDaemonDatabase } from '../memory/daemon-backend.js';
 import { resolveStateRoot } from './project-root.js';
@@ -56,7 +66,7 @@ export async function purgeEphemeralNamespaces(options = {}) {
     const fs = await import('fs');
     const path = await import('path');
     const nothingToDo = {
-        purged: 0, trimmed: 0, relocated: 0, superseded: 0,
+        purged: 0, trimmed: 0, relocated: 0, superseded: 0, stripped: 0,
     };
     const dbPath = path.resolve(options.dbPath ?? memoryDbPath(resolveStateRoot()));
     if (!fs.existsSync(dbPath))
@@ -77,18 +87,11 @@ export async function purgeEphemeralNamespaces(options = {}) {
         // Purge match shape: exact namespace IN (...) OR namespace LIKE 'prefix-%'.
         // The prefix clause covers runtime-suffixed namespaces like
         // `doctor-memprobe-<persona>` whose set of suffixes isn't known upfront.
-        const namespaces = Array.from(PURGE_ON_SESSION_START_NAMESPACES);
-        const prefixes = Array.from(PURGE_ON_SESSION_START_PREFIXES);
         const caps = [
             ['tasklist', options.tasklistRetentionCap ?? TASKLIST_RETENTION_CAP],
             [VERIFY_RECORD_NAMESPACE, options.verifyRetentionCap ?? VERIFY_RETENTION_CAP],
         ];
-        const exactClause = namespaces.length
-            ? `namespace IN (${namespaces.map(() => '?').join(', ')})`
-            : '0';
-        const prefixClause = prefixes.map(() => 'namespace LIKE ?').join(' OR ');
-        const purgeWhere = prefixClause ? `(${exactClause} OR ${prefixClause})` : exactClause;
-        const purgeBindings = [...namespaces, ...prefixes.map((p) => `${p}%`)];
+        const { sql: purgeWhere, params: purgeBindings } = namespaceMatchSql(PURGE_ON_SESSION_START_NAMESPACES, PURGE_ON_SESSION_START_PREFIXES);
         // GLOB, not LIKE: SQLite's LIKE is case-INSENSITIVE for ASCII, so
         // `key LIKE 'verify:%'` would also sweep a `Verify:...` row that
         // `gate.cjs`'s `record-verify-outcome` — which tests
@@ -98,6 +101,8 @@ export async function purgeEphemeralNamespaces(options = {}) {
         // so the only wildcard in the pattern is the trailing `*`.
         const strayVerifyWhere = 'namespace = ? AND key GLOB ?';
         const strayVerifyBindings = [LEARNINGS_NAMESPACE, `${VERIFY_RECORD_NAMESPACE}:*`];
+        const ephemeral = ephemeralNamespaceSql();
+        const embeddedEphemeralWhere = `${ephemeral.sql} AND embedding IS NOT NULL`;
         // EVERY column needs a distinct alias. `exec` maps each row to an object
         // keyed by column name, so two columns that SQLite names identically
         // collapse into one and silently shift every later index. Unaliased
@@ -107,11 +112,13 @@ export async function purgeEphemeralNamespaces(options = {}) {
         const countRows = db.exec(`SELECT
          (SELECT COUNT(*) FROM memory_entries WHERE ${purgeWhere}) AS purgeable,
          (SELECT COUNT(*) FROM memory_entries WHERE ${strayVerifyWhere}) AS relocatable,
-         ${caps.map((_, i) => `(SELECT COUNT(*) FROM memory_entries WHERE namespace = ?) AS capTotal${i}`).join(',\n         ')}`, [...purgeBindings, ...strayVerifyBindings, ...caps.map(([ns]) => ns)]);
+         (SELECT COUNT(*) FROM memory_entries WHERE ${embeddedEphemeralWhere}) AS strippable,
+         ${caps.map((_, i) => `(SELECT COUNT(*) FROM memory_entries WHERE namespace = ?) AS capTotal${i}`).join(',\n         ')}`, [...purgeBindings, ...strayVerifyBindings, ...ephemeral.params, ...caps.map(([ns]) => ns)]);
         const counts = countRows[0]?.values?.[0] ?? [];
         const purgeable = Number(counts[0] ?? 0);
         const relocatable = Number(counts[1] ?? 0);
-        const capTotals = caps.map((_, i) => Number(counts[i + 2] ?? 0));
+        const strippable = Number(counts[2] ?? 0);
+        const capTotals = caps.map((_, i) => Number(counts[i + 3] ?? 0));
         let purged = 0;
         if (purgeable > 0) {
             db.run(`DELETE FROM memory_entries WHERE ${purgeWhere}`, purgeBindings);
@@ -136,6 +143,15 @@ export async function purgeEphemeralNamespaces(options = {}) {
             db.run(`UPDATE memory_entries SET namespace = ? WHERE ${strayVerifyWhere}`, [VERIFY_RECORD_NAMESPACE, ...strayVerifyBindings]);
             relocated = db.getRowsModified?.() ?? 0;
         }
+        // After the purge, so rows it already deleted are not counted twice. Model
+        // goes back to NULL — the exact shape the ephemeral writers produce.
+        let stripped = 0;
+        if (strippable > 0) {
+            db.run(`UPDATE memory_entries
+            SET embedding = NULL, embedding_model = NULL, embedding_dimensions = NULL
+          WHERE ${embeddedEphemeralWhere}`, ephemeral.params);
+            stripped = db.getRowsModified?.() ?? 0;
+        }
         let trimmed = 0;
         for (const [i, [ns, cap]] of caps.entries()) {
             // Rows just relocated into `verify` count toward its cap in this same run.
@@ -154,16 +170,18 @@ export async function purgeEphemeralNamespaces(options = {}) {
            )`, [ns, ns, cap]);
             trimmed += db.getRowsModified?.() ?? 0;
         }
-        if (purged === 0 && trimmed === 0 && relocated === 0 && superseded === 0)
+        if (purged === 0 && trimmed === 0 && relocated === 0 && superseded === 0 && stripped === 0) {
             return nothingToDo;
+        }
         // VACUUM only after a DELETE actually freed pages. A relocation is an
-        // UPDATE — it reclaims nothing, so VACUUMing for it would rewrite the whole
-        // file (60+ MB on a populated store) in the foreground of session start for
-        // no benefit. Has to run outside any open transaction; node:sqlite/sql.js
+        // UPDATE that reclaims nothing; a vector strip frees some pages, but later
+        // writes reuse them. VACUUMing for either would rewrite the whole file
+        // (60+ MB on a populated store) in the foreground of session start for no
+        // real benefit. Has to run outside any open transaction; node:sqlite/sql.js
         // both auto-commit each `db.run`, so this is safe to chain.
         if (purged > 0 || trimmed > 0 || superseded > 0)
             db.run('VACUUM');
-        return { purged, trimmed, relocated, superseded };
+        return { purged, trimmed, relocated, superseded, stripped };
     }
     finally {
         db.close();

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.13.2",
+  "version": "4.13.3",
   "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.1",
+    "moflo": "^4.13.2",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"