monomind 1.19.0 → 2.0.1

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

@@ -406,6 +406,47 @@ export const hooksRoute = {
         };
     },
 };
+export const hooksRouteSemantic = {
+    name: 'hooks_route_semantic',
+    description: 'Route a task using the @monomind/routing package: keyword pre-filter, then real-embedding ' +
+        'cosine-similarity matching (isolated worker), with a headless Claude (Haiku) fallback below ' +
+        'the confidence threshold. Slower and more precise than hooks_route — use for ambiguous or ' +
+        'highly specialized tasks (e.g. Solidity, game engines, embedded, DevOps) where keyword matching ' +
+        'is likely to under-specify the agent.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string', description: 'Task description' },
+            debug: { type: 'boolean', description: 'Include all route scores in the response (default: false)' },
+        },
+        required: ['task'],
+    },
+    handler: async (params) => {
+        const MAX_ROUTE_TASK_LEN = 2000; // matches route-layer-factory's MAX_TASK_LENGTH
+        const rawTask = params.task;
+        const task = typeof rawTask === 'string' && rawTask.length > MAX_ROUTE_TASK_LEN
+            ? rawTask.slice(0, MAX_ROUTE_TASK_LEN)
+            : rawTask;
+        const debug = params.debug === true;
+        if (!task || typeof task !== 'string') {
+            throw new Error('task is required');
+        }
+        const { createConfiguredRouteLayer } = await import('../routing/route-layer-factory.js');
+        const layer = await createConfiguredRouteLayer({ debug });
+        const result = await layer.route(task);
+        const routeId = randomUUID();
+        await recordRoute(getRouteOutcomesBaseDir(), {
+            routeId,
+            ts: Date.now(),
+            task,
+            recommendedAgent: result.agentSlug,
+            routingMethod: `routing-pkg:${result.method}`,
+            confidence: result.confidence,
+            learningMode: 'js',
+        }).catch(() => { });
+        return { routeId, task, ...result };
+    },
+};
 export const hooksMetrics = {
     name: 'hooks_metrics',
     description: 'View learning metrics dashboard',
@@ -586,6 +627,11 @@ export const hooksPreTask = {
             }
         }
         catch { /* non-critical */ }
+        // NOTE: a LATS planning pass used to be attempted here via
+        // `import('@monomind/hooks').buildLATSPlan` — that function never existed
+        // in the package (the planning module was removed), so the import failed
+        // silently on every call. The dead block was removed.
+        let plan;
         return {
             taskId,
             description,
@@ -605,6 +651,7 @@ export const hooksPreTask = {
                 ...erlHints,
             ],
             modelRouting,
+            plan,
             timestamp: new Date().toISOString(),
         };
     },
@@ -1206,42 +1253,20 @@ export const hooksTransfer = {
         };
     },
 };
