monomind 2.2.0 → 2.3.1

package/packages/@monomind/cli/dist/src/mcp-tools/task-tools.d.ts

@@ -4,5 +4,25 @@
  * Tool definitions for task management with file persistence.
  */
 import { type MCPTool } from './types.js';
+interface TaskRecord {
+    taskId: string;
+    type: string;
+    description: string;
+    priority: 'low' | 'normal' | 'high' | 'critical';
+    status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+    progress: number;
+    assignedTo: string[];
+    tags: string[];
+    createdAt: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    result?: Record<string, unknown>;
+}
+interface TaskStore {
+    tasks: Record<string, TaskRecord>;
+    version: string;
+}
+export declare function loadTaskStore(): TaskStore;
 export declare const taskTools: MCPTool[];
+export {};
 //# sourceMappingURL=task-tools.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/task-tools.js

@@ -23,7 +23,7 @@ function ensureTaskDir() {
     }
 }
 const MAX_TASK_STORE_BYTES = 50 * 1024 * 1024;
-function loadTaskStore() {
+export function loadTaskStore() {
     try {
         const path = getTaskPath();
         if (existsSync(path)) {
@@ -36,8 +36,9 @@ function loadTaskStore() {
             return parsed;
         }
     }
-    catch {
-        // Return empty store on error
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[loadTaskStore] failed to read/parse task store:', e);
     }
     return { tasks: {}, version: '3.0.0' };
 }
@@ -273,8 +274,9 @@ export const taskTools = [
                         writeFileSync(tmpAgent1, JSON.stringify(agentStore, null, 2), 'utf-8');
                         renameSync(tmpAgent1, agentStorePath);
                     }
-                    catch {
-                        // Best-effort agent sync
+                    catch (e) {
+                        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                            console.error('[task_complete] agent store sync failed:', e);
                     }
                 }
                 return {
@@ -372,15 +374,30 @@ export const taskTools = [
                 return { taskId, error: 'Task not found' };
             }
             const previouslyAssigned = [...task.assignedTo];
-            // Load agent store to sync worker state
+            // Load agent store to sync worker state. Distinguish "file doesn't
+            // exist yet" (safe to proceed with an empty store) from "file exists
+            // but failed to read/parse" (a real store that's momentarily corrupt
+            // or oversized) — the latter must NOT fall through to the unconditional
+            // write-back below, or a transient read failure silently wipes out
+            // every agent's real on-disk state.
             const agentStorePath = join(getMonomindDataRoot(), 'agents', 'store.json');
             let agentStore = { agents: {} };
+            let agentStoreReadFailed = false;
             try {
-                if (existsSync(agentStorePath) && statSync(agentStorePath).size <= MAX_TASK_STORE_BYTES) {
-                    agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
+                if (existsSync(agentStorePath)) {
+                    if (statSync(agentStorePath).size <= MAX_TASK_STORE_BYTES) {
+                        agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
+                    }
+                    else {
+                        agentStoreReadFailed = true;
+                    }
                 }
             }
-            catch { /* ignore */ }
+            catch (e) {
+                agentStoreReadFailed = true;
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[task_assign] failed to read agent store — skipping agent-store sync to avoid overwriting it with an empty one:', e);
+            }
             // Reject IDs that would mutate Object.prototype when used as a key in
             // the JSON-loaded plain object `agentStore.agents`.
             const FORBIDDEN_AGENT_IDS = new Set(['__proto__', 'constructor', 'prototype']);
@@ -422,19 +439,24 @@ export const taskTools = [
                 }
             }
             saveTaskStore(store);
-            // Save agent store
-            const agentDir = join(getMonomindDataRoot(), 'agents');
-            if (!existsSync(agentDir)) {
-                mkdirSync(agentDir, { recursive: true });
+            // Save agent store — skipped when the read above failed, so a
+            // transient corrupt/oversized store.json is left alone instead of
+            // being overwritten with an empty one.
+            if (!agentStoreReadFailed) {
+                const agentDir = join(getMonomindDataRoot(), 'agents');
+                if (!existsSync(agentDir)) {
+                    mkdirSync(agentDir, { recursive: true });
+                }
+                const tmpAgent2 = `${agentStorePath}.${process.pid}.${Date.now()}.tmp`;
+                writeFileSync(tmpAgent2, JSON.stringify(agentStore, null, 2), 'utf-8');
+                renameSync(tmpAgent2, agentStorePath);
             }
-            const tmpAgent2 = `${agentStorePath}.${process.pid}.${Date.now()}.tmp`;
-            writeFileSync(tmpAgent2, JSON.stringify(agentStore, null, 2), 'utf-8');
-            renameSync(tmpAgent2, agentStorePath);
             return {
                 taskId: task.taskId,
                 assignedTo: task.assignedTo,
                 previouslyAssigned,
                 status: task.status,
+                ...(agentStoreReadFailed ? { agentStoreSyncSkipped: true } : {}),
             };
         },
     },

package/packages/@monomind/cli/dist/src/mcp-tools/terminal-tools.d.ts

@@ -4,5 +4,7 @@
  * Terminal session management with real command execution.
  */
 import type { MCPTool } from './types.js';
+/** Returns a copy of `env` with secret-shaped variable names removed. */
+export declare function filterSecretEnvVars(env: NodeJS.ProcessEnv): Record<string, string>;
 export declare const terminalTools: MCPTool[];
 //# sourceMappingURL=terminal-tools.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/terminal-tools.js

@@ -1,9 +1,10 @@
 import { getProjectCwd } from './types.js';
-import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
+import { writeJsonFileAtomic } from '../utils/json-file.js';
 // Storage paths
 const STORAGE_DIR = '.monomind';
 const TERMINAL_DIR = 'terminals';
@@ -24,7 +25,7 @@ const TERMINAL_FILE = 'store.json';
 // is layered on *after* the filtered process.env below).
 const SECRET_ENV_NAME_PATTERN = /(KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|_AUTH$|^AUTH_|PRIVATE_KEY|ACCESS_KEY)/i;
 /** Returns a copy of `env` with secret-shaped variable names removed. */
-function filterSecretEnvVars(env) {
+export function filterSecretEnvVars(env) {
     const filtered = {};
     for (const [k, v] of Object.entries(env)) {
         if (v === undefined)
@@ -41,32 +42,39 @@ function getTerminalDir() {
 function getTerminalPath() {
     return join(getTerminalDir(), TERMINAL_FILE);
 }
-function ensureTerminalDir() {
-    const dir = getTerminalDir();
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-}
 const MAX_TERMINAL_STORE_BYTES = 10 * 1024 * 1024; // 10 MB
-function loadTerminalStore() {
+// Same hardened-loader convention as agent-tools.ts's loadAgentStoreOrNull:
+// handlers that mutate and save must use the null-aware variant, since
+// treating a corrupt/oversized store as empty and then saving that back
+// would silently wipe every real session. Also guards against a __proto__
+// key in the parsed JSON (agent-tools.ts's loader does the same). Can't
+// delegate to utils/json-file.ts's readJsonFileSync here — it collapses
+// "file absent" and "file corrupt" into the same fallback value, but this
+// loader must tell them apart (absent → empty default is safe to build on
+// and save; corrupt → null, refuse to save over it).
+function loadTerminalStoreOrNull() {
     try {
         const path = getTerminalPath();
-        if (existsSync(path) && statSync(path).size <= MAX_TERMINAL_STORE_BYTES) {
-            return JSON.parse(readFileSync(path, 'utf-8'));
-        }
+        if (!existsSync(path))
+            return { sessions: {}, version: '3.0.0' };
+        if (statSync(path).size > MAX_TERMINAL_STORE_BYTES)
+            return null;
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        if (parsed && typeof parsed === 'object' && Object.prototype.hasOwnProperty.call(parsed, '__proto__'))
+            return null;
+        return parsed;
     }
-    catch {
-        // Return empty store
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[loadTerminalStore] terminal store unreadable/corrupt:', e);
+        return null;
     }
-    return { sessions: {}, version: '3.0.0' };
+}
+function loadTerminalStore() {
+    return loadTerminalStoreOrNull() ?? { sessions: {}, version: '3.0.0' };
 }
 function saveTerminalStore(store) {
-    ensureTerminalDir();
-    // Unique tmp filename so concurrent handler invocations cannot clobber each
-    // other's .tmp mid-write (which would produce a partial JSON on rename).
-    const tmpPath = `${getTerminalPath()}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(tmpPath, JSON.stringify(store, null, 2), 'utf-8');
-    renameSync(tmpPath, getTerminalPath());
+    writeJsonFileAtomic(getTerminalPath(), store);
 }
 export const terminalTools = [
     {
@@ -82,7 +90,10 @@ export const terminalTools = [
             },
         },
         handler: async (input) => {
-            const store = loadTerminalStore();
+            const store = loadTerminalStoreOrNull();
+            if (!store) {
+                return { success: false, error: 'Terminal store is unreadable/corrupt — refusing to create a session to avoid overwriting real session data.' };
+            }
             const MAX_SESSIONS = 1000;
             if (Object.keys(store.sessions).length >= MAX_SESSIONS) {
                 return { success: false, error: 'Session limit reached' };
@@ -167,7 +178,10 @@ export const terminalTools = [
             required: ['command'],
         },
         handler: async (input) => {
-            const store = loadTerminalStore();
+            const store = loadTerminalStoreOrNull();
+            if (!store) {
+                return { success: false, error: 'Terminal store is unreadable/corrupt — refusing to execute to avoid overwriting real session data.' };
+            }
             const sessionId = input.sessionId;
             // Cap command: the metacharacter regex check at line 220 is O(n), and the
             // raw command is stored verbatim in session history (up to 200 entries).
@@ -313,7 +327,10 @@ export const terminalTools = [
             required: ['sessionId'],
         },
         handler: async (input) => {
-            const store = loadTerminalStore();
+            const store = loadTerminalStoreOrNull();
+            if (!store) {
+                return { success: false, error: 'Terminal store is unreadable/corrupt — refusing to close a session to avoid overwriting real session data.' };
+            }
             const sessionId = input.sessionId;
             const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
             if (!sessionId || FORBIDDEN_KEYS.has(sessionId)) {

package/packages/@monomind/cli/dist/src/memory/ewc-consolidation.js

@@ -70,8 +70,10 @@ export class EWCConsolidator {
             this.initialized = true;
             return true;
         }
-        catch {
+        catch (e) {
             // Start fresh if no persisted state
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[ewc-consolidation] failed to load persisted state, starting fresh:', e);
             this.initialized = true;
             return true;
         }
@@ -544,8 +546,10 @@ export class EWCConsolidator {
             fs.writeFileSync(tmp, JSON.stringify(state, null, 2));
             fs.renameSync(tmp, this.config.storagePath);
         }
-        catch {
+        catch (e) {
             // Silently fail - persistence is best-effort
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[ewc-consolidation] failed to persist state:', e);
         }
     }
     /**

package/packages/@monomind/cli/dist/src/memory/intelligence.js

@@ -454,8 +454,10 @@ class LocalReasoningBank {
             // ReasoningBank via intelligence.ts's public API, so no separate
             // models.json bridge is needed.
         }
-        catch {
+        catch (e) {
             // Ignore load errors, start fresh
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[intelligence] failed to load patterns.json, starting fresh:', e);
         }
     }
     /**
@@ -680,8 +682,10 @@ function loadPersistedStats() {
             }
         }
     }
-    catch {
+    catch (e) {
         // Ignore load errors, start fresh
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] failed to load stats.json, starting fresh:', e);
     }
 }
 /**
@@ -693,8 +697,10 @@ function savePersistedStats() {
         const path = getStatsPath();
         writeFileSync(path, JSON.stringify(globalStats, null, 2), 'utf-8');
     }
-    catch {
+    catch (e) {
         // Ignore save errors
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] failed to save stats.json:', e);
     }
 }
 // ============================================================================
@@ -762,7 +768,11 @@ async function _doInitializeIntelligence(config) {
                     }
                 }
             }
-            catch { /* neural patterns file unreadable — skip */ }
+            catch (e) {
+                /* neural patterns file unreadable — skip */
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[intelligence] failed to seed patterns.json into ReasoningBank:', e);
+            }
         }
         // Seed SONA routing patterns into the ReasoningBank so keyword-based
         // routing knowledge from .swarm/sona-patterns.json participates in
@@ -890,7 +900,9 @@ export async function recordStep(step) {
         globalStats.trajectoriesRecorded++;
         return true;
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] recordStep failed:', e);
         return false;
     }
 }
@@ -923,7 +935,9 @@ export async function recordTrajectory(steps, verdict) {
         savePersistedStats();
         return true;
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] recordTrajectory failed:', e);
         return false;
     }
 }
@@ -980,7 +994,9 @@ export async function findSimilarPatterns(query, options) {
             similarity: r.similarity ?? r.confidence ?? 0.5
         }));
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] findSimilarPatterns failed:', e);
         return [];
     }
 }
@@ -1030,7 +1046,9 @@ export async function endTrajectoryWithVerdict(verdict) {
         savePersistedStats();
         return result;
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] endTrajectoryWithVerdict failed:', e);
         return null;
     }
 }
@@ -1052,7 +1070,9 @@ export async function distillLearning() {
         savePersistedStats();
         return result;
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] distillLearning failed:', e);
         return null;
     }
 }
@@ -1184,7 +1204,9 @@ function loadSonaRoutingPatterns() {
         }
         return results;
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] failed to load .swarm/sona-patterns.json:', e);
         return [];
     }
 }

package/packages/@monomind/cli/dist/src/memory/memory-bridge.js

@@ -121,6 +121,15 @@ let bridgeAvailable = null;
 let _embedder = null;
 const MAX_INIT_ATTEMPTS = 3;
 let initAttempts = 0;
+/** Flush after mutations: the sql.js fallback backend is in-memory WASM and
+ *  only reaches disk via persist(); the CLI process is short-lived, so waiting
+ *  for an auto-persist interval would lose writes. No-op on better-sqlite3. */
+async function flushBackend(backend) {
+    try {
+        await backend?.persist?.();
+    }
+    catch { /* best effort */ }
+}
 async function getBackend(dbPath) {
     if (bridgeAvailable === false)
         return null;
@@ -134,7 +143,6 @@ async function getBackend(dbPath) {
         backendPromise = (async () => {
             try {
                 const mod = await import('@monoes/memory');
-                const { LanceDBBackend } = mod;
                 // Try to create embedding generator from HuggingFace transformers
                 let embeddingGenerator;
                 try {
@@ -148,27 +156,43 @@ async function getBackend(dbPath) {
                     };
                     _embedder = embeddingGenerator;
                 }
-                catch { /* embeddings unavailable — store and search without vectors */ }
-                const backend = new LanceDBBackend({
-                    // Always route through getDbPath's traversal guard — dbPath here can
-                    // originate from a caller/tool-supplied value, and getDbPath(undefined)
-                    // already returns the correct default, so there's no case where
-                    // calling it unconditionally changes behavior for the no-path case.
-                    dbPath: getDbPath(dbPath),
-                    vectorDimension: BRIDGE_EMBEDDING_DIMS,
+                catch (e) {
+                    if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                        console.error('[memory-bridge] embedding model failed to load — store and search without vectors:', e);
+                }
+                // Local SQLite engine (LanceDB replaced 2026-07): better-sqlite3 when its
+                // native binding loads, sql.js (pure WASM) otherwise — both persist text
+                // AND embeddings, so vectors are always recomputable/derivable data.
+                // getDbPath keeps its traversal guard and directory semantics; the SQLite
+                // file lives inside that directory.
+                const dir = getDbPath(dbPath);
+                fs.mkdirSync(dir, { recursive: true });
+                const cfg = {
+                    databasePath: path.join(dir, 'memory.db'),
+                    walMode: true,
+                    optimize: true,
+                    defaultNamespace: 'default',
                     embeddingGenerator,
-                    enableFts: false,
-                    nProbes: 20,
-                });
+                };
                 const origLog = console.log;
                 console.log = (...args) => {
                     const msg = String(args[0] ?? '');
-                    if (msg.includes('Transformers.js') || msg.includes('[LanceDB]') || msg.includes('Loading model'))
+                    if (msg.includes('Transformers.js') || msg.includes('Loading model'))
                         return;
                     origLog.apply(console, args);
                 };
+                let backend;
                 try {
-                    await backend.initialize();
+                    try {
+                        backend = new mod.SQLiteBackend(cfg);
+                        await backend.initialize();
+                    }
+                    catch (e) {
+                        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                            console.error('[memory-bridge] better-sqlite3 unavailable — using sql.js backend:', e);
+                        backend = new mod.SqlJsBackend(cfg);
+                        await backend.initialize();
+                    }
                 }
                 finally {
                     console.log = origLog;
@@ -212,7 +236,10 @@ export async function bridgeStoreEntry(options) {
                 embedding = await _embedder(value);
                 embeddingInfo = { dimensions: embedding.length, model: BRIDGE_EMBEDDING_MODEL };
             }
-            catch { /* store without embedding */ }
+            catch (e) {
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[memory-bridge] embedding generation failed — storing entry without embedding:', e);
+            }
         }
         const mod = await import('@monoes/memory');
         const entry = mod.createDefaultEntry({
@@ -233,7 +260,10 @@ export async function bridgeStoreEntry(options) {
                 if (existing)
                     await backend.delete(existing.id);
             }
-            catch { /* non-fatal */ }
+            catch (e) {
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[memory-bridge] upsert failed to delete existing entry — may create a duplicate:', e);
+            }
         }
         // Dedup gate: skip if a near-duplicate already exists
         const automemCfg = getAutomemConfig();
@@ -247,6 +277,7 @@ export async function bridgeStoreEntry(options) {
             catch { /* non-fatal — store anyway */ }
         }
         await backend.store(entry);
+        await flushBackend(backend);
         return { success: true, id, embedding: embeddingInfo };
     }
     catch (err) {
@@ -293,20 +324,31 @@ export async function bridgeSearchEntries(options) {
                 namespace: namespace ?? 'default',
                 limit: 50000,
             });
-            const queryLower = queryStr.toLowerCase();
-            results = entries
-                .filter((e) => (e.content || '').toLowerCase().includes(queryLower)
-                || (e.key || '').toLowerCase().includes(queryLower))
-                .slice(0, limit)
-                .map((e) => ({
-                id: e.id,
-                key: e.key,
-                content: e.content || '',
-                score: 0.5,
-                namespace: e.namespace,
-                provenance: 'keyword',
-                _createdAt: e.createdAt || 0,
-            }));
+            // Token-based matching, not whole-phrase substring: "semantic test" must
+            // match an entry keyed "semantic-test" (the old .includes(query) required
+            // the exact phrase — including its whitespace — to appear verbatim).
+            // Score = fraction of query tokens present in key+content.
+            const tokens = queryStr.toLowerCase().split(/[^a-z0-9]+/).filter(t => t.length > 1);
+            if (tokens.length) {
+                results = entries
+                    .map((e) => {
+                    const haystack = `${e.key || ''} ${e.content || ''}`.toLowerCase();
+                    const hits = tokens.filter(t => haystack.includes(t)).length;
+                    return { e, score: hits / tokens.length };
+                })
+                    .filter((x) => x.score > 0)
+                    .sort((a, b) => b.score - a.score)
+                    .slice(0, limit)
+                    .map(({ e, score }) => ({
+                    id: e.id,
+                    key: e.key,
+                    content: e.content || '',
+                    score: Math.min(0.9, 0.3 + score * 0.6),
+                    namespace: e.namespace,
+                    provenance: `keyword:${score.toFixed(2)}`,
+                    _createdAt: e.createdAt || 0,
+                }));
+            }
             searchMethod = 'keyword';
         }
         // Filter stale entries based on automem config — skip for knowledge
@@ -404,6 +446,8 @@ export async function bridgeDeleteEntry(options) {
             if (entry)
                 deleted = await backend.delete(entry.id);
         }
+        if (deleted)
+            await flushBackend(backend);
         return { success: true, deleted };
     }
     catch {
@@ -644,7 +688,10 @@ export async function bridgeSessionEnd(options) {
             try {
                 data = JSON.parse(existing.content);
             }
-            catch { /* use empty */ }
+            catch (e) {
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[memory-bridge] session content failed to parse — ending session with empty prior state:', e);
+            }
             await backend.update(existing.id, {
                 content: JSON.stringify({
                     ...data,
@@ -655,6 +702,7 @@ export async function bridgeSessionEnd(options) {
                 }),
                 tags: ['session', 'ended'],
             });
+            await flushBackend(backend);
         }
         return { success: true };
     }
@@ -746,6 +794,8 @@ export async function bridgeConsolidate(params) {
                 deleted++;
             }
         }
+        if (deleted)
+            await flushBackend(backend);
         return { success: true, consolidated: deleted };
     }
     catch {

package/packages/@monomind/cli/dist/src/memory/memory-crud.js

@@ -238,8 +238,32 @@ export async function storeEntry(options) {
         }
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
-        const id = `entry_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        // memory_entries has no UNIQUE constraint on (key, namespace) — only
+        // `id TEXT PRIMARY KEY`. `INSERT OR REPLACE` only replaces a row when
+        // its PRIMARY KEY collides, so generating a fresh id on every call (as
+        // this used to do unconditionally) meant upsert never actually matched
+        // the existing row for a given key+namespace — it silently inserted a
+        // duplicate instead of replacing it. When upserting, look up the
+        // existing row's real id first and reuse it so the replace actually
+        // collides; only mint a new id when no existing row is found.
+        let id = `entry_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        let existingCreatedAt = null;
+        if (upsert) {
+            // Only match active rows — a soft-deleted row's key+namespace should
+            // not be resurrected by an unrelated upsert; that would both restore
+            // history a delete intentionally cleared and mask the deletion.
+            const existingIdResult = db.exec("SELECT id, created_at FROM memory_entries WHERE key = ? AND namespace = ? AND status = 'active' LIMIT 1", [key, namespace]);
+            const existingRow = existingIdResult[0]?.values?.[0];
+            const existingId = existingRow?.[0];
+            if (typeof existingId === 'string') {
+                id = existingId;
+                const createdAt = existingRow?.[1];
+                if (typeof createdAt === 'number')
+                    existingCreatedAt = createdAt;
+            }
+        }
         const now = Date.now();
+        const createdAt = existingCreatedAt ?? now;
         let embeddingJson = null;
         let embeddingDimensions = null;
         let embeddingModel = null;
@@ -270,7 +294,7 @@ export async function storeEntry(options) {
             embeddingModel,
             tags.length > 0 ? JSON.stringify(tags) : null,
             '{}',
-            now,
+            createdAt,
             now,
             ttl ? now + (ttl * 1000) : null
         ]);

package/packages/@monomind/cli/dist/src/memory/memory-initializer.js

@@ -110,8 +110,9 @@ async function activateControllerRegistry(dbPath, verbose) {
             console.log(`ControllerRegistry: ${activated.length} controllers activated`);
         }
     }
-    catch {
-        // ControllerRegistry activation is best-effort
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[activateControllers] ControllerRegistry activation failed:', e);
     }
     return { activated, failed, initTimeMs: performance.now() - startTime };
 }

package/packages/@monomind/cli/dist/src/memory/memory-migrations.js

@@ -57,6 +57,8 @@ export async function ensureSchemaColumns(dbPath) {
                 }
                 catch (e) {
                     // Column might already exist or other error - continue
+                    if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                        console.error(`[ensureSchemaColumns] failed to add column '${col.name}':`, e);
                 }
             }
         }

package/packages/@monomind/cli/dist/src/monovector/command-outcomes.js

@@ -41,7 +41,10 @@ export async function recordCommand(baseDir, cmd) {
             await fs.writeFile(path, lines.slice(-MAX_COMMAND_RECORDS).join('\n') + '\n', 'utf8');
         }
     }
-    catch { /* non-fatal */ }
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[recordCommand] failed to record command outcome:', e);
+    }
 }
 /**
  * Derive a measured success signal from recent command outcomes.