monomind 2.1.9 → 2.3.0

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

@@ -30,21 +30,35 @@ const MAX_AGENT_STORE_BYTES = 50 * 1024 * 1024;
 // (e.g. hive-mind-tools.ts) can reuse this hardened loader instead of
 // maintaining their own weaker copy (missing the size cap / __proto__ guard).
 export function loadAgentStore() {
+    return loadAgentStoreOrNull() ?? { agents: {}, version: '3.0.0' };
+}
+// Like loadAgentStore(), but distinguishes "file doesn't exist yet" (returns
+// the empty default store — safe to build on and save) from "file exists but
+// failed to read/parse, or is corrupt/oversized" (returns null). Handlers
+// that are about to mutate-and-save MUST use this instead of loadAgentStore()
+// and bail out on null, or a transient read failure silently wipes every
+// previously-spawned agent on the next save (the exact bug found and fixed
+// in task-tools.ts's task_assign earlier this session — same pattern here).
+// Exported for other tool modules with their own mutate-and-save paths
+// against the same agent store file — see hive-mind-tools.ts.
+export function loadAgentStoreOrNull() {
     try {
         const path = getAgentPath();
         migrateLegacyStoreFile(path, join(AGENT_DIR, AGENT_FILE));
         if (existsSync(path)) {
             if (statSync(path).size > MAX_AGENT_STORE_BYTES)
-                return { agents: {}, version: '3.0.0' };
+                return null;
             const data = readFileSync(path, 'utf-8');
             const parsed = JSON.parse(data);
             if (parsed && typeof parsed === 'object' && Object.prototype.hasOwnProperty.call(parsed, '__proto__'))
-                return { agents: {}, version: '3.0.0' };
+                return null;
             return parsed;
         }
     }
-    catch {
-        // Return empty store on error
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[loadAgentStore] failed to read/parse agent store — refusing to proceed to avoid overwriting it with an empty one:', e);
+        return null;
     }
     return { agents: {}, version: '3.0.0' };
 }