-// Session start hook - auto-starts daemon
+// Session start hook
 export const hooksSessionStart = {
     name: 'hooks_session-start',
-    description: 'Initialize a new session and auto-start daemon',
+    description: 'Initialize a new session',
     inputSchema: {
         type: 'object',
         properties: {
             sessionId: { type: 'string', description: 'Optional session ID' },
             restoreLatest: { type: 'boolean', description: 'Restore latest session state' },
-            startDaemon: { type: 'boolean', description: 'Start worker daemon (default: false — opt-in to prevent unintended token usage)' },
         },
     },
     handler: async (params) => {
         const sessionId = params.sessionId || `session-${Date.now()}`;
         const restoreLatest = params.restoreLatest;
-        const shouldStartDaemon = params.startDaemon === true;
-        // Auto-start daemon if enabled
-        let daemonStatus = { started: false };
-        if (shouldStartDaemon) {
-            try {
-                // Dynamic import to avoid circular dependencies
-                const { startDaemon } = await import('../services/worker-daemon.js');
-                const daemon = await startDaemon(getProjectCwd());
-                const status = daemon.getStatus();
-                daemonStatus = {
-                    started: true,
-                    pid: status.pid,
-                };
-            }
-            catch (error) {
-                daemonStatus = {
-                    started: false,
-                    error: error instanceof Error ? error.message : String(error),
-                };
-            }
-        }
         // Phase 5: Wire ReflexionMemory session start via bridge
         let sessionMemory = null;
         try {
@@ -1268,9 +1293,7 @@ export const hooksSessionStart = {
                 intelligenceEnabled: true,
                 hooksEnabled: true,
                 memoryPersistence: true,
-                daemonEnabled: shouldStartDaemon,
             },
-            daemon: daemonStatus,
             sessionMemory: sessionMemory || { controller: 'none', restoredPatterns: 0 },
             previousSession: restoreLatest ? {
                 id: `session-${Date.now() - 86400000}`,
@@ -1280,38 +1303,24 @@ export const hooksSessionStart = {
         };
     },
 };
-// Session end hook - stops daemon
+// Session end hook - persists state
 export const hooksSessionEnd = {
     name: 'hooks_session-end',
-    description: 'End current session, stop daemon, and persist state',
+    description: 'End current session and persist state',
     inputSchema: {
         type: 'object',
         properties: {
             saveState: { type: 'boolean', description: 'Save session state' },
             exportMetrics: { type: 'boolean', description: 'Export session metrics' },
-            stopDaemon: { type: 'boolean', description: 'Stop worker daemon (default: true)' },
         },
     },
     handler: async (params) => {
         const saveState = params.saveState !== false;
-        const shouldStopDaemon = params.stopDaemon !== false;
         // Use caller-supplied sessionId if provided, otherwise generate a current-time ID.
         // The -3600000 offset was incorrect — it prevented matching session-start IDs.
         const sessionId = typeof params.sessionId === 'string' && params.sessionId
             ? params.sessionId
             : `session-${Date.now()}`;
-        // Stop daemon if enabled
-        let daemonStopped = false;
-        if (shouldStopDaemon) {
-            try {
-                const { stopDaemon } = await import('../services/worker-daemon.js');
-                await stopDaemon();
-                daemonStopped = true;
-            }
-            catch {
-                // Daemon may not be running
-            }
-        }
         // Read actual counts from stores
         const store = loadMemoryStore();
         const allEntries = Object.values(store.entries);
@@ -1353,7 +1362,6 @@ export const hooksSessionEnd = {
         return {
             sessionId,
             statePath: saveState ? `.claude/sessions/${sessionId}.json` : undefined,
-            daemon: { stopped: daemonStopped },
             sessionPersistence: sessionPersistence || { controller: 'none', persisted: false },
             summary: {
                 tasksExecuted: taskCount,

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

@@ -0,0 +1,31 @@
+/**
+ * Hooks Dynamic Agent Synthesis MCP Tools
+ *
+ * Wires the previously-orphaned @monomind/hooks synthesis subsystem
+ * (EphemeralRegistry, TTLCleanup, AgentPromoter, DGMArchive,
+ * SynthesisPromptTemplate — "Task 47") into the CLI's live MCP tool
+ * registry.
+ *
+ * Architecture: @monomind/hooks has no LLM client of its own, so the actual
+ * agent-definition generation is delegated to the calling agent (e.g. Claude
+ * Code via the Task tool), which already has reasoning + generation
+ * capability. The flow is:
+ *   1. hooks_synthesis_prompt   — caller gets a structured prompt describing
+ *      the task that had no good routing match.
+ *   2. Caller (LLM) generates an AgentDefinition JSON object from the prompt.
+ *   3. hooks_synthesis_register — validates the definition (zod schema),
+ *      writes it to disk as a markdown agent file, and registers it in the
+ *      ephemeral registry with a TTL.
+ *   4. hooks_synthesis_status   — introspect the registry / DGM archive.
+ *   5. hooks_synthesis_promote  — promote a well-performing ephemeral agent
+ *      to the permanent registry (copies file + records in DGM archive).
+ *   6. hooks_synthesis_cleanup  — delete expired, non-promoted agents.
+ */
+import { type MCPTool } from './types.js';
+export declare const hooksSynthesisPrompt: MCPTool;
+export declare const hooksSynthesisRegister: MCPTool;
+export declare const hooksSynthesisStatus: MCPTool;
+export declare const hooksSynthesisPromote: MCPTool;
+export declare const hooksSynthesisCleanup: MCPTool;
+export declare const hooksSynthesisTools: MCPTool[];
+//# sourceMappingURL=hooks-synthesis.d.ts.map

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

@@ -0,0 +1,196 @@
+/**
+ * Hooks Dynamic Agent Synthesis MCP Tools
+ *
+ * Wires the previously-orphaned @monomind/hooks synthesis subsystem
+ * (EphemeralRegistry, TTLCleanup, AgentPromoter, DGMArchive,
+ * SynthesisPromptTemplate — "Task 47") into the CLI's live MCP tool
+ * registry.
+ *
+ * Architecture: @monomind/hooks has no LLM client of its own, so the actual
+ * agent-definition generation is delegated to the calling agent (e.g. Claude
+ * Code via the Task tool), which already has reasoning + generation
+ * capability. The flow is:
+ *   1. hooks_synthesis_prompt   — caller gets a structured prompt describing
+ *      the task that had no good routing match.
+ *   2. Caller (LLM) generates an AgentDefinition JSON object from the prompt.
+ *   3. hooks_synthesis_register — validates the definition (zod schema),
+ *      writes it to disk as a markdown agent file, and registers it in the
+ *      ephemeral registry with a TTL.
+ *   4. hooks_synthesis_status   — introspect the registry / DGM archive.
+ *   5. hooks_synthesis_promote  — promote a well-performing ephemeral agent
+ *      to the permanent registry (copies file + records in DGM archive).
+ *   6. hooks_synthesis_cleanup  — delete expired, non-promoted agents.
+ */
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { mkdirSync, writeFileSync, existsSync } from 'node:fs';
+import { getProjectCwd } from './types.js';
+import { agentDefinitionSchema, SynthesisPromptTemplate, EphemeralRegistry, TTLCleanup, AgentPromoter, DGMArchive, } from '@monomind/hooks';
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000; // 24h
+function getEphemeralAgentDir() {
+    return join(getProjectCwd(), '.claude', 'agents', 'ephemeral');
+}
+export const hooksSynthesisPrompt = {
+    name: 'hooks_synthesis-prompt',
+    description: 'Build an LLM prompt requesting a new synthesized agent definition, for use when hooks_route finds no confident match. ' +
+        'The caller generates the AgentDefinition JSON from the returned prompt, then submits it via hooks_synthesis-register.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            taskDescription: { type: 'string', description: 'The task that had no confident agent match' },
+            topMatchSlug: { type: 'string', description: 'Slug of the closest existing agent match' },
+            topMatchScore: { type: 'number', description: 'Confidence score of the closest match (0-1)' },
+            existingAgentCount: { type: 'number', description: 'Number of existing agents considered' },
+            existingSlugs: { type: 'array', items: { type: 'string' }, description: 'Slugs of existing agents to avoid colliding with' },
+        },
+        required: ['taskDescription'],
+    },
+    handler: async (params) => {
+        const taskDescription = params.taskDescription;
+        const topMatchSlug = params.topMatchSlug ?? 'none';
+        const topMatchScore = typeof params.topMatchScore === 'number' ? params.topMatchScore : 0;
+        const existingAgentCount = typeof params.existingAgentCount === 'number' ? params.existingAgentCount : 0;
+        const existingSlugs = Array.isArray(params.existingSlugs) ? params.existingSlugs : [];
+        const requestId = randomUUID();
+        const prompt = SynthesisPromptTemplate.build({
+            requestId,
+            taskDescription,
+            topMatchSlug,
+            topMatchScore,
+            existingAgentCount,
+            requestedAt: new Date(),
+        }, existingSlugs);
+        return { requestId, prompt };
+    },
+};
+export const hooksSynthesisRegister = {
+    name: 'hooks_synthesis-register',
+    description: 'Validate and register a synthesized agent definition (from hooks_synthesis-prompt). ' +
+        'Writes the agent as a markdown file and registers it in the ephemeral registry with a TTL.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            agentDefinition: { type: 'object', description: 'AgentDefinition JSON produced from the synthesis prompt' },
+            synthesisRequestId: { type: 'string', description: 'requestId returned by hooks_synthesis-prompt' },
+            ttlMs: { type: 'number', description: 'Time-to-live in ms before the agent expires (default: 24h)' },
+        },
+        required: ['agentDefinition', 'synthesisRequestId'],
+    },
+    handler: async (params) => {
+        const raw = params.agentDefinition;
+        const synthesisRequestId = params.synthesisRequestId;
+        const ttlMs = typeof params.ttlMs === 'number' && params.ttlMs > 0 ? params.ttlMs : DEFAULT_TTL_MS;
+        const parsed = agentDefinitionSchema.safeParse({
+            ...raw,
+            synthesizedAt: raw.synthesizedAt ?? new Date().toISOString(),
+        });
+        if (!parsed.success) {
+            return { registered: false, error: parsed.error.issues.map(i => `${i.path.join('.')}: ${i.message}`).join('; ') };
+        }
+        const def = parsed.data;
+        const registry = EphemeralRegistry.getInstance();
+        if (registry.isRegistered(def.slug)) {
+            return { registered: false, error: `slug "${def.slug}" is already registered` };
+        }
+        const agentDir = getEphemeralAgentDir();
+        if (!existsSync(agentDir))
+            mkdirSync(agentDir, { recursive: true });
+        const filePath = join(agentDir, `${def.slug}.md`);
+        writeFileSync(filePath, SynthesisPromptTemplate.toAgentMarkdown(def), 'utf-8');
+        const now = new Date();
+        registry.register({
+            slug: def.slug,
+            filePath,
+            createdAt: now,
+            expiresAt: new Date(now.getTime() + ttlMs),
+            usageCount: 0,
+            avgQualityScore: 0,
+            promoted: false,
+            synthesisRequestId,
+        });
+        return { registered: true, slug: def.slug, filePath, expiresAt: new Date(now.getTime() + ttlMs).toISOString() };
+    },
+};
+export const hooksSynthesisStatus = {
+    name: 'hooks_synthesis-status',
+    description: 'Introspect the ephemeral agent registry and DGM MAP-Elites archive: registered agents, usage/quality, and promotion candidates.',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => {
+        const registry = EphemeralRegistry.getInstance();
+        const all = [...registry.getAll().values()];
+        const candidates = registry.getPromotionCandidates();
+        const archive = DGMArchive.getInstance();
+        return {
+            registrySize: registry.size,
+            agents: all.map(r => ({
+                slug: r.slug,
+                usageCount: r.usageCount,
+                avgQualityScore: r.avgQualityScore,
+                promoted: r.promoted,
+                expiresAt: r.expiresAt.toISOString(),
+            })),
+            promotionCandidates: candidates.map(c => c.slug),
+            dgmArchive: {
+                size: archive.size,
+                best: archive.best() ?? null,
+                niches: archive.listAll(),
+            },
+        };
+    },
+};
+export const hooksSynthesisPromote = {
+    name: 'hooks_synthesis-promote',
+    description: 'Promote an eligible ephemeral agent (min usage + quality threshold) to the permanent agent directory and DGM archive.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            slug: { type: 'string', description: 'Slug of the ephemeral agent to promote' },
+            targetDir: { type: 'string', description: 'Permanent agent directory (default: .claude/agents)' },
+        },
+        required: ['slug'],
+    },
+    handler: async (params) => {
+        const slug = params.slug;
+        const targetDir = params.targetDir || join(getProjectCwd(), '.claude', 'agents');
+        const registry = EphemeralRegistry.getInstance();
+        const record = registry.get(slug);
+        if (!record)
+            return { promoted: false, error: `slug "${slug}" not found in registry` };
+        if (!AgentPromoter.isEligible(record)) {
+            return {
+                promoted: false,
+                error: `slug "${slug}" is not eligible (needs usageCount>=${AgentPromoter.MIN_USAGE_COUNT}, avgQualityScore>=${AgentPromoter.PROMOTION_THRESHOLD})`,
+                usageCount: record.usageCount,
+                avgQualityScore: record.avgQualityScore,
+            };
+        }
+        const destPath = await AgentPromoter.promote(record, targetDir);
+        registry.markPromoted(slug);
+        return { promoted: true, slug, destPath };
+    },
+};
+export const hooksSynthesisCleanup = {
+    name: 'hooks_synthesis-cleanup',
+    description: 'Delete expired, non-promoted ephemeral agents from the registry and disk (TTL cleanup).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            agentDir: { type: 'string', description: 'Ephemeral agent directory (default: .claude/agents/ephemeral)' },
+        },
+    },
+    handler: async (params) => {
+        const agentDir = params.agentDir || getEphemeralAgentDir();
+        const registry = EphemeralRegistry.getInstance();
+        const cleanup = new TTLCleanup(agentDir);
+        const result = await cleanup.runCleanup(registry);
+        return result;
+    },
+};
+export const hooksSynthesisTools = [
+    hooksSynthesisPrompt,
+    hooksSynthesisRegister,
+    hooksSynthesisStatus,
+    hooksSynthesisPromote,
+    hooksSynthesisCleanup,
+];
+//# sourceMappingURL=hooks-synthesis.js.map

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

