monomind 1.18.15 → 2.0.0

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',
@@ -440,19 +481,15 @@ export const hooksMetrics = {
             period,
             patterns: {
                 total: patternEntries.length,
-                successful: null,
-                failed: null,
-                avgConfidence: null,
+                _note: 'Success/failure breakdown not tracked yet — store outcomes via hooks_post-task to populate.',
             },
             agents: {
-                routingAccuracy: null,
                 totalRoutes: routingEntries.length,
-                topAgent: null,
+                _note: 'Routing accuracy not tracked yet — requires route-outcome correlation data.',
             },
             commands: {
                 totalExecuted: taskEntries.length,
-                successRate: null,
-                avgRiskScore: null,
+                _note: 'Success rate not tracked yet — requires command-outcomes.jsonl data.',
             },
             dataSource: 'memory-store',
             entriesFound: entries.length,
@@ -468,42 +505,46 @@ export const hooksList = {
         properties: {},
     },
     handler: async () => {
+        // Static registry — not live discovery from handler objects.
+        // Update this list when hooks are added or removed.
+        const hooks = [
+            // Core hooks
+            { name: 'pre-edit', type: 'PreToolUse', status: 'active' },
+            { name: 'post-edit', type: 'PostToolUse', status: 'active' },
+            { name: 'pre-command', type: 'PreToolUse', status: 'active' },
+            { name: 'post-command', type: 'PostToolUse', status: 'active' },
+            { name: 'pre-task', type: 'PreToolUse', status: 'active' },
+            { name: 'post-task', type: 'PostToolUse', status: 'active' },
+            // Routing hooks
+            { name: 'route', type: 'intelligence', status: 'active' },
+            { name: 'explain', type: 'intelligence', status: 'active' },
+            // Session hooks
+            { name: 'session-start', type: 'SessionStart', status: 'active' },
+            { name: 'session-end', type: 'SessionEnd', status: 'active' },
+            { name: 'session-restore', type: 'SessionStart', status: 'active' },
+            // Learning hooks
+            { name: 'pretrain', type: 'intelligence', status: 'active' },
+            { name: 'build-agents', type: 'intelligence', status: 'active' },
+            { name: 'transfer', type: 'intelligence', status: 'active' },
+            { name: 'metrics', type: 'analytics', status: 'active' },
+            // System hooks
+            { name: 'init', type: 'system', status: 'active' },
+            { name: 'notify', type: 'coordination', status: 'active' },
+            // Intelligence subcommands
+            { name: 'intelligence', type: 'intelligence', status: 'active' },
+            { name: 'intelligence_trajectory-start', type: 'intelligence', status: 'active' },
+            { name: 'intelligence_trajectory-step', type: 'intelligence', status: 'active' },
+            { name: 'intelligence_trajectory-end', type: 'intelligence', status: 'active' },
+            { name: 'intelligence_pattern-store', type: 'intelligence', status: 'active' },
+            { name: 'intelligence_pattern-search', type: 'intelligence', status: 'active' },
+            { name: 'intelligence_stats', type: 'analytics', status: 'active' },
+            { name: 'intelligence_learn', type: 'intelligence', status: 'active' },
+            { name: 'intelligence_attention', type: 'intelligence', status: 'active' },
+        ];
         return {
-            hooks: [
-                // Core hooks
-                { name: 'pre-edit', type: 'PreToolUse', status: 'active' },
-                { name: 'post-edit', type: 'PostToolUse', status: 'active' },
-                { name: 'pre-command', type: 'PreToolUse', status: 'active' },
-                { name: 'post-command', type: 'PostToolUse', status: 'active' },
-                { name: 'pre-task', type: 'PreToolUse', status: 'active' },
-                { name: 'post-task', type: 'PostToolUse', status: 'active' },
-                // Routing hooks
-                { name: 'route', type: 'intelligence', status: 'active' },
-                { name: 'explain', type: 'intelligence', status: 'active' },
-                // Session hooks
-                { name: 'session-start', type: 'SessionStart', status: 'active' },
-                { name: 'session-end', type: 'SessionEnd', status: 'active' },
-                { name: 'session-restore', type: 'SessionStart', status: 'active' },
-                // Learning hooks
-                { name: 'pretrain', type: 'intelligence', status: 'active' },
-                { name: 'build-agents', type: 'intelligence', status: 'active' },
-                { name: 'transfer', type: 'intelligence', status: 'active' },
-                { name: 'metrics', type: 'analytics', status: 'active' },
-                // System hooks
-                { name: 'init', type: 'system', status: 'active' },
-                { name: 'notify', type: 'coordination', status: 'active' },
-                // Intelligence subcommands
-                { name: 'intelligence', type: 'intelligence', status: 'active' },
-                { name: 'intelligence_trajectory-start', type: 'intelligence', status: 'active' },
-                { name: 'intelligence_trajectory-step', type: 'intelligence', status: 'active' },
-                { name: 'intelligence_trajectory-end', type: 'intelligence', status: 'active' },
-                { name: 'intelligence_pattern-store', type: 'intelligence', status: 'active' },
-                { name: 'intelligence_pattern-search', type: 'intelligence', status: 'active' },
-                { name: 'intelligence_stats', type: 'analytics', status: 'active' },
-                { name: 'intelligence_learn', type: 'intelligence', status: 'active' },
-                { name: 'intelligence_attention', type: 'intelligence', status: 'active' },
-            ],
-            total: 26,
+            _note: 'Static registry — update this list when hooks are added or removed.',
+            hooks,
+            total: hooks.length,
         };
     },
 };
@@ -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(),
         };
     },