@@ -126,7 +140,10 @@ export const agentTools = [
             required: ['agentType'],
         },
         handler: async (input) => {
-            const store = loadAgentStore();
+            const store = loadAgentStoreOrNull();
+            if (!store) {
+                return { success: false, error: 'Agent store is unreadable/corrupt — refusing to spawn to avoid overwriting real agent data. Retry, or check the store file if this persists.' };
+            }
             // Cap agentId: used as the JSON object key in store.agents[agentId].
             // An oversized key inflates the on-disk store for every spawned agent.
             // Cap agentType/domain: persisted as AgentRecord field values.
@@ -215,7 +232,10 @@ export const agentTools = [
             if (!agentId || typeof agentId !== 'string' || ['__proto__', 'constructor', 'prototype'].includes(agentId)) {
                 return { success: false, agentId, error: 'Invalid agent ID' };
             }
-            const store = loadAgentStore();
+            const store = loadAgentStoreOrNull();
+            if (!store) {
+                return { success: false, agentId, error: 'Agent store is unreadable/corrupt — refusing to terminate to avoid overwriting real agent data.' };
+            }
             if (Object.hasOwn(store.agents, agentId)) {
                 store.agents[agentId].status = 'terminated';
                 saveAgentStore(store);
@@ -277,25 +297,35 @@ export const agentTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                status: { type: 'string', description: 'Filter by status' },
+                status: { type: 'string', description: 'Filter by status (pass "all" or omit to include every status)' },
                 domain: { type: 'string', description: 'Filter by domain' },
+                agentType: { type: 'string', description: 'Filter by agent type' },
                 includeTerminated: { type: 'boolean', description: 'Include terminated agents' },
             },
         },
         handler: async (input) => {
             const store = loadAgentStore();
             let agents = Object.values(store.agents);
-            // Filter by status
-            if (input.status) {
+            // Filter by status. 'all' (the CLI's `--all` flag sends this literal
+            // string) means "no status filter" — it used to be treated as a real
+            // status value to match against, which no agent ever has, so `--all`
+            // silently returned zero agents instead of every agent.
+            if (input.status && input.status !== 'all') {
                 agents = agents.filter(a => a.status === input.status);
             }
-            else if (!input.includeTerminated) {
+            else if (input.status !== 'all' && !input.includeTerminated) {
                 agents = agents.filter(a => a.status !== 'terminated');
             }
             // Filter by domain
             if (input.domain) {
                 agents = agents.filter(a => a.domain === input.domain);
             }
+            // Filter by agent type — the CLI's `--type` flag has sent this since
+            // it was added, but this handler never read it, so `--type` was a
+            // silent no-op that returned every agent regardless of the filter.
+            if (input.agentType) {
+                agents = agents.filter(a => a.agentType === input.agentType);
+            }
             return {
                 agents: agents.map(a => ({
                     agentId: a.agentId,
@@ -310,6 +340,7 @@ export const agentTools = [
                 filters: {
                     status: input.status,
                     domain: input.domain,
+                    agentType: input.agentType,
                     includeTerminated: input.includeTerminated,
                 },
             };
@@ -329,9 +360,15 @@ export const agentTools = [
             required: ['action'],
         },
         handler: async (input) => {
-            const store = loadAgentStore();
-            const agents = Object.values(store.agents).filter(a => a.status !== 'terminated');
             const action = input.action || 'status'; // Default to status
+            const store = loadAgentStoreOrNull();
+            if (!store) {
+                // 'scale'/'drain' would otherwise build on an empty store and save it,
+                // wiping every real agent; 'status' reporting all-zeros on a corrupt
+                // store would also be misleading, so all three branches bail here.
+                return { action, error: 'Agent store is unreadable/corrupt — refusing to proceed to avoid overwriting real agent data.' };
+            }
+            const agents = Object.values(store.agents).filter(a => a.status !== 'terminated');
             if (action === 'status') {
                 const byType = {};
                 const byStatus = {};
@@ -404,13 +441,16 @@ export const agentTools = [
             }
             if (action === 'drain') {
                 const agentType = input.agentType;
+                // Scope "remaining" to the same population drain operated over — when
+                // filtered by agentType, agents.length (all non-terminated agents,
+                // any type) minus drained (only that type's count) mixed two
+                // different populations and produced a meaningless total.
+                const scoped = agentType ? agents.filter(a => a.agentType === agentType) : agents;
                 let drained = 0;
-                for (const agent of agents) {
-                    if (!agentType || agent.agentType === agentType) {
-                        if (agent.status === 'idle') {
-                            store.agents[agent.agentId].status = 'terminated';
-                            drained++;
-                        }
+                for (const agent of scoped) {
+                    if (agent.status === 'idle') {
+                        store.agents[agent.agentId].status = 'terminated';
+                        drained++;
                     }
                 }
                 saveAgentStore(store);
@@ -418,7 +458,7 @@ export const agentTools = [
                     action,
                     agentType: agentType || 'all',
                     drained,
-                    remaining: agents.length - drained,
+                    remaining: scoped.length - drained,
                 };
             }
             return { action, error: 'Unknown action' };
@@ -521,7 +561,10 @@ export const agentTools = [
             if (!agentId || typeof agentId !== 'string' || ['__proto__', 'constructor', 'prototype'].includes(agentId)) {
                 return { success: false, agentId, error: 'Invalid agent ID' };
             }
-            const store = loadAgentStore();
+            const store = loadAgentStoreOrNull();
+            if (!store) {
+                return { success: false, agentId, error: 'Agent store is unreadable/corrupt — refusing to update to avoid overwriting real agent data.' };
+            }
             const agent = Object.hasOwn(store.agents, agentId) ? store.agents[agentId] : undefined;
             if (agent) {
                 if (input.status)

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