@@ -3,8 +3,8 @@
  * 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, hooksMetrics, hooksList, hooksPreTask, hooksPostTask, hooksExplain, hooksPretrain, hooksBuildAgents, hooksTransfer, hooksSessionStart, hooksSessionEnd, hooksIntelligence, } from './hooks-routing.js';
-import { hooksIntelligenceReset, hooksTrajectoryStart, hooksTrajectoryStep, hooksTrajectoryEnd, hooksPatternStore, hooksPatternSearch, hooksIntelligenceStats, hooksIntelligenceLearn, hooksIntelligenceAttention, hooksWorkerList, hooksWorkerDispatch, hooksWorkerStatus, hooksWorkerDetect, hooksWorkerCancel, hooksModelRoute, hooksModelOutcome, hooksModelStats, } from './hooks-intelligence.js';
+import { hooksPreEdit, hooksPostEdit, hooksPreCommand, hooksPostCommand, hooksRoute, hooksRouteSemantic, hooksMetrics, hooksList, hooksPreTask, hooksPostTask, hooksExplain, hooksPretrain, hooksBuildAgents, hooksTransfer, hooksSessionStart, 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 = [
     hooksPreEdit,
@@ -12,6 +12,7 @@ export const hooksTools = [
     hooksPreCommand,
     hooksPostCommand,
     hooksRoute,
+    hooksRouteSemantic,
     hooksMetrics,
     hooksList,
     hooksPreTask,
@@ -33,16 +34,17 @@ export const hooksTools = [
     hooksIntelligenceStats,
     hooksIntelligenceLearn,
     hooksIntelligenceAttention,
-    // Worker tools
-    hooksWorkerList,
-    hooksWorkerDispatch,
-    hooksWorkerStatus,
-    hooksWorkerDetect,
-    hooksWorkerCancel,
     // Model routing tools
     hooksModelRoute,
     hooksModelOutcome,
     hooksModelStats,
+    // NOTE: the "advanced" tools formerly re-exported from @monomind/hooks/mcp
+    // (hooks/route-advanced, hooks/evo-agentx, hooks/rlvr-outcome, hooks/statusline,
+    // trace + HIL checkpoint tools) and the hooks_synthesis-* tools were removed.
+    // Their backing modules (AFLOW/LATS/GEPA/ReasoningBank) had already been
+    // deleted, the handlers silently degraded to hardcoded data, and none of the
+    // tools were ever invoked (no trace/checkpoint/ephemeral-agent artifacts ever
+    // appeared on disk).
 ];
 export default hooksTools;
 //# sourceMappingURL=hooks-tools.js.map

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

@@ -16,7 +16,6 @@ export { hooksTools } from './hooks-tools.js';
 export { taskTools } from './task-tools.js';
 export { sessionTools } from './session-tools.js';
 export { hiveMindTools } from './hive-mind-tools.js';
-export { workflowTools } from './workflow-tools.js';
 export { analyzeTools } from './analyze-tools.js';
 export { transferTools } from './transfer-tools.js';
 export { securityTools } from './security-tools.js';

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

@@ -16,7 +16,6 @@ export { hooksTools } from './hooks-tools.js';
 export { taskTools } from './task-tools.js';
 export { sessionTools } from './session-tools.js';
 export { hiveMindTools } from './hive-mind-tools.js';
-export { workflowTools } from './workflow-tools.js';
 export { analyzeTools } from './analyze-tools.js';
 export { transferTools } from './transfer-tools.js';
 export { securityTools } from './security-tools.js';

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

@@ -122,18 +122,17 @@ export const memoryPatternStore = {
             const pattern = validateString(params.pattern, 'pattern');
             if (!pattern)
                 return { success: false, error: 'pattern is required (non-empty string, max 100KB)' };
-            // validateExternalContent: guard against prompt injection in stored patterns
-            try {
-                const secMod = await import('@monomind/security').catch(() => null);
-                const validateExternalContent = secMod?.validateExternalContent;
-                if (validateExternalContent) {
-                    const check = await validateExternalContent(pattern, 'memory_pattern-store pattern');
-                    if (!check.safe) {
-                        return { success: false, error: `Injection guard: ${check.reason}`, injectionDetected: true };
-                    }
+            // validateExternalContent: guard against prompt injection in stored patterns.
+            // This is a WRITE to persistent memory, so it fails CLOSED: if
+            // validation throws, the write is blocked rather than silently
+            // persisted unvalidated.
+            {
+                const { validateExternalContent } = await import('../utils/input-guards.js');
+                const check = await validateExternalContent(pattern, 'memory_pattern-store pattern');
+                if (!check.safe) {
+                    return { success: false, error: `Injection guard: ${check.reason}`, injectionDetected: true };
                 }
             }
-            catch { /* security module optional */ }
             const bridge = await getBridge();
             const result = await bridge.bridgeStorePattern({
                 pattern,
@@ -165,18 +164,14 @@ export const memoryPatternSearch = {
             const query = validateString(params.query, 'query', 10_000);
             if (!query)
                 return { results: [], error: 'query is required (non-empty string, max 10KB)' };
-            // validateExternalContent: guard against prompt injection in search queries
-            try {
-                const secMod = await import('@monomind/security').catch(() => null);
-                const validateExternalContent = secMod?.validateExternalContent;
-                if (validateExternalContent) {
-                    const check = await validateExternalContent(query, 'memory_pattern-search query');
-                    if (!check.safe) {
-                        return { results: [], error: `Injection guard: ${check.reason}`, injectionDetected: true };
-                    }
+            // validateExternalContent: guard against prompt injection in search queries.
+            {
+                const { validateExternalContent } = await import('../utils/input-guards.js');
+                const check = await validateExternalContent(query, 'memory_pattern-search query');
+                if (!check.safe) {
+                    return { results: [], error: `Injection guard: ${check.reason}`, injectionDetected: true };
                 }
             }
-            catch { /* security module optional */ }
             const bridge = await getBridge();
             const minConfidence = validateScore(params.minConfidence, 0.3);
             const result = await bridge.bridgeSearchPatterns({
@@ -554,17 +549,13 @@ export const memoryContextSynthesize = {
                 return { success: false, error: 'query is required (non-empty string, max 10KB)' };
             // validateExternalContent: guard against prompt injection in synthesized context
             // Source: https://arxiv.org/abs/2302.12173, https://arxiv.org/abs/2310.12815
-            try {
-                const secMod = await import('@monomind/security').catch(() => null);
-                const validateExternalContent = secMod?.validateExternalContent;
-                if (validateExternalContent) {
-                    const check = await validateExternalContent(query, 'memory_context-synthesize query');
-                    if (!check.safe) {
-                        return { success: false, error: `Injection guard: ${check.reason}`, injectionDetected: true };
-                    }
+            {
+                const { validateExternalContent } = await import('../utils/input-guards.js');
+                const check = await validateExternalContent(query, 'memory_context-synthesize query');
+                if (!check.safe) {
+                    return { success: false, error: `Injection guard: ${check.reason}`, injectionDetected: true };
                 }
             }
-            catch { /* security module optional */ }
             const bridge = await getBridge();
             const result = await bridge.bridgeContextSynthesize({
                 query,

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

@@ -5,5 +5,11 @@
  * All monograph_* tools are backed by @monoes/monograph package.
  */
 import type { MCPTool } from './types.js';
+/**
+ * Full tool list regardless of gating — used by the graphify compat shims,
+ * which must resolve targets (e.g. monograph_community) even when the
+ * advanced set is not exposed over MCP.
+ */
+export declare const allMonographTools: MCPTool[];
 export declare const monographTools: MCPTool[];
 //# sourceMappingURL=monograph-tools.d.ts.map