monomind 1.7.0 → 1.9.0

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

@@ -4,7 +4,7 @@
  * Helps the system navigate Monomind's capabilities by providing structured
  * discovery of tools, commands, agents, skills, and recommended workflows.
  *
- * @module @monoes/cli/mcp-tools/guidance
+ * @module @monomind/cli/mcp-tools/guidance
  */
 import { getProjectCwd } from './types.js';
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
@@ -18,21 +18,34 @@ const CLI_ROOT = join(__dirname, '../../..');
  * Tries CWD first (most common), then walks up from the CLI package location.
  */
 function findProjectRoot() {
+    // Allow operator override; trusted when set.
+    const envRoot = process.env.MONOMIND_PROJECT_ROOT;
+    if (envRoot && existsSync(join(envRoot, '.claude'))) {
+        return envRoot;
+    }
     // Strategy 1: CWD (most reliable when invoked by user)
     if (existsSync(join(getProjectCwd(), '.claude'))) {
         return getProjectCwd();
     }
-    // Strategy 2: Walk up from CLI package location
-    // CLI is at packages/@monoes/cli/ — project root is 4 levels up
+    // Strategy 2: Walk up from CLI package location.
+    // CLI is at packages/@monomind/cli/ — project root is 4 levels up.
     const fromPackage = join(CLI_ROOT, '../../../..');
     if (existsSync(join(fromPackage, '.claude'))) {
         return fromPackage;
     }
-    // Strategy 3: Walk up from CWD
+    // Strategy 3: Walk up from CWD, but stop at the first ancestor that ALSO
+    // contains a project-marker the user owns (`.git` or `package.json`). This
+    // closes a confused-deputy: previously, dropping `.claude/agents/x.md` in
+    // any of 10 ancestor directories (e.g., `/tmp`) would have been consumed
+    // as authoritative agent data. Requiring a marker means an attacker also
+    // needs control over a `.git` repo or `package.json` at the same level —
+    // which means they already control the project.
     let dir = getProjectCwd();
     for (let i = 0; i < 10; i++) {
-        if (existsSync(join(dir, '.claude')))
+        if (existsSync(join(dir, '.claude')) &&
+            (existsSync(join(dir, '.git')) || existsSync(join(dir, 'package.json')))) {
             return dir;
+        }
         const parent = dirname(dir);
         if (parent === dir)
             break;
@@ -288,15 +301,28 @@ function discoverAgents() {
     if (!existsSync(agentsDir))
         return [];
     const agents = [];
-    function walk(dir) {
+    const visited = new Set();
+    // Symlink-aware walk with depth cap. `entry.isDirectory()` returns true for
+    // symlinks pointing at directories, so a careless `agents/loop -> ..`
+    // symlink would otherwise traverse outside the agents tree (or loop
+    // forever). Using lstat + skipping symlinks closes both vectors.
+    function walk(dir, depth) {
+        if (depth > 8)
+            return;
+        if (visited.has(dir))
+            return;
+        visited.add(dir);
         try {
             const entries = readdirSync(dir, { withFileTypes: true });
             for (const entry of entries) {
+                if (entry.isSymbolicLink())
+                    continue;
+                const full = join(dir, entry.name);
                 if (entry.isDirectory()) {
-                    walk(join(dir, entry.name));
+                    walk(full, depth + 1);
                 }
-                else if (entry.name.endsWith('.md') && entry.name !== 'MIGRATION_SUMMARY.md') {
-                    const content = readFileSync(join(dir, entry.name), 'utf-8');
+                else if (entry.isFile() && entry.name.endsWith('.md') && entry.name !== 'MIGRATION_SUMMARY.md') {
+                    const content = readFileSync(full, 'utf-8');
                     const nameMatch = content.match(/^name:\s*(.+)$/m);
                     if (nameMatch)
                         agents.push(nameMatch[1].trim().replace(/^["']|["']$/g, ''));
@@ -305,7 +331,7 @@ function discoverAgents() {
         }
         catch { /* ignore */ }
     }
-    walk(agentsDir);
+    walk(agentsDir, 0);
     return [...new Set(agents)].sort();
 }
 function discoverSkills() {
@@ -316,6 +342,8 @@ function discoverSkills() {
     try {
         const entries = readdirSync(skillsDir, { withFileTypes: true });
         for (const entry of entries) {
+            if (entry.isSymbolicLink())
+                continue;
             if (entry.isDirectory()) {
                 const skillFile = join(skillsDir, entry.name, 'SKILL.md');
                 if (existsSync(skillFile)) {

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

@@ -3,18 +3,10 @@
  *
  * Tool definitions for collective intelligence and swarm coordination.
  */
-import { existsSync, readFileSync, writeFileSync, mkdirSync, appendFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
 import { weightedTally } from '../consensus/vote-signer.js';
-function logEvent(kind, data) {
-    try {
-        const dir = join(getProjectCwd(), '.monomind', 'swarm');
-        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-        const event = { ts: new Date().toISOString(), source: 'mcp', kind, ...data };
-        appendFileSync(join(dir, 'events.jsonl'), JSON.stringify(event) + '\n');
-    } catch { }
-}
 // Storage paths
 const STORAGE_DIR = '.monomind';
 const HIVE_DIR = 'hive-mind';
@@ -127,12 +119,16 @@ function loadHiveState() {
 function saveHiveState(state) {
     ensureHiveDir();
     state.updatedAt = new Date().toISOString();
-    writeFileSync(getHivePath(), JSON.stringify(state, null, 2), 'utf-8');
+    const dest = getHivePath();
+    const tmp = `${dest}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmp, JSON.stringify(state, null, 2), 'utf-8');
+    renameSync(tmp, dest);
 }
 // Import agent store helpers for spawn functionality
 import { existsSync as agentStoreExists, readFileSync as readAgentStore, writeFileSync as writeAgentStore, mkdirSync as mkdirAgentStore } from 'node:fs';
+// Canonical agent store path matches agent-tools.ts: .monomind/agents/store.json
 function loadAgentStore() {
-    const storePath = join(getProjectCwd(), '.monomind', 'agents.json');
+    const storePath = join(getProjectCwd(), '.monomind', 'agents', 'store.json');
     try {
         if (agentStoreExists(storePath)) {
             return JSON.parse(readAgentStore(storePath, 'utf-8'));
@@ -141,12 +137,16 @@ function loadAgentStore() {
     catch { /* ignore */ }
     return { agents: {} };
 }
+const HIVE_RESERVED_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 function saveAgentStore(store) {
-    const storeDir = join(getProjectCwd(), '.monomind');
+    const storeDir = join(getProjectCwd(), '.monomind', 'agents');
     if (!agentStoreExists(storeDir)) {
         mkdirAgentStore(storeDir, { recursive: true });
     }
-    writeAgentStore(join(storeDir, 'agents.json'), JSON.stringify(store, null, 2), 'utf-8');
+    const dest = join(storeDir, 'store.json');
+    const tmp = `${dest}.${process.pid}.${Date.now()}.tmp`;
+    writeAgentStore(tmp, JSON.stringify(store, null, 2), 'utf-8');
+    renameSync(tmp, dest);
 }
 export const hiveMindTools = [
     {
@@ -175,6 +175,8 @@ export const hiveMindTools = [
             const spawnedWorkers = [];
             for (let i = 0; i < count; i++) {
                 const agentId = `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+                if (HIVE_RESERVED_KEYS.has(agentId))
+                    continue;
                 // Create agent record (like agent/spawn)
                 agentStore.agents[agentId] = {
                     agentId,
@@ -187,7 +189,11 @@ export const hiveMindTools = [
                     domain: 'hive-mind',
                 };
                 // Join to hive-mind (like hive-mind/join)
+                const MAX_HIVE_AGENTS = 100;
                 if (!state.workers.includes(agentId)) {
+                    if (state.workers.length >= MAX_HIVE_AGENTS) {
+                        return { success: false, error: `Hive has reached max agent capacity (${MAX_HIVE_AGENTS})` };
+                    }
                     state.workers.push(agentId);
                 }
                 spawnedWorkers.push({
@@ -198,9 +204,6 @@ export const hiveMindTools = [
             }
             saveAgentStore(agentStore);
             saveHiveState(state);
-            for (const w of spawnedWorkers) {
-                logEvent('hive.spawn', { agentId: w.agentId, role: w.role, agentType });
-            }
             return {
                 success: true,
                 spawned: count,
@@ -223,19 +226,21 @@ export const hiveMindTools = [
             },
         },
         handler: async (input) => {
-            const state = loadHiveState();
             const hiveId = `hive-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
             const queenId = input.queenId || `queen-${Date.now()}`;
-            state.initialized = true;
-            state.topology = input.topology || 'mesh';
-            state.createdAt = new Date().toISOString();
-            state.queen = {
-                agentId: queenId,
-                electedAt: new Date().toISOString(),
-                term: 1,
+            const now = new Date().toISOString();
+            const state = {
+                initialized: true,
+                hiveId,
+                topology: input.topology || 'mesh',
+                queen: { agentId: queenId, electedAt: now, term: 1 },
+                workers: [],
+                consensus: { pending: [], history: [] },
+                sharedMemory: {},
+                createdAt: now,
+                updatedAt: now,
             };
             saveHiveState(state);
-            logEvent('hive.init', { hiveId, topology: state.topology, consensus: input.consensus || 'byzantine', queenId });
             return {
                 success: true,
                 hiveId,
@@ -292,7 +297,7 @@ export const hiveMindTools = [
             const realLoad = activeTaskCount / workerCount;
             const status = {
                 // CLI expected fields
-                hiveId: `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
+                hiveId: state.hiveId ?? `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
                 status: state.initialized ? 'active' : 'offline',
                 topology: state.topology,
                 consensus: 'byzantine', // Default consensus type
@@ -332,7 +337,7 @@ export const hiveMindTools = [
                     memory: 'healthy',
                 },
                 // Additional fields
-                id: `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
+                id: state.hiveId ?? `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
                 initialized: state.initialized,
                 workerCount: state.workers.length,
                 pendingConsensus: state.consensus.pending.length,
@@ -367,10 +372,20 @@ export const hiveMindTools = [
         handler: async (input) => {
             const state = loadHiveState();
             const agentId = input.agentId;
+            // Reject IDs that would mutate Object.prototype when used as a key on the
+            // JSON-loaded plain object `agentStore.agents` (read in hive-mind_status).
+            if (typeof agentId !== 'string' || agentId.length === 0 || agentId.length > 128 ||
+                HIVE_RESERVED_KEYS.has(agentId) || !/^[a-zA-Z0-9_-]+$/.test(agentId)) {
+                return { success: false, error: 'Invalid agentId' };
+            }
             if (!state.initialized) {
                 return { success: false, error: 'Hive-mind not initialized' };
             }
+            const MAX_HIVE_AGENTS = 100;
             if (!state.workers.includes(agentId)) {
+                if (state.workers.length >= MAX_HIVE_AGENTS) {
+                    return { success: false, error: `Hive has reached max agent capacity (${MAX_HIVE_AGENTS})` };
+                }
                 state.workers.push(agentId);
                 saveHiveState(state);
             }
@@ -397,6 +412,10 @@ export const hiveMindTools = [
         handler: async (input) => {
             const state = loadHiveState();
             const agentId = input.agentId;
+            if (typeof agentId !== 'string' || agentId.length === 0 || agentId.length > 128 ||
+                HIVE_RESERVED_KEYS.has(agentId) || !/^[a-zA-Z0-9_-]+$/.test(agentId)) {
+                return { success: false, error: 'Invalid agentId' };
+            }
             const index = state.workers.indexOf(agentId);
             if (index > -1) {
                 state.workers.splice(index, 1);
@@ -436,7 +455,7 @@ export const hiveMindTools = [
             const state = loadHiveState();
             const action = input.action;
             const strategy = input.strategy || 'raft';
-            const totalNodes = state.workers.length || 1;
+            const totalNodes = state.workers.length;
             if (action === 'propose') {
                 const proposalId = `proposal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
                 const quorumPreset = input.quorumPreset || 'majority';
@@ -476,7 +495,6 @@ export const hiveMindTools = [
                 };
                 state.consensus.pending.push(proposal);
                 saveHiveState(state);
-                logEvent('hive.consensus.propose', { proposalId, type: proposal.type, strategy, proposedBy: proposal.proposedBy, totalNodes });
                 return {
                     action,
                     proposalId,
@@ -500,6 +518,12 @@ export const hiveMindTools = [
                 if (!voterId) {
                     return { action, error: 'voterId is required for voting' };
                 }
+                if (totalNodes === 0) {
+                    return { action, error: 'No workers in hive — cannot vote' };
+                }
+                if (!state.workers.includes(voterId)) {
+                    return { action, error: `Voter ${voterId} is not a member of this hive` };
+                }
                 const voteValue = input.vote;
                 const proposalStrategy = proposal.strategy || 'raft';
                 const required = calculateRequiredVotes(proposalStrategy, totalNodes, proposal.quorumPreset);
@@ -598,11 +622,9 @@ export const hiveMindTools = [
                 // Try to resolve
                 const resolution = divergenceGateOpen ? tryResolveProposal(proposal, totalNodes) : null;
                 let resolved = false;
-                logEvent('hive.consensus.vote', { proposalId: proposal.proposalId, voterId, vote: voteValue, strategy: proposalStrategy, votesFor, votesAgainst });
                 if (resolution !== null) {
                     resolved = true;
                     proposal.status = resolution;
-                    logEvent('hive.consensus.resolved', { proposalId: proposal.proposalId, result: resolution, strategy: proposalStrategy, votesFor, votesAgainst });
                     state.consensus.history.push({
                         proposalId: proposal.proposalId,
                         type: proposal.type,
@@ -613,6 +635,9 @@ export const hiveMindTools = [
                         term: proposal.term,
                         byzantineDetected: proposal.byzantineVoters?.length ? proposal.byzantineVoters : undefined,
                     });
+                    if (state.consensus.history.length > 1000) {
+                        state.consensus.history = state.consensus.history.slice(-1000);
+                    }
                     state.consensus.pending = state.consensus.pending.filter(p => p.proposalId !== proposal.proposalId);
                 }
                 saveHiveState(state);
@@ -635,6 +660,44 @@ export const hiveMindTools = [
                         });
                     }
                     catch { /* AgentDB not available — JSON store is primary */ }
+                    // Persist consensus audit record
+                    const sessionSecret = process.env.MONOMIND_SESSION_SECRET;
+                    if (!sessionSecret) {
+                        process.stderr.write('[hive-consensus] Audit write skipped: MONOMIND_SESSION_SECRET not set\n');
+                    }
+                    else {
+                        try {
+                            const { AuditWriter } = await import('../consensus/audit-writer.js');
+                            const auditDir = join(getProjectCwd(), STORAGE_DIR, 'consensus');
+                            const writer = new AuditWriter(auditDir);
+                            const now = new Date().toISOString();
+                            const voteEntries = Object.entries(proposal.votes).map(([agentId, vote]) => ({
+                                agentId,
+                                agentSlug: agentId,
+                                vote,
+                                votedAt: now,
+                            }));
+                            writer.record({
+                                decisionId: proposal.proposalId,
+                                swarmId: `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
+                                protocol: (proposalStrategy === 'bft' ? 'byzantine' : proposalStrategy === 'raft' ? 'raft' : 'quorum'),
+                                topic: proposal.type,
+                                decision: resolution,
+                                votes: voteEntries,
+                                quorumRequired: required,
+                                quorumThreshold: required / Math.max(totalNodes, 1),
+                                round: (proposal.divergenceRoundsSeen ?? 0) + 1,
+                                startedAt: proposal.proposedAt,
+                                completedAt: now,
+                                sessionSecret,
+                            });
+                        }
+                        catch (e) {
+                            if (process.env.MONOMIND_LOG_LEVEL === 'debug') {
+                                process.stderr.write(`[hive-consensus] Audit write failed: ${e.message}\n`);
+                            }
+                        }
+                    }
                 }
                 return {
                     action,
@@ -750,7 +813,6 @@ export const hiveMindTools = [
             // Keep only last 100 broadcasts
             state.sharedMemory.broadcasts = messages.slice(-100);
             saveHiveState(state);
-            logEvent('hive.broadcast', { messageId, fromId: input.fromId || 'system', message: input.message, priority: input.priority || 'normal', recipients: state.workers.length });
             return {
                 success: true,
                 messageId,
@@ -800,7 +862,6 @@ export const hiveMindTools = [
             // Reset hive state
             const shutdownTime = new Date().toISOString();
             const previousQueen = state.queen?.agentId;
-            logEvent('hive.shutdown', { workersTerminated: workerCount, previousQueen, graceful, pendingConsensus, topology: state.topology });
             state.initialized = false;
             state.queen = undefined;
             state.workers = [];
@@ -849,6 +910,8 @@ export const hiveMindTools = [
             if (action === 'set') {
                 if (!key)
                     return { action, error: 'Key required' };
+                if (HIVE_RESERVED_KEYS.has(key))
+                    return { action, error: 'Forbidden key' };
                 state.sharedMemory[key] = input.value;
                 saveHiveState(state);
                 // Also store in AgentDB for searchable hive memory

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

@@ -2,17 +2,9 @@
  * Hooks MCP Tools
  * Provides intelligent hooks functionality via MCP protocol
  */
-import { mkdirSync, writeFileSync, existsSync, readFileSync, statSync, unlinkSync, readdirSync, appendFileSync } from 'fs';
-import { dirname, join, resolve } from 'path';
+import { mkdirSync, writeFileSync, renameSync, existsSync, readFileSync, statSync, unlinkSync, readdirSync } from 'fs';
+import { dirname, join, resolve, sep } from 'path';
 import { getProjectCwd } from './types.js';
-function logEvent(kind, data) {
-    try {
-        const dir = join(getProjectCwd(), '.monomind', 'swarm');
-        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-        const event = { ts: new Date().toISOString(), source: 'hook', kind, ...data };
-        appendFileSync(join(dir, 'events.jsonl'), JSON.stringify(event) + '\n');
-    } catch { }
-}
 // Real vector search functions - lazy loaded to avoid circular imports
 let searchEntriesFn = null;
 async function getRealSearchFunction() {
@@ -92,7 +84,8 @@ let semanticRouter = null;
 let nativeVectorDb = null;
 let semanticRouterInitialized = false;
 let routerBackend = 'none';
-// Pre-computed embeddings for common task patterns (cached)
+// Pre-computed embeddings for common task patterns (cached, capped to prevent unbounded growth)
+const MAX_PATTERN_EMBEDDINGS = 2000;
 const TASK_PATTERN_EMBEDDINGS = new Map();
 function generateSimpleEmbedding(text, dimension = 384) {
     // Simple deterministic embedding based on character codes
@@ -168,7 +161,9 @@ function saveRoutingOutcomes(outcomes) {
             mkdirSync(dir, { recursive: true });
         // Cap at 500 entries to bound file size
         const capped = outcomes.slice(-500);
-        writeFileSync(ROUTING_OUTCOMES_PATH, JSON.stringify({ outcomes: capped }, null, 2));
+        const tmp = ROUTING_OUTCOMES_PATH + '.tmp';
+        writeFileSync(tmp, JSON.stringify({ outcomes: capped }, null, 2));
+        renameSync(tmp, ROUTING_OUTCOMES_PATH);
     }
     catch { /* non-critical */ }
 }
@@ -293,7 +288,9 @@ async function getSemanticRouter() {
                 for (const keyword of keywords) {
                     const embedding = generateSimpleEmbedding(keyword);
                     db.insert(`${patternName}:${keyword}`, embedding);
-                    TASK_PATTERN_EMBEDDINGS.set(`${patternName}:${keyword}`, embedding);
+                    if (TASK_PATTERN_EMBEDDINGS.size < MAX_PATTERN_EMBEDDINGS) {
+                        TASK_PATTERN_EMBEDDINGS.set(`${patternName}:${keyword}`, embedding);
+                    }
                 }
             }
             nativeVectorDb = db;
@@ -313,9 +310,11 @@ async function getSemanticRouter() {
         for (const [patternName, { keywords, agents }] of Object.entries(getMergedTaskPatterns())) {
             const embeddings = keywords.map(kw => generateSimpleEmbedding(kw));
             semanticRouter.addIntentWithEmbeddings(patternName, embeddings, { agents, keywords });
-            // Cache embeddings for keywords
+            // Cache embeddings for keywords (capped)
             keywords.forEach((kw, i) => {
-                TASK_PATTERN_EMBEDDINGS.set(kw, embeddings[i]);
+                if (TASK_PATTERN_EMBEDDINGS.size < MAX_PATTERN_EMBEDDINGS) {
+                    TASK_PATTERN_EMBEDDINGS.set(kw, embeddings[i]);
+                }
             });
         }
         routerBackend = 'pure-js';
@@ -353,18 +352,10 @@ async function getFlashAttention() {
     }
     return flashAttention;
 }
-// LoRA Adapter - lazy loaded
+// LoRA Adapter removed — superseded by SONA instant adaptation
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 let loraAdapter = null;
 async function getLoRAAdapter() {
-    if (!loraAdapter) {
-        try {
-            const { getLoRAAdapter: getLora } = await import('../ruvector/lora-adapter.js');
-            loraAdapter = await getLora();
-        }
-        catch {
-            loraAdapter = null;
-        }
-    }
     return loraAdapter;
 }
 // In-memory trajectory tracking (persisted on end)
@@ -372,7 +363,7 @@ const activeTrajectories = new Map();
 const MEMORY_DIR = '.monomind/memory';
 const MEMORY_FILE = 'store.json';
 function getMemoryPath() {
-    return resolve(join(MEMORY_DIR, MEMORY_FILE));
+    return join(getProjectCwd(), MEMORY_DIR, MEMORY_FILE);
 }
 function loadMemoryStore() {
     try {
@@ -718,10 +709,13 @@ export const hooksPostCommand = {
                 const store = loadMemoryStore();
                 const key = `cmd-${Date.now()}`;
                 store.entries[key] = { key, value: JSON.stringify({ command, exitCode, success }), namespace: 'commands', createdAt: new Date().toISOString() };
-                const memDir = resolve(MEMORY_DIR);
+                const memDir = join(getProjectCwd(), MEMORY_DIR);
                 if (!existsSync(memDir))
                     mkdirSync(memDir, { recursive: true });
-                writeFileSync(getMemoryPath(), JSON.stringify(store, null, 2), 'utf-8');
+                const _mp = getMemoryPath();
+                const _mptmp = _mp + '.tmp';
+                writeFileSync(_mptmp, JSON.stringify(store, null, 2), 'utf-8');
+                renameSync(_mptmp, _mp);
                 _storedIn = 'json-store';
             }
             catch { /* non-critical */ }
@@ -1078,7 +1072,7 @@ export const hooksPreTask = {
                 });
                 for (const r of (heuristicResults?.results ?? [])) {
                     try {
-                        const h = JSON.parse(r.content ?? r.value ?? '{}');
+                        const h = JSON.parse(r.content ?? '{}');
                         if (h.action && h.confidence !== undefined && h.confidence >= 0.6) {
                             erlHints.push(`ERL hint (conf=${h.confidence.toFixed(2)}): use "${h.action}" for tasks involving "${h.condition ?? 'similar context'}"`);
                         }
@@ -1094,7 +1088,7 @@ export const hooksPreTask = {
                     threshold: 0.55,
                 });
                 for (const r of (gradientResults?.results ?? [])) {
-                    const critique = r.content ?? r.value ?? '';
+                    const critique = r.content ?? '';
                     if (critique && critique.length > 10) {
                         erlHints.push(`TextGrad warning: ${critique.slice(0, 120)}`);
                     }
@@ -1102,7 +1096,6 @@ export const hooksPreTask = {
             }
         }
         catch { /* non-critical */ }
-        logEvent('task.start', { taskId, description: description?.slice(0, 200), complexity, suggestedAgent: suggestion.agents[0], modelTier: modelRouting?.tier });
         return {
             taskId,
             description,
@@ -1246,7 +1239,7 @@ export const hooksPostTask = {
                         key: `textual_gradient:${taskId}`,
                         value: critique,
                         namespace: 'gradients',
-                        tags: ['textual_gradient', agent, 'failure'],
+                        tags: ['textual_gradient', agent ?? 'unknown', 'failure'],
                     });
                 }
             }
@@ -1265,7 +1258,6 @@ export const hooksPostTask = {
             storeAs: 'heuristics',
             note: 'Spawn agents sequentially: Diagnoser → Critics in parallel → Aggregator',
         } : { needed: false };
-        logEvent('task.end', { taskId, success, duration, agent, quality, task: taskText?.slice(0, 200) });
         return {
             taskId,
             success,
@@ -1375,6 +1367,10 @@ export const hooksPretrain = {
     },
     handler: async (params) => {
         const repoPath = resolve(params.path || '.');
+        const projectRoot = getProjectCwd();
+        if (repoPath !== projectRoot && !repoPath.startsWith(projectRoot + sep)) {
+            return { error: 'Invalid path: must be within the project directory.' };
+        }
         const depth = params.depth || 'medium';
         const startTime = performance.now();
         // Real file scanning — count files by extension, extract patterns
@@ -1472,9 +1468,20 @@ export const hooksBuildAgents = {
         },
     },
     handler: async (params) => {
-        const outputDir = resolve(params.outputDir || './agents');
+        const rawOutputDir = resolve(params.outputDir || './agents');
+        const outputDir = rawOutputDir;
+        if (!outputDir.startsWith(getProjectCwd() + sep) && outputDir !== getProjectCwd()) {
+            return { error: 'Invalid outputDir: must be within the project directory.' };
+        }
         const focus = params.focus || 'all';
-        const format = params.format || 'yaml';
+        // Strict allowlist on `format` — without this, `format = "yaml/../../../etc/cron.d/x"`
+        // collapses through `join` and lets writes escape the validated outputDir.
+        const ALLOWED_FORMATS = new Set(['yaml', 'json']);
+        const formatRaw = params.format || 'yaml';
+        if (!ALLOWED_FORMATS.has(formatRaw)) {
+            return { error: 'Invalid format: must be yaml or json' };
+        }
+        const format = formatRaw;
         const persist = params.persist !== false; // Default to true
         const agents = [
             { type: 'coder', configFile: join(outputDir, `coder.${format}`), capabilities: ['code-generation', 'refactoring', 'debugging'], optimizations: ['flash-attention', 'token-reduction'] },
@@ -1505,7 +1512,9 @@ export const hooksBuildAgents = {
                 const content = format === 'json'
                     ? JSON.stringify(config, null, 2)
                     : `# ${agent.type} agent configuration\ntype: ${agent.type}\nversion: "3.0.0"\ncapabilities:\n${agent.capabilities.map(c => `  - ${c}`).join('\n')}\noptimizations:\n${agent.optimizations.map(o => `  - ${o}`).join('\n')}\ncreatedAt: "${config.createdAt}"\n`;
-                writeFileSync(agent.configFile, content, 'utf-8');
+                const _cftmp = agent.configFile + '.tmp';
+                writeFileSync(_cftmp, content, 'utf-8');
+                renameSync(_cftmp, agent.configFile);
             }
         }
         return {
@@ -1538,8 +1547,25 @@ export const hooksTransfer = {
         const sourcePath = params.sourcePath;
         const minConfidence = params.minConfidence || 0.7;
         const filter = params.filter;
+        // Validate sourcePath is an existing directory before reading from it
+        const resolvedSource = resolve(sourcePath);
+        const { statSync } = await import('fs');
+        const { homedir } = await import('os');
+        const home = homedir();
+        if (resolvedSource !== home && !resolvedSource.startsWith(home + sep)) {
+            return { error: 'sourcePath must be within the home directory.' };
+        }
+        try {
+            const st = statSync(resolvedSource);
+            if (!st.isDirectory()) {
+                return { error: 'sourcePath must be a directory' };
+            }
+        }
+        catch {
+            return { error: 'sourcePath does not exist' };
+        }
         // Try to load patterns from source project's memory store
-        const sourceMemoryPath = join(resolve(sourcePath), MEMORY_DIR, MEMORY_FILE);
+        const sourceMemoryPath = join(resolvedSource, MEMORY_DIR, MEMORY_FILE);
         let sourceStore = { entries: {}, version: '3.0.0' };
         try {
             if (existsSync(sourceMemoryPath)) {
@@ -2051,6 +2077,13 @@ export const hooksTrajectoryStart = {
             steps: [],
             startedAt,
         };
+        const MAX_TRAJECTORIES = 10000;
+        if (activeTrajectories.size >= MAX_TRAJECTORIES) {
+            // Evict the oldest trajectory
+            const oldest = activeTrajectories.keys().next().value;
+            if (oldest)
+                activeTrajectories.delete(oldest);
+        }
         activeTrajectories.set(trajectoryId, trajectory);
         return {
             trajectoryId,

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

@@ -34,5 +34,6 @@ export { ruvllmWasmTools } from './ruvllm-tools.js';
 export { guidanceTools } from './guidance-tools.js';
 export { autopilotTools } from './autopilot-tools.js';
 export { graphifyTools } from './graphify-tools.js';
+export { monographTools } from './monograph-tools.js';
 export { a2aTools } from './a2a-tools.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -35,6 +35,7 @@ export { ruvllmWasmTools } from './ruvllm-tools.js';
 export { guidanceTools } from './guidance-tools.js';
 export { autopilotTools } from './autopilot-tools.js';
 export { graphifyTools } from './graphify-tools.js';
+export { monographTools } from './monograph-tools.js';
 // A2A Agent Card protocol (source: https://a2a-protocol.org)
 export { a2aTools } from './a2a-tools.js';
 //# sourceMappingURL=index.js.map