moflo 4.13.1 → 4.13.3

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/services/spell-gate.js

@@ -70,10 +70,18 @@ const DIRECTIVE_PATTERNS = [
     /^(also|too|and also)\s+(for|with|on)\b/i,
     /^(what about|how about)\s+(the\s+)?(other|rest|same)\b/i,
 ];
+/**
+ * Phrased as observations, and each says out loud that the bracket comes from a
+ * turn count rather than measured tokens (#1487). This code path has no
+ * transcript to read — it is the legacy `npx flo gate prompt-reminder` CLI, not
+ * the hook — so the honest thing it can do is not sound like a measurement.
+ * Instruction-shaped text the model cannot verify gets obeyed: the old CRITICAL
+ * line had agents abandoning work over a nearly empty window.
+ */
 const BRACKET_MESSAGES = {
-    MODERATE: 'Context: MODERATE. Re-state goal before architectural decisions. Use agents for >300 LOC.',
-    DEPLETED: 'Context: DEPLETED. Checkpoint progress. Recommend /compact or fresh session.',
-    CRITICAL: 'Context: CRITICAL. Stop accepting complex tasks. Commit, store learnings, suggest new session.',
+    MODERATE: 'Context: 11-20 turns since session start (turn count, not measured token usage).',
+    DEPLETED: 'Context: 21-30 turns since session start (turn count, not measured token usage). Checkpointing progress is worth considering.',
+    CRITICAL: 'Context: 30+ turns since session start (turn count, not measured token usage). /compact or a fresh session is worth considering.',
 };
 /** Paths exempt from memory-first gate (they ARE the memory system) */
 const EXEMPT_PATTERNS = [
@@ -329,8 +337,20 @@ export class GateService {
             result.reminder = 'REMINDER: Use TaskCreate before spawning agents.';
         }
         if (this.config.context_tracking) {
+            // Edge-triggered (#1487): the old level-triggered form re-emitted the same
+            // line every turn once past the threshold, with no reset anywhere, so it
+            // read as a standing instruction long after it stopped being true.
+            //
+            // Derived from the counter rather than remembered in a field, deliberately.
+            // This file and bin/gate.cjs write the SAME .claude/workflow-state.json,
+            // and gate.cjs owns `contextBand` with a richer vocabulary (`tokens:400000`
+            // as well as the brackets). A second writer with an incompatible vocabulary
+            // would silently invalidate gate.cjs's edge-trigger on any project wired to
+            // both. Comparing this turn's bracket with the previous turn's is exactly
+            // the same edge, needs no state, and cannot collide.
             const bracket = this.getContextBracket(state.interactionCount);
-            if (bracket !== 'FRESH') {
+            const previous = this.getContextBracket(state.interactionCount - 1);
+            if (bracket !== 'FRESH' && bracket !== previous) {
                 result.bracket = BRACKET_MESSAGES[bracket];
             }
         }

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

package/package.json

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