monomind 2.1.9 → 2.3.0

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

@@ -97,8 +97,10 @@ export const hooksPostEdit = {
                 confidence: success ? 0.85 : 0.3,
             });
         }
-        catch {
+        catch (e) {
             // Bridge not available — continue with basic response
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[hooks-post-edit] memory bridge feedback failed:', e);
         }
         return {
             recorded: true,
@@ -738,8 +740,10 @@ export const hooksPostTask = {
                 metadata: { taskId, duration: params.duration || undefined, patterns: params.patterns || undefined },
             });
         }
-        catch {
+        catch (e) {
             // Bridge not available — continue with basic response
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[hooks-post-task] memory bridge feedback failed:', e);
         }
         // Phase 3: Record causal edge (task → outcome)
         try {
@@ -751,8 +755,10 @@ export const hooksPostTask = {
                 strength: quality,
             });
         }
-        catch {
+        catch (e) {
             // Non-fatal
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[hooks-post-task] causal edge record failed:', e);
         }
         // Persist routing outcome for runtime learning (file-based, always reliable).
         // B1.3: also gate this sibling learning sink on a known outcome — an unverified
@@ -938,8 +944,10 @@ export const hooksExplain = {
                 }
             }
         }
-        catch {
-            // File unreadable; leave as null
+        catch (e) {
+            // File unreadable or corrupt; leave as null
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[hooks-explain] routing outcomes file read/parse failed:', e);
         }
         return {
             task,
@@ -1059,7 +1067,11 @@ export const hooksPretrain = {
             });
             patternsStored = patterns.length;
         }
-        catch { /* memory backend unavailable */ }
+        catch (e) {
+            /* memory backend unavailable */
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[hooks-pretrain] pattern store failed:', e);
+        }
         // Feed extracted import patterns into the neural training system so
         // pretrain actually trains, not just scans.
         let neuralPatternsLearned = 0;
@@ -1077,7 +1089,11 @@ export const hooksPretrain = {
                 intel.flushPatterns();
                 neuralPatternsLearned = steps.length;
             }
-            catch { /* intelligence not available */ }
+            catch (e) {
+                /* intelligence not available */
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[hooks-pretrain] intelligence training failed:', e);
+            }
         }
         return {
             success: true,
@@ -1215,8 +1231,10 @@ export const hooksTransfer = {
                 sourceStore = JSON.parse(readFileSync(sourceMemoryPath, 'utf-8'));
             }
         }
-        catch {
+        catch (e) {
             // Fall back to empty store
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[hooks-transfer] source memory store read/parse failed:', e);
         }
         const sourceEntries = Object.values(sourceStore.entries);
         // Count patterns by type from source
@@ -1282,8 +1300,10 @@ export const hooksSessionStart = {
                 };
             }
         }
-        catch {
+        catch (e) {
             // Bridge not available
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[hooks-session-start] memory bridge failed:', e);
         }
         return {
             sessionId,
@@ -1303,6 +1323,86 @@ export const hooksSessionStart = {
         };
     },
 };