@@ -1019,7 +1066,7 @@ export const hooksPretrain = {
         if (patterns.length > 0) {
             try {
                 const intel = await import('../memory/intelligence.js');
-                await intel.initializeIntelligence({ loraLearningRate: 0.002, maxTrajectorySize: patterns.length });
+                await intel.initializeIntelligence({ confidenceLearningRate: 0.002, maxTrajectorySize: patterns.length });
                 // Record each extracted pattern as an action step
                 for (const pat of patterns.slice(0, 50)) {
                     await intel.recordStep({ type: 'action', content: pat, metadata: { source: 'pretrain', depth } });
@@ -1202,55 +1249,24 @@ export const hooksTransfer = {
                 total,
                 byType,
             },
-            skipped: {
-                lowConfidence: Math.floor(total * 0.15),
-                duplicates: Math.floor(total * 0.08),
-                conflicts: Math.floor(total * 0.03),
-            },
-            stats: {
-                avgConfidence: 0.82 + (minConfidence > 0.8 ? 0.1 : 0),
-                avgAge: '3 days',
-            },
             dataSource: 'source-project',
         };
     },
 };
-// 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 {
@@ -1277,50 +1293,34 @@ 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}`,
-                tasksRestored: sessionMemory?.restoredPatterns || 3,
-                memoryRestored: sessionMemory?.restoredPatterns || 15,
+                tasksRestored: sessionMemory?.restoredPatterns || 0,
+                memoryRestored: sessionMemory?.restoredPatterns || 0,
             } : null,
         };
     },
 };
-// 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);
@@ -1361,9 +1361,7 @@ export const hooksSessionEnd = {
         }
         return {
             sessionId,
-            duration: 3600000, // 1 hour in ms
             statePath: saveState ? `.claude/sessions/${sessionId}.json` : undefined,
-            daemon: { stopped: daemonStopped },
             sessionPersistence: sessionPersistence || { controller: 'none', persisted: false },
             summary: {
                 tasksExecuted: taskCount,
@@ -1379,110 +1377,6 @@ export const hooksSessionEnd = {
         };
     },
 };
-// Session restore hook
-export const hooksSessionRestore = {
-    name: 'hooks_session-restore',
-    description: 'Restore a previous session',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            sessionId: { type: 'string', description: 'Session ID to restore (or "latest")' },
-            restoreAgents: { type: 'boolean', description: 'Restore spawned agents' },
-            restoreTasks: { type: 'boolean', description: 'Restore active tasks' },
-        },
-    },
-    handler: async (params) => {
-        const requestedId = params.sessionId || 'latest';
-        const restoreAgents = params.restoreAgents !== false;
-        const restoreTasks = params.restoreTasks !== false;
-        const originalSessionId = requestedId === 'latest' ? `session-${Date.now() - 86400000}` : requestedId;
-        const newSessionId = `session-${Date.now()}`;
-        // Get real memory entry count
-        const store = loadMemoryStore();
-        const memoryEntryCount = Object.keys(store.entries).length;
-        // Count task and agent entries
-        const taskEntries = Object.keys(store.entries).filter(k => k.includes('task')).length;
-        const agentEntries = Object.keys(store.entries).filter(k => k.includes('agent')).length;
-        return {
-            sessionId: newSessionId,
-            originalSessionId,
-            restoredState: {
-                tasksRestored: restoreTasks ? Math.min(taskEntries, 10) : 0,
-                agentsRestored: restoreAgents ? Math.min(agentEntries, 5) : 0,
-                memoryRestored: memoryEntryCount,
-            },
-            warnings: restoreTasks && taskEntries > 0 ? [`${Math.min(taskEntries, 2)} tasks were in progress and may need review`] : undefined,
-            dataSource: 'memory-store',
-        };
-    },
-};
-// Notify hook - cross-agent notifications
-export const hooksNotify = {
-    name: 'hooks_notify',
-    description: 'Send cross-agent notification',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            message: { type: 'string', description: 'Notification message' },
-            target: { type: 'string', description: 'Target agent or "all"' },
-            priority: { type: 'string', description: 'Priority level (low, normal, high, urgent)' },
-            data: { type: 'object', description: 'Additional data payload' },
-        },
-        required: ['message'],
-    },
-    handler: async (params) => {
-        const message = params.message;
-        const target = params.target || 'all';
-        const priority = params.priority || 'normal';
-        return {
-            notificationId: `notify-${Date.now()}`,
-            message,
-            target,
-            priority,
-            delivered: true,
-            recipients: target === 'all' ? ['coder', 'architect', 'tester', 'reviewer'] : [target],
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
-// Init hook - initialize hooks in project
-export const hooksInit = {
-    name: 'hooks_init',
-    description: 'Initialize hooks in project with .claude/settings.json',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            path: { type: 'string', description: 'Project path' },
-            template: { type: 'string', description: 'Template to use (minimal, standard, full)' },
-            force: { type: 'boolean', description: 'Overwrite existing configuration' },
-        },
-    },
-    handler: async (params) => {
-        const path = params.path || '.';
-        const template = params.template || 'standard';
-        const force = params.force;
-        const hooksConfigured = template === 'minimal' ? 4 : template === 'full' ? 16 : 9;
-        return {
-            path,
-            template,
-            created: {
-                settingsJson: `${path}/.claude/settings.json`,
-                hooksDir: `${path}/.claude/hooks`,
-            },
-            hooks: {
-                configured: hooksConfigured,
-                types: ['PreToolUse', 'PostToolUse', 'SessionStart', 'SessionEnd'],
-            },
-            intelligence: {
-                enabled: template !== 'minimal',
-                sona: template === 'full',
-                moe: template === 'full',
-                hnsw: template !== 'minimal',
-            },
-            overwritten: force,
-        };
-    },
-};
 // Intelligence hook - JS pattern/trajectory logging
 export const hooksIntelligence = {
     name: 'hooks_intelligence',

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