moflo 4.9.25 → 4.9.27

package/dist/src/cli/mcp-tools/aidefence-moflodb-store.js

@@ -9,8 +9,14 @@
  * adapter is the seam where the bridge is plugged in. Arbitrary values are
  * JSON-serialised into the bridge's `content` field; namespaces are prefixed
  * with `aidefence:` to isolate from general memory entries.
+ *
+ * #981 / #986 — writes funnel through `storeEntry` / `deleteEntry` so the
+ * single-writer daemon-routing preamble (memory-initializer.ts) covers them.
+ * Calling the bridge directly here would bypass the daemon and resurrect
+ * the multi-process clobber.
  */
-import { bridgeStoreEntry, bridgeSearchEntries, bridgeGetEntry, bridgeDeleteEntry, isBridgeAvailable, } from '../memory/memory-bridge.js';
+import { bridgeSearchEntries, bridgeGetEntry, isBridgeAvailable, } from '../memory/memory-bridge.js';
+import { storeEntry, deleteEntry } from '../memory/memory-initializer.js';
 const NS_PREFIX = 'aidefence:';
 function prefixNs(namespace) {
     return `${NS_PREFIX}${namespace}`;
@@ -30,7 +36,7 @@ function safeParse(raw) {
  */
 export class MofloDbAIDefenceStore {
     async store(params) {
-        await bridgeStoreEntry({
+        await storeEntry({
             namespace: prefixNs(params.namespace),
             key: params.key,
             value: JSON.stringify(params.value),
@@ -64,7 +70,7 @@ export class MofloDbAIDefenceStore {
         return safeParse(result.entry.content);
     }
     async delete(namespace, key) {
-        await bridgeDeleteEntry({
+        await deleteEntry({
             namespace: prefixNs(namespace),
             key,
         });

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

@@ -68,8 +68,15 @@ export const REQUIRED_BRIDGE_CONTROLLERS = Object.freeze([
 export function getBridgeLastError() {
     return lastBridgeError;
 }
-function logBridgeError(context, err) {
-    if (process.env.MOFLO_BRIDGE_QUIET)
+/**
+ * Log a bridge error. By default `MOFLO_BRIDGE_QUIET` suppresses the line
+ * to keep test output clean for read-path noise. Pass `{ alwaysLog: true }`
+ * for write-path errors that mean data did NOT reach disk — those MUST
+ * always log, since the quiet env var is for read-path noise control,
+ * not for masking data loss (#982 / #854 / #962 anti-pattern).
+ */
+export function logBridgeError(context, err, opts) {
+    if (process.env.MOFLO_BRIDGE_QUIET && !opts?.alwaysLog)
         return;
     const msg = errorDetail(err);
     console.error(`[moflo] ${context}: ${msg}`);
@@ -186,6 +193,17 @@ export function execRows(db, sql, params) {
  * Persist the in-memory sql.js DB back to disk. sql.js is purely in-memory —
  * without an explicit export+writeFileSync after each mutation, writes vanish
  * when the process exits, which breaks store→retrieve across CLI commands.
+ *
+ * Throws on failure (#982). Callers that issued a mutation MUST treat a
+ * persist throw as the mutation having failed: the in-memory DB still has
+ * the new row, but it never reached disk and dies with the process.
+ *
+ * Pre-#982 this swallowed silently and logged once to stderr — the
+ * `bridgeStoreEntry` path then returned `{ success: true }` despite the
+ * data being lost, the success-lie pattern that cost #854 and #962 too.
+ *
+ * Use {@link tryPersistBridgeDb} for the rare best-effort caller (cache
+ * invalidation, idempotent maintenance) that genuinely doesn't care.
  */
 export function persistBridgeDb(db, dbPath) {
     // Mirror the read-side resolution so writes land where reads come from.
@@ -200,7 +218,24 @@ export function persistBridgeDb(db, dbPath) {
         atomicWriteFileSync(target, db.export());
     }
     catch (err) {
-        logBridgeError('bridge persist failed', err);
+        logBridgeError('bridge persist failed', err, { alwaysLog: true });
+        throw err;
+    }
+}
+/**
+ * Best-effort variant of {@link persistBridgeDb}. Returns `{ ok: false }`
+ * on failure instead of throwing. Reserve for callers where a missed
+ * persist is genuinely acceptable (e.g. cache invalidation that the next
+ * mutation will redo). Always-log policy still applies — write failures
+ * cannot be silenced.
+ */
+export function tryPersistBridgeDb(db, dbPath) {
+    try {
+        persistBridgeDb(db, dbPath);
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err : new Error(String(err)) };
     }
 }
 // Kept in sync with MEMORY_SCHEMA_V3.memory_entries in memory-initializer.ts.

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

@@ -7,9 +7,24 @@
  *
  * @module v3/cli/bridge-entries
  */
-import { cosineSim, execRows, generateId, persistBridgeDb, refreshVectorStatsCache, withDb } from './bridge-core.js';
+import { cosineSim, execRows, generateId, logBridgeError, persistBridgeDb, refreshVectorStatsCache, withDb } from './bridge-core.js';
 import { embeddingResponseFrom, getBridgeEmbedder, resolveBridgeEmbedding } from './bridge-embedder.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
+/**
+ * Run `persistBridgeDb` and convert any throw into a `persist failed:`
+ * error string for the caller. Centralises the #982 single-store /
+ * bulk-store / delete pattern so the failure shape can never drift
+ * across the three call sites.
+ */
+function tryPersist(db, dbPath) {
+    try {
+        persistBridgeDb(db, dbPath);
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: `persist failed: ${errorDetail(err)}` };
+    }
+}
 function makeEntryCacheKey(namespace, key) {
     const safeNs = String(namespace).replace(/:/g, '_');
     const safeKey = String(key).replace(/:/g, '_');
@@ -126,18 +141,54 @@ export async function bridgeStoreEntry(options) {
             now, now,
             ttl ? now + (ttl * 1000) : null,
         ]);
-        persistBridgeDb(ctx.db, options.dbPath);
+        // Honest persist (#982). If atomicWriteFileSync throws (Windows EBUSY
+        // on a daemon-held file, ENOSPC, perm denied, antivirus rename block),
+        // surface it as `success: false` instead of returning a lying success.
+        // Skip post-persist bookkeeping so cache + attestation cannot diverge
+        // from on-disk state.
+        const persisted = tryPersist(ctx.db, options.dbPath);
+        if (!persisted.ok) {
+            return { success: false, id, error: persisted.error };
+        }
+        // Post-persist bookkeeping (#994). The row is durable on disk; cache
+        // warming, attestation, and statusline stats are observability only.
+        // A throw here MUST NOT propagate — withDb would catch it, return null,
+        // and storeEntry would fall back to raw sql.js, which then fails with
+        // UNIQUE constraint (the bridge already wrote the row) and reports
+        // exit 1 even though `memory retrieve` finds the value moments later.
+        // Same #982 invariant in the inverse direction.
         const cacheKey = makeEntryCacheKey(namespace, key);
-        await cacheSet(registry, cacheKey, { id, key, namespace, content: value, embedding: embeddingJson });
-        await logAttestation(registry, 'store', id, { key, namespace, hasEmbedding: !!embeddingJson });
-        if (embeddingJson)
-            refreshVectorStatsCache();
+        let cached = true;
+        try {
+            await cacheSet(registry, cacheKey, { id, key, namespace, content: value, embedding: embeddingJson });
+        }
+        catch (err) {
+            cached = false;
+            logBridgeError('post-persist cache set failed', err);
+        }
+        // logAttestation already swallows internally; the await catches any
+        // pre-call registry-resolution throw too. Logged so a recurring failure
+        // is visible without crashing the write path.
+        try {
+            await logAttestation(registry, 'store', id, { key, namespace, hasEmbedding: !!embeddingJson });
+        }
+        catch (err) {
+            logBridgeError('post-persist attestation failed', err);
+        }
+        if (embeddingJson) {
+            try {
+                refreshVectorStatsCache();
+            }
+            catch (err) {
+                logBridgeError('post-persist stats refresh failed', err);
+            }
+        }
         return {
             success: true,
             id,
             embedding: embeddingResponse,
             guarded: true,
-            cached: true,
+            cached,
             attested: true,
         };
     });
@@ -152,7 +203,13 @@ export async function bridgeStoreEntries(items, dbPath) {
         return [];
     return withDb(dbPath, async (ctx, registry) => {
         const results = [];
-        const bookkeeping = [];
+        /**
+         * Per-item bookkeeping fired AFTER persist succeeds (#982). If we
+         * fired cache/attestation during the loop and then persist threw,
+         * the cache would be warm with rows that never reached disk — the
+         * exact divergence #982 is fixing in the single-store path. Defer.
+         */
+        const deferredBookkeeping = [];
         let anyEmbedded = false;
         let anyWritten = false;
         // Validate the batch once as a single 'bulk-store' mutation. Per-item
@@ -212,23 +269,60 @@ export async function bridgeStoreEntries(items, dbPath) {
             anyWritten = true;
             if (embeddingJson)
                 anyEmbedded = true;
-            const cacheKey = makeEntryCacheKey(namespace, key);
-            bookkeeping.push(cacheSet(registry, cacheKey, { id, key, namespace, content: value, embedding: embeddingJson }));
-            bookkeeping.push(logAttestation(registry, 'store', id, { key, namespace, hasEmbedding: !!embeddingJson }));
+            deferredBookkeeping.push({
+                cacheKey: makeEntryCacheKey(namespace, key),
+                cacheValue: { id, key, namespace, content: value, embedding: embeddingJson },
+                entryId: id,
+                entryKey: key,
+                namespace,
+                hasEmbedding: !!embeddingJson,
+            });
             results.push({
                 success: true,
                 id,
                 embedding: embeddingResponse,
             });
         }
-        // Cache writes and attestation logs are independent post-hoc bookkeeping —
-        // overlap them while the final persist runs. SQL inserts above stayed
-        // sequential because sql.js is single-threaded.
-        await Promise.all(bookkeeping);
-        if (anyWritten)
-            persistBridgeDb(ctx.db, dbPath);
-        if (anyEmbedded)
-            refreshVectorStatsCache();
+        // Honest persist (#982). The whole batch shares one persist call: if it
+        // throws, NONE of the rows reached disk, so flip every successful entry
+        // to a failure with the same error. Per-row partial success is impossible
+        // — sql.js dumps the entire DB snapshot atomically. Bookkeeping (cache
+        // + attestation) is deferred until AFTER persist succeeds so the cache
+        // cannot warm rows that never reached disk.
+        if (anyWritten) {
+            const persisted = tryPersist(ctx.db, dbPath);
+            if (!persisted.ok) {
+                for (let i = 0; i < results.length; i++) {
+                    if (results[i].success) {
+                        results[i] = { success: false, id: results[i].id, error: persisted.error };
+                    }
+                }
+                return results;
+            }
+        }
+        // Persist succeeded — fire deferred bookkeeping in parallel.
+        // Wrapped in try/catch (#994): rows are already durable, so a cache or
+        // attestation throw must not propagate to withDb's catch and downgrade
+        // every successful row to a fallback retry that fails on UNIQUE.
+        // Promise.all short-circuits, so partial bookkeeping is silently lost
+        // on a throw — log so a recurring failure is debuggable.
+        try {
+            await Promise.all(deferredBookkeeping.flatMap(b => [
+                cacheSet(registry, b.cacheKey, b.cacheValue),
+                logAttestation(registry, 'store', b.entryId, { key: b.entryKey, namespace: b.namespace, hasEmbedding: b.hasEmbedding }),
+            ]));
+        }
+        catch (err) {
+            logBridgeError('post-persist batch bookkeeping failed', err);
+        }
+        if (anyEmbedded) {
+            try {
+                refreshVectorStatsCache();
+            }
+            catch (err) {
+                logBridgeError('post-persist stats refresh failed', err);
+            }
+        }
         return results;
     });
 }
@@ -397,8 +491,10 @@ export async function bridgeGetEntry(options) {
             // Use getAsObject to read columns by name downstream. Bindings are
             // passed as a single array — varargs are silently ignored.
             row = stmt.getAsObject([key, namespace]);
-            // getAsObject returns {} when no row matches; treat as null.
-            if (!row || Object.keys(row).length === 0)
+            // #998: sql.js `getAsObject` zips SELECT column names with their values
+            // even on a no-row result, so the returned object always has keys —
+            // check the TEXT-NOT-NULL primary key to detect a real row.
+            if (!row || row.id == null)
                 row = null;
         }
         catch {
@@ -479,7 +575,13 @@ export async function bridgeDeleteEntry(options) {
             // (sql.js writeback semantics — see feedback_sqljs_writeback_clobber.md).
             return deleteFail(`Internal inconsistency: row matched SELECT but DELETE removed 0 rows (key='${key}', namespace='${namespace}'). Possible bridge cache staleness — restart the daemon and retry.`);
         }
-        persistBridgeDb(ctx.db, options.dbPath);
+        // Honest persist (#982). If the persist throws, the DELETE didn't reach
+        // disk — the row will reappear on next process load. Surface as a failure
+        // and skip cache invalidation so the cache stays consistent with disk.
+        const persisted = tryPersist(ctx.db, options.dbPath);
+        if (!persisted.ok) {
+            return deleteFail(persisted.error);
+        }
         await cacheInvalidate(registry, makeEntryCacheKey(namespace, key));
         await logAttestation(registry, 'delete', key, { namespace });
         let remaining = 0;

package/dist/src/cli/memory/daemon-write-client.js

@@ -0,0 +1,217 @@
+/**
+ * Daemon write client (#981 / #984 — single-writer architecture).
+ *
+ * HTTP client for the `POST /api/memory/{store,delete,batch}` RPC added by
+ * Story #983. Lets short-lived CLI processes and the long-lived MCP server
+ * route their `.moflo/moflo.db` writes through the daemon, which owns the
+ * authoritative sql.js handle. Avoids the multi-process clobber from #981.
+ *
+ * Contract — every function in this module:
+ *   - Never throws. Any error path returns `{ routed: false }`.
+ *   - Returns within ≤100ms even if the daemon is dead/slow (HTTP timeout).
+ *   - Caches daemon health for 5s to keep the hot write path cheap.
+ *   - Short-circuits without HTTP when:
+ *       (a) `process.env.MOFLO_IS_DAEMON === '1'` (daemon's own process)
+ *       (b) `moflo.yaml` has `daemon.auto_start: false`
+ *
+ * Story #984 ships the client without any consumer wiring — Story #985 / #986
+ * add the routing preamble inside `storeEntry` / `deleteEntry` (see
+ * `docs/internal/981-writer-audit.md`).
+ *
+ * @module cli/memory/daemon-write-client
+ */
+import * as http from 'node:http';
+// ============================================================================
+// Constants
+// ============================================================================
+/** Default daemon HTTP port. Mirrors `DEFAULT_DASHBOARD_PORT` in daemon-dashboard.ts. */
+const DEFAULT_DAEMON_PORT = 3117;
+/** HTTP timeout for ALL daemon requests (probe + write). Bounds the worst-case CLI hang. */
+const DAEMON_HTTP_TIMEOUT_MS = 100;
+/** Health-probe cache TTL. Probe at most once per 5s in either direction. */
+const HEALTH_CACHE_TTL_MS = 5_000;
+let healthCache = null;
+let configCache = null;
+/**
+ * Test seam: clear all caches. Production callers never invoke this; tests
+ * use it between cases so cached state doesn't leak across.
+ */
+export function _resetForTest() {
+    healthCache = null;
+    configCache = null;
+}
+// ============================================================================
+// Resolve daemon port (env override → moflo.yaml unused for v1 → default)
+// ============================================================================
+function getDaemonPort() {
+    const fromEnv = process.env.MOFLO_DAEMON_PORT;
+    if (fromEnv) {
+        const n = parseInt(fromEnv, 10);
+        if (Number.isFinite(n) && n > 0 && n < 65536)
+            return n;
+    }
+    return DEFAULT_DAEMON_PORT;
+}
+// ============================================================================
+// Daemon-disabled check (cached) — reads `daemon.auto_start` from moflo.yaml
+// ============================================================================
+async function isDaemonEnabledInConfig() {
+    const now = Date.now();
+    if (configCache && (now - configCache.checkedAt) < HEALTH_CACHE_TTL_MS) {
+        return configCache.daemonEnabled;
+    }
+    let enabled = true; // default-on — matches moflo.yaml default
+    try {
+        const { loadMofloConfig } = await import('../config/moflo-config.js');
+        const config = loadMofloConfig();
+        enabled = config?.daemon?.auto_start !== false;
+    }
+    catch {
+        // If we can't read the config (e.g., not in a moflo project), assume
+        // daemon-enabled — we'll still probe and the probe will fail safely.
+        enabled = true;
+    }
+    configCache = { daemonEnabled: enabled, checkedAt: now };
+    return enabled;
+}
+// ============================================================================
+// Health probe (cached) — GET /api/status
+// ============================================================================
+/**
+ * Cached daemon health probe. Returns true iff the daemon's HTTP server
+ * is reachable on `127.0.0.1:<port>` within {@link DAEMON_HTTP_TIMEOUT_MS}.
+ *
+ * Cache survives 5s in either direction — so a daemon that just came up
+ * is missed for ≤5s, and a daemon that just died is incorrectly assumed
+ * up for ≤5s. Caller falls back to direct write either way.
+ */
+export async function isDaemonAvailable() {
+    // 1) In-daemon short-circuit — never probe ourselves.
+    if (process.env.MOFLO_IS_DAEMON === '1')
+        return false;
+    // 2) Config short-circuit — daemon explicitly disabled.
+    if (!(await isDaemonEnabledInConfig()))
+        return false;
+    // 3) Cached probe.
+    const now = Date.now();
+    if (healthCache && (now - healthCache.checkedAt) < HEALTH_CACHE_TTL_MS) {
+        return healthCache.available;
+    }
+    const available = await probeDaemonHealth(getDaemonPort());
+    healthCache = { available, checkedAt: now };
+    return available;
+}
+function probeDaemonHealth(port) {
+    return new Promise((resolve) => {
+        let done = false;
+        const finish = (ok) => {
+            if (done)
+                return;
+            done = true;
+            resolve(ok);
+        };
+        const req = http.get({ host: '127.0.0.1', port, path: '/api/status', timeout: DAEMON_HTTP_TIMEOUT_MS }, (res) => {
+            // Discard body; status code is enough.
+            res.resume();
+            finish(res.statusCode === 200);
+        });
+        req.on('error', () => finish(false));
+        req.on('timeout', () => { req.destroy(); finish(false); });
+    });
+}
+// ============================================================================
+// Write helpers — POST /api/memory/{store,delete}
+// ============================================================================
+/**
+ * Route a single store write through the daemon. Returns
+ * `{ routed: false }` if the daemon is unavailable, the env disables
+ * routing, or any HTTP error fires.
+ */
+export async function tryDaemonStore(opts) {
+    if (!(await isDaemonAvailable()))
+        return { routed: false };
+    return postJson('/api/memory/store', {
+        namespace: opts.namespace,
+        key: opts.key,
+        value: opts.value,
+        tags: opts.tags,
+        ttl: opts.ttl,
+    });
+}
+/**
+ * Route a single delete through the daemon. Returns `{ routed: false }`
+ * on any failure mode.
+ */
+export async function tryDaemonDelete(opts) {
+    if (!(await isDaemonAvailable()))
+        return { routed: false };
+    return postJson('/api/memory/delete', {
+        namespace: opts.namespace,
+        key: opts.key,
+    });
+}
+// ============================================================================
+// Internal HTTP poster — never throws, bounded timeout
+// ============================================================================
+function postJson(path, body) {
+    return new Promise((resolve) => {
+        let done = false;
+        const finish = (result) => {
+            if (done)
+                return;
+            done = true;
+            // On routed-failure, invalidate the health cache so the next call
+            // re-probes and trips back to direct-write quickly when the daemon
+            // is dying.
+            if (result.routed === false)
+                healthCache = null;
+            resolve(result);
+        };
+        const payload = JSON.stringify(body);
+        const req = http.request({
+            host: '127.0.0.1',
+            port: getDaemonPort(),
+            path,
+            method: 'POST',
+            timeout: DAEMON_HTTP_TIMEOUT_MS,
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload),
+            },
+        }, (res) => {
+            let buf = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { buf += chunk; });
+            res.on('end', () => {
+                // Status >=500 is a daemon-side fault; treat as unrouted so the
+                // caller falls back. Status 4xx (validation) is ALSO unrouted —
+                // we don't want a malformed payload silently lost just because
+                // the HTTP delivery succeeded.
+                const status = res.statusCode ?? 0;
+                if (status < 200 || status >= 300) {
+                    finish({ routed: false });
+                    return;
+                }
+                try {
+                    const data = JSON.parse(buf);
+                    finish({
+                        routed: true,
+                        ok: !!data?.ok,
+                        id: typeof data?.id === 'string' ? data.id : undefined,
+                        deleted: typeof data?.deleted === 'boolean' ? data.deleted : undefined,
+                        error: typeof data?.error === 'string' ? data.error : undefined,
+                    });
+                }
+                catch {
+                    finish({ routed: false });
+                }
+            });
+            res.on('error', () => finish({ routed: false }));
+        });
+        req.on('error', () => finish({ routed: false }));
+        req.on('timeout', () => { req.destroy(); finish({ routed: false }); });
+        req.write(payload);
+        req.end();
+    });
+}
+//# sourceMappingURL=daemon-write-client.js.map

package/dist/src/cli/memory/memory-initializer.js

@@ -20,6 +20,18 @@ import { parseEmbeddingJson, toFloat32 } from './controllers/_shared.js';
 import { writeVectorStatsJson } from './bridge-core.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 import { MOFLO_DIR, hnswIndexPath, legacyMemoryDbPath, memoryDbPath, } from '../services/moflo-paths.js';
+import { tryDaemonStore, tryDaemonDelete } from './daemon-write-client.js';
+// #981 — daemon-write-client throws are a contract violation (it's documented
+// as never-throw). When a throw escapes anyway, log to stderr ONCE per process
+// and fall through to the direct-write path. Silent swallow would hide bugs;
+// per-call logging would spam.
+let _routingFaultLogged = false;
+function logRoutingFault(err) {
+    if (_routingFaultLogged)
+        return;
+    _routingFaultLogged = true;
+    process.stderr.write(`moflo: daemon-write-client routing fault (#981, falling back to direct write): ${errorDetail(err)}\n`);
+}
 /**
  * Write vector-stats.json cache for the statusline (no subprocess needed).
  * Called after memory store in the raw-sql.js fallback path. The bridge path
@@ -1561,6 +1573,30 @@ export async function storeEntry(options) {
         merged.add('locked');
         options = { ...options, namespace: 'learnings', tags: [...merged] };
     }
+    // #981 — single-writer routing. When an external daemon is reachable AND
+    // we're not the daemon ourselves AND no custom dbPath was supplied, route
+    // the write through the daemon's HTTP RPC so its in-memory sql.js handle
+    // stays authoritative. Any failure path falls through to the existing
+    // bridge / raw-sql.js logic below — byte-identical behaviour to today.
+    if (!options.dbPath
+        && process.env.MOFLO_IS_DAEMON !== '1'
+        && process.env.MOFLO_DISABLE_DAEMON_ROUTING !== '1') {
+        try {
+            const routed = await tryDaemonStore({
+                namespace: options.namespace ?? 'default',
+                key: options.key,
+                value: options.value,
+                tags: options.tags,
+                ttl: options.ttl,
+            });
+            if (routed.routed && routed.ok) {
+                return { success: true, id: routed.id ?? '' };
+            }
+        }
+        catch (err) {
+            logRoutingFault(err);
+        }
+    }
     // ADR-053: Try AgentDB v3 bridge first. The bridge calls
     // refreshVectorStatsCache() itself (bridge-entries.ts:191) — a second
     // write here was redundant and previously clobbered the correct count
@@ -1973,6 +2009,34 @@ export async function getEntry(options) {
  * Issue #980: Properly supports namespaced entries
  */
 export async function deleteEntry(options) {
+    // #981 — single-writer routing for deletes. Same gates as storeEntry:
+    // not the daemon, no custom dbPath, routing not opted out. Failure paths
+    // fall through to the existing bridge / raw-sql.js logic below.
+    if (!options.dbPath
+        && process.env.MOFLO_IS_DAEMON !== '1'
+        && process.env.MOFLO_DISABLE_DAEMON_ROUTING !== '1') {
+        try {
+            const routed = await tryDaemonDelete({
+                namespace: options.namespace ?? 'default',
+                key: options.key,
+            });
+            if (routed.routed && routed.ok) {
+                return {
+                    success: true,
+                    deleted: routed.deleted ?? true,
+                    key: options.key,
+                    namespace: options.namespace ?? 'default',
+                    // Daemon doesn't surface remainingEntries; callers that depend on
+                    // this value (the `flo memory delete` CLI) read it from a
+                    // subsequent stat query, not this return shape.
+                    remainingEntries: 0,
+                };
+            }
+        }
+        catch (err) {
+            logRoutingFault(err);
+        }
+    }
     // ADR-053: Try AgentDB v3 bridge first
     const bridge = await getBridge();
     if (bridge) {

package/dist/src/cli/services/daemon-dashboard.js

@@ -14,6 +14,7 @@
  */
 import { createServer } from 'node:http';
 import { errorDetail } from '../shared/utils/error-detail.js';
+import { handleMemoryStore, handleMemoryDelete, handleMemoryBatch, matchMemoryRpcRoute, } from './daemon-memory-rpc.js';
 export const DEFAULT_DASHBOARD_PORT = 3117;
 /**
  * Create a MemoryAccessor backed by the sql.js/HNSW memory database.
@@ -36,7 +37,12 @@ export async function createDashboardMemoryAccessor() {
         async write(namespace, key, value) {
             const result = await storeEntry({ key, value: typeof value === 'string' ? value : JSON.stringify(value), namespace, upsert: true });
             if (!result.success) {
-                console.warn(`[dashboard] memory.write(${namespace}, ${key}) failed: ${result.error ?? 'unknown'}`);
+                // #982 — surface the failure to callers (runner.storeProgress wraps
+                // this in a try/catch + console.warn). Pre-#982 we just warned and
+                // returned cleanly, which let the spell engine claim success on a
+                // run whose progress writes never reached disk.
+                const err = `memory.write(${namespace}, ${key}) failed: ${result.error ?? 'unknown'}`;
+                throw new Error(err);
             }
         },
         async search(namespace, query) {
@@ -320,7 +326,8 @@ async function handleRequest(req, res, daemon, opts) {
     const url = req.url ?? '/';
     const method = req.method ?? 'GET';
     try {
-        // POST: schedule actions (disable / enable / run). Only 127.0.0.1 traffic
+        // POST: schedule actions (disable / enable / run) and memory write RPC
+        // (#981 single-writer architecture — Story #983). Only 127.0.0.1 traffic
         // reaches here (server.listen bind), so no CSRF layer is needed. Any
         // other POST falls through to the read-only 405 below.
         if (method === 'POST') {
@@ -329,11 +336,30 @@ async function handleRequest(req, res, daemon, opts) {
                 await handleScheduleAction(res, daemon, action.id, action.verb);
                 return;
             }
+            const memoryRoute = matchMemoryRpcRoute(url);
+            if (memoryRoute === 'store') {
+                await handleMemoryStore(req, res, opts.memory);
+                return;
+            }
+            if (memoryRoute === 'delete') {
+                await handleMemoryDelete(req, res, opts.memory);
+                return;
+            }
+            if (memoryRoute === 'batch') {
+                await handleMemoryBatch(req, res, opts.memory);
+                return;
+            }
         }
         if (method !== 'GET') {
             sendJson(res, 405, { error: 'Method not allowed' });
             return;
         }
+        // Memory RPC endpoints are POST-only; return 405 (not 404) on GET so
+        // clients distinguish "wrong method" from "no such endpoint".
+        if (matchMemoryRpcRoute(url)) {
+            sendJson(res, 405, { error: 'Method not allowed' });
+            return;
+        }
         if (url === '/') {
             sendHtml(res, DASHBOARD_HTML);
         }