+// Session restore hook — hooks.ts's `hooks session-restore` (and its
+// `session-start` alias) called this tool name, but it was never registered
+// anywhere in the tool registry, so both always failed. This repo has no
+// per-session snapshot of agents/tasks to restore from, so "restore" here
+// means: report the currently-live (non-terminated/non-terminal) agents and
+// tasks as "carried forward", and reinitialize the memory-bridge session
+// context the same way hooks_session-start does — an honest, working
+// implementation rather than a fabricated one.
+export const hooksSessionRestore = {
+    name: 'hooks_session-restore',
+    description: 'Restore a previous session — reports currently-live agents/tasks and reinitializes memory-bridge session context',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            sessionId: { type: 'string', description: 'Session ID to restore, or "latest"' },
+            restoreAgents: { type: 'boolean', description: 'Include a count of currently-live agents (default true)' },
+            restoreTasks: { type: 'boolean', description: 'Include a count of currently-live tasks (default true)' },
+        },
+    },
+    handler: async (params) => {
+        const originalSessionId = params.sessionId || 'latest';
+        const newSessionId = `session-${Date.now()}`;
+        const warnings = [];
+        let agentsRestored = 0;
+        if (params.restoreAgents !== false) {
+            try {
+                const { loadAgentStore } = await import('./agent-tools.js');
+                const store = loadAgentStore();
+                agentsRestored = Object.values(store.agents).filter((a) => a.status !== 'terminated').length;
+            }
+            catch (e) {
+                warnings.push('Agent store unavailable — agent count not restored');
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[hooks-session-restore] agent store read failed:', e);
+            }
+        }
+        let tasksRestored = 0;
+        if (params.restoreTasks !== false) {
+            try {
+                const { loadTaskStore } = await import('./task-tools.js');
+                const store = loadTaskStore();
+                tasksRestored = Object.values(store.tasks).filter((t) => t.status === 'pending' || t.status === 'in_progress').length;
+            }
+            catch (e) {
+                warnings.push('Task store unavailable — task count not restored');
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[hooks-session-restore] task store read failed:', e);
+            }
+        }
+        // bridgeSessionStart only stores a new "session active" marker entry —
+        // it has no pattern-restoration data to count, so there is no real
+        // "memoryRestored" number to report. Track whether the bridge itself
+        // came up instead of faking a count.
+        let memoryBridgeInitialized = false;
+        try {
+            const bridge = await import('../memory/memory-bridge.js');
+            const result = await bridge.bridgeSessionStart({
+                sessionId: newSessionId,
+                metadata: { context: 'restore previous session patterns' },
+            });
+            if (result) {
+                memoryBridgeInitialized = result.success;
+            }
+            else {
+                warnings.push('Memory bridge unavailable — pattern restoration skipped');
+            }
+        }
+        catch (e) {
+            warnings.push('Memory bridge failed to initialize');
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[hooks-session-restore] memory bridge failed:', e);
+        }
+        return {
+            sessionId: newSessionId,
+            originalSessionId,
+            restoredState: { tasksRestored, agentsRestored, memoryBridgeInitialized },
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    },
+};
 // Session end hook - persists state
 export const hooksSessionEnd = {
     name: 'hooks_session-end',
@@ -1356,8 +1456,10 @@ export const hooksSessionEnd = {
                 };
             }
         }
-        catch {
+        catch (e) {
             // Bridge not available
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[hooks-session-end] memory bridge failed:', e);
         }
         return {
             sessionId,

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

@@ -3,7 +3,7 @@
  * Thin registration module that aggregates all hooks MCP tools into a single array.
  * Business logic lives in hooks-embedding.ts, hooks-routing.ts, and hooks-intelligence.ts.
  */
-import { hooksPreEdit, hooksPostEdit, hooksPreCommand, hooksPostCommand, hooksRoute, hooksRouteSemantic, hooksMetrics, hooksList, hooksPreTask, hooksPostTask, hooksExplain, hooksPretrain, hooksBuildAgents, hooksTransfer, hooksSessionStart, hooksSessionEnd, hooksIntelligence, } from './hooks-routing.js';
+import { hooksPreEdit, hooksPostEdit, hooksPreCommand, hooksPostCommand, hooksRoute, hooksRouteSemantic, hooksMetrics, hooksList, hooksPreTask, hooksPostTask, hooksExplain, hooksPretrain, hooksBuildAgents, hooksTransfer, hooksSessionStart, hooksSessionRestore, hooksSessionEnd, hooksIntelligence, } from './hooks-routing.js';
 import { hooksIntelligenceReset, hooksTrajectoryStart, hooksTrajectoryStep, hooksTrajectoryEnd, hooksPatternStore, hooksPatternSearch, hooksIntelligenceStats, hooksIntelligenceLearn, hooksIntelligenceAttention, hooksModelRoute, hooksModelOutcome, hooksModelStats, } from './hooks-intelligence.js';
 // Export all hooks tools
 export const hooksTools = [
@@ -23,6 +23,7 @@ export const hooksTools = [
     hooksBuildAgents,
     hooksTransfer,
     hooksSessionStart,
+    hooksSessionRestore,
     hooksSessionEnd,
     hooksIntelligence,
     hooksIntelligenceReset,

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

@@ -639,7 +639,10 @@ const monographWatchTool = {
         }
         const watcher = new MonographWatcher(repoPath);
         watcher.on('monograph:updated', (_paths) => {
-            import('@monoes/monograph').then(({ buildAsync }) => buildAsync(repoPath)).catch(() => { });
+            import('@monoes/monograph').then(({ buildAsync }) => buildAsync(repoPath)).catch((e) => {
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[monograph_watch] background rebuild failed:', e);
+            });
         });
         await watcher.start();
         _activeWatchers.set(repoPath, watcher);
@@ -776,7 +779,10 @@ function triggerBackgroundBuildIfNeeded(repoPath, commitsBehind, threshold = STA
     _buildInProgress = true;
     void import('@monoes/monograph')
         .then(({ buildAsync }) => buildAsync(repoPath, { codeOnly: true }))
-        .catch(() => { })
+        .catch((e) => {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[triggerBackgroundBuildIfNeeded] staleness-triggered rebuild failed:', e);
+    })
         .finally(() => { _buildInProgress = false; });
     return true;
 }

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

@@ -40,8 +40,9 @@ function loadPerfStore() {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch {
-        // Return empty store
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[performance-tools] failed to load perf store, using empty store:', e);
     }
     return { metrics: [], benchmarks: {}, version: '3.0.0' };
 }

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

@@ -34,8 +34,9 @@ function loadSession(sessionId) {
             return JSON.parse(data);
         }
     }
-    catch {
-        // Return null on error
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[session-tools] loadSession failed:', e);
     }
     return null;
 }
@@ -90,7 +91,10 @@ function loadRelatedStores(options) {
                 data.memory = JSON.parse(readFileSync(memoryPath, 'utf-8'));
             }
         }
-        catch { /* ignore */ }
+        catch (e) {
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[session-tools] failed to load memory store:', e);
+        }
     }
     if (options.includeTasks) {
         try {
@@ -99,7 +103,10 @@ function loadRelatedStores(options) {
                 data.tasks = JSON.parse(readFileSync(taskPath, 'utf-8'));
             }
         }
-        catch { /* ignore */ }
+        catch (e) {
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[session-tools] failed to load task store:', e);
+        }
     }
     if (options.includeAgents) {
         try {
@@ -108,7 +115,10 @@ function loadRelatedStores(options) {
                 data.agents = JSON.parse(readFileSync(agentPath, 'utf-8'));
             }
         }
-        catch { /* ignore */ }
+        catch (e) {
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[session-tools] failed to load agent store:', e);
+        }
     }
     return data;
 }

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

