monomind 2.2.0 → 2.3.0

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

@@ -28,8 +28,10 @@ function loadClaims() {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch {
+    catch (e) {
         // Return empty store on error
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[claims-tools] failed to load claims.json, starting fresh:', e);
     }
     return { claims: {}, stealable: {}, contests: {} };
 }

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

@@ -52,8 +52,9 @@ function loadConfigStore() {
             };
         }
     }
-    catch {
-        // Return default store on error
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[config-tools] failed to load config store, using defaults:', e);
     }
     return {
         values: { ...DEFAULT_CONFIG },

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

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

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

@@ -54,8 +54,10 @@ function loadConfig() {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch {
+    catch (e) {
         // Return null on error
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[embeddings-tools] config read/parse failed:', e);
     }
     return null;
 }
@@ -457,8 +459,10 @@ export const embeddingsTools = [
                     },
                 };
             }
-            catch {
+            catch (e) {
                 // Database not available - return empty but truthful
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[embeddings-tools] search failed:', e);
                 const searchTime = (performance.now() - startTime).toFixed(2);
                 return {
                     success: true,

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

@@ -31,8 +31,9 @@ function loadGitHubStore() {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch {
-        // Return empty store
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[github-tools] failed to parse store.json, using empty store:', e);
     }
     return { repos: {}, prs: {}, issues: {}, version: '3.0.0' };
 }
@@ -199,7 +200,10 @@ export const githubTools = [
                             const prs = JSON.parse(raw);
                             return { success: true, _real: true, source: 'gh-cli', pullRequests: prs, total: prs.length };
                         }
-                        catch { /* fall through */ }
+                        catch (e) {
+                            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                                console.error('[github-tools] failed to parse gh pr list output:', e);
+                        }
                     }
                 }
                 const prs = Object.values(store.prs);
@@ -247,7 +251,10 @@ export const githubTools = [
                         try {
                             return { success: true, _real: true, action: 'review', pullRequest: JSON.parse(raw) };
                         }
-                        catch { /* fall through */ }
+                        catch (e) {
+                            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                                console.error('[github-tools] failed to parse gh pr view output:', e);
+                        }
                     }
                 }
                 return { success: false, error: 'gh CLI not available or PR not found. Install gh: https://cli.github.com' };
@@ -325,7 +332,10 @@ export const githubTools = [
                             const issues = JSON.parse(raw);
                             return { success: true, _real: true, source: 'gh-cli', issues, total: issues.length };
                         }
-                        catch { /* fall through */ }
+                        catch (e) {
+                            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                                console.error('[github-tools] failed to parse gh issue list output:', e);
+                        }
                     }
                 }
                 const issues = Object.values(store.issues);
@@ -436,14 +446,20 @@ export const githubTools = [
                     try {
                         return { success: true, _real: true, runs: JSON.parse(raw) };
                     }
-                    catch { /* fall through */ }
+                    catch (e) {
+                        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                            console.error('[github-tools] failed to parse gh run list output:', e);
+                    }
                 }
                 const workflows = run('gh workflow list --json id,name,state');
                 if (workflows) {
                     try {
                         return { success: true, _real: true, workflows: JSON.parse(workflows) };
                     }
-                    catch { /* fall through */ }
+                    catch (e) {
+                        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                            console.error('[github-tools] failed to parse gh workflow list output:', e);
+                    }
                 }
             }
             if (action === 'status') {
@@ -454,7 +470,10 @@ export const githubTools = [
                         try {
                             return { success: true, _real: true, run: JSON.parse(raw) };
                         }
-                        catch { /* fall through */ }
+                        catch (e) {
+                            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                                console.error('[github-tools] failed to parse gh run view output:', e);
+                        }
                     }
                 }
                 // List recent runs as fallback
@@ -463,7 +482,10 @@ export const githubTools = [
                     try {
                         return { success: true, _real: true, recentRuns: JSON.parse(recent) };
                     }
-                    catch { /* fall through */ }
+                    catch (e) {
+                        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                            console.error('[github-tools] failed to parse gh run list (recent) output:', e);
+                    }
                 }
             }
             if (action === 'trigger') {
@@ -538,7 +560,10 @@ export const githubTools = [
                         try {
                             result.releases = JSON.parse(raw);
                         }
-                        catch { /* skip */ }
+                        catch (e) {
+                            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                                console.error('[github-tools] failed to parse gh release list output:', e);
+                        }
                     }
                 }
                 if (!result.releases) {

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

@@ -18,7 +18,7 @@ import { weightedTally } from '../consensus/tally.js';
 // Reuse agent-tools.ts's hardened store loader (50MB size cap + __proto__
 // rejection) instead of maintaining a second, weaker copy that reads the
 // same physical file — see loadAgentStore export note there.
-import { loadAgentStore } from './agent-tools.js';
+import { loadAgentStore, loadAgentStoreOrNull } from './agent-tools.js';
 // Storage paths
 const STORAGE_DIR = '.monomind';
 const HIVE_DIR = 'hive-mind';
@@ -117,8 +117,9 @@ function loadHiveState() {
             return JSON.parse(data);
         }
     }