@@ -36,7 +36,10 @@ function loadSwarmStore() {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch { /* return default */ }
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[swarm-tools] failed to parse swarm-state.json — resetting to empty store:', e);
+    }
     return { swarms: {}, version: '3.0.0' };
 }
 function saveSwarmStore(store) {

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

@@ -51,8 +51,9 @@ function loadMetrics() {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch {
-        // Return default metrics
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[loadMetrics] failed to read/parse metrics.json, using defaults:', e);
     }
     return {
         startTime: new Date().toISOString(),
@@ -543,8 +544,9 @@ export const systemTools = [
                     tasks = Object.values(store.tasks || {});
                 }
             }
-            catch {
-                // empty store
+            catch (e) {
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[task_summary] failed to read/parse task store:', e);
             }
             return {
                 total: tasks.length,

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,45 +1,80 @@
 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';
 const TERMINAL_FILE = 'store.json';
+// ── Secret-shaped env var filtering for terminal_execute ────────────────────
+// terminal_execute runs arbitrary (metacharacter-denylisted) shell commands
+// via execSync with `env: { ...process.env, ...session.env }` — the host
+// process's real environment, which commonly holds provider API keys
+// (ANTHROPIC_API_KEY, OPENAI_API_KEY, ...), CI/VCS tokens, and cloud
+// credentials. A single unpiped command (the metacharacter denylist blocks
+// piping/chaining, but not e.g. `curl` or `aws` invoked directly) can still
+// read and exfiltrate whatever env vars it inherits. Stripping variables
+// whose *names* match common secret conventions is defense-in-depth: it
+// doesn't change legitimate terminal usage (PATH/HOME/etc. stay intact) but
+// meaningfully shrinks what a malicious or hijacked command can read by
+// default. Callers that genuinely need a specific secret can pass it via
+// terminal_create's `env` option, which flows through untouched (session.env
+// 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. */
+export function filterSecretEnvVars(env) {
+    const filtered = {};
+    for (const [k, v] of Object.entries(env)) {
+        if (v === undefined)
+            continue;
+        if (SECRET_ENV_NAME_PATTERN.test(k))
+            continue;
+        filtered[k] = v;
+    }
+    return filtered;
+}
 function getTerminalDir() {
     return join(getProjectCwd(), STORAGE_DIR, TERMINAL_DIR);
 }
 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 = [
     {
@@ -55,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' };
@@ -140,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).
@@ -200,7 +241,7 @@ export const terminalTools = [
                     timeout,
                     maxBuffer: 5 * 1024 * 1024,
                     stdio: ['pipe', 'pipe', 'pipe'],
-                    env: { ...process.env, ...session.env },
+                    env: { ...filterSecretEnvVars(process.env), ...session.env },
                 });
                 exitCode = 0;
             }
@@ -286,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);
         }
     }
     /**