-    catch {
-        // Return default state on error
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[hive-mind-tools] failed to parse hive state.json — resetting to default state:', e);
     }
     return {
         initialized: false,
@@ -226,7 +227,13 @@ export const hiveMindTools = [
             const rawPrefix = input.prefix || 'hive-worker';
             const prefix = typeof rawPrefix === 'string' && rawPrefix.length > MAX_HIVE_PREFIX_LEN
                 ? rawPrefix.slice(0, MAX_HIVE_PREFIX_LEN) : rawPrefix;
-            const agentStore = loadAgentStore();
+            // Must use the null-aware loader here (this handler mutates and saves)
+            // — loadAgentStore() on a corrupt/oversized store.json now returns the
+            // empty default, and saving that back would wipe every real agent.
+            const agentStore = loadAgentStoreOrNull();
+            if (!agentStore) {
+                return { success: false, error: 'Agent store is unreadable/corrupt — refusing to spawn hive workers to avoid overwriting real agent data.' };
+            }
             const spawnedWorkers = [];
             for (let i = 0; i < count; i++) {
                 const agentId = `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
@@ -375,7 +382,10 @@ export const hiveMindTools = [
                     }
                 }
             }
-            catch { /* ignore */ }
+            catch (e) {
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[hive-mind-tools] failed to parse task store — task counts default to 0:', e);
+            }
             const workerCount = Math.max(1, state.workers.length);
             const realLoad = activeTaskCount / workerCount;
             const status = {
@@ -1000,8 +1010,15 @@ export const hiveMindTools = [
                     workerCount,
                 };
             }
-            // Clear workers from agent store
-            const agentStore = loadAgentStore();
+            // Clear workers from agent store. Must use the null-aware loader here
+            // (this handler mutates and saves) — loadAgentStore() on a corrupt/
+            // oversized store.json now returns the empty default, and deleting
+            // from + saving that back would wipe every real agent, not just the
+            // hive workers being shut down.
+            const agentStore = loadAgentStoreOrNull();
+            if (!agentStore) {
+                return { success: false, error: 'Agent store is unreadable/corrupt — refusing to shut down to avoid overwriting real agent data.', pendingConsensus, workerCount };
+            }
             for (const workerId of state.workers) {
                 if (agentStore.agents[workerId]) {
                     delete agentStore.agents[workerId];

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

@@ -141,7 +141,11 @@ export function loadRoutingOutcomes() {
             return data.outcomes || [];
         }
     }
-    catch { /* corrupt file, start fresh */ }
+    catch (e) {
+        /* corrupt file, start fresh */
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[hooks-embedding] routing-outcomes.json read/parse failed:', e);
+    }
     return [];
 }
 export function saveRoutingOutcomes(outcomes) {
@@ -155,7 +159,11 @@ export function saveRoutingOutcomes(outcomes) {
         writeFileSync(tmp, JSON.stringify({ outcomes: capped }, null, 2));
         renameSync(tmp, getRoutingOutcomesPath());
     }
-    catch { /* non-critical */ }
+    catch (e) {
+        /* non-critical */
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[hooks-embedding] routing-outcomes.json write failed:', e);
+    }
 }
 /**
  * Build learned routing patterns from successful task outcomes.
@@ -265,8 +273,10 @@ export function loadMemoryStore() {
             return JSON.parse(data);
         }
     }
-    catch {
+    catch (e) {
         // Return empty store on error
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[hooks-embedding] memory store.json read/parse failed:', e);
     }
     return { entries: {}, version: '3.0.0' };
 }

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

@@ -260,9 +260,11 @@ export const hooksTrajectoryEnd = {
                     },
                 });
             }
-            catch {
+            catch (e) {
                 // Non-fatal: intelligence bridge unavailable, trajectory is still
                 // persisted via the legacy store above.
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[hooks-intelligence] intelligence bridge recordStep failed:', e);
             }
         }
         // SONA Learning - process trajectory outcome for routing optimization
@@ -295,8 +297,10 @@ export const hooksTrajectoryEnd = {
                         confidence: result.confidence,
                     };
                 }
-                catch {
+                catch (e) {
                     // SONA learning failed, continue without it
+                    if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                        console.error('[hooks-intelligence] SONA processTrajectoryOutcome failed:', e);
                 }
             }
             // Try EWC++ consolidation on successful trajectories
@@ -314,8 +318,10 @@ export const hooksTrajectoryEnd = {
                             penalty: stats.avgPenalty,
                         };
                     }
-                    catch {
+                    catch (e) {
                         // EWC consolidation failed, continue without it
+                        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                            console.error('[hooks-intelligence] EWC consolidation failed:', e);
                     }
                 }
             }

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

@@ -20,6 +20,7 @@ export declare const hooksPretrain: MCPTool;
 export declare const hooksBuildAgents: MCPTool;
 export declare const hooksTransfer: MCPTool;
 export declare const hooksSessionStart: MCPTool;
+export declare const hooksSessionRestore: MCPTool;
 export declare const hooksSessionEnd: MCPTool;
 export declare const hooksIntelligence: MCPTool;
 //# sourceMappingURL=hooks-routing.d.ts.map

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,