@monoes/monomindcli 1.18.15 → 2.0.0

package/dist/src/mcp-tools/monograph-tools.js

@@ -7,8 +7,10 @@
 import { join, resolve, sep } from 'path';
 import { execSync } from 'child_process';
 import { statSync } from 'fs';
+import { randomUUID } from 'crypto';
 import { getProjectCwd } from './types.js';
 let _cachedDbPath;
+let _cachedCwd;
 function _isValidDb(p) {
     try {
         return statSync(p).size >= 100;
@@ -18,15 +20,19 @@ function _isValidDb(p) {
     }
 }
 function getDbPath() {
-    if (_cachedDbPath !== undefined)
-        return _cachedDbPath ?? join(getProjectCwd(), '.monomind', 'monograph.db');
-    const direct = join(getProjectCwd(), '.monomind', 'monograph.db');
+    const cwd = getProjectCwd();
+    // Invalidate cache when project root changes (e.g. MONOMIND_CWD set after initialize)
+    if (_cachedDbPath && _cachedCwd === cwd)
+        return _cachedDbPath;
+    _cachedCwd = cwd;
+    _cachedDbPath = undefined;
+    const direct = join(cwd, '.monomind', 'monograph.db');
     if (_isValidDb(direct)) {
         _cachedDbPath = direct;
         return direct;
     }
     try {
-        const root = execSync('git rev-parse --show-toplevel', { cwd: getProjectCwd(), encoding: 'utf8' }).trim();
+        const root = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf8' }).trim();
         const candidate = join(root, '.monomind', 'monograph.db');
         if (_isValidDb(candidate)) {
             _cachedDbPath = candidate;
@@ -34,12 +40,60 @@ function getDbPath() {
         }
     }
     catch { /* not in a git repo */ }
-    _cachedDbPath = null;
+    // Don't cache failures — the DB may be created by a subsequent build
     return direct;
 }
 function text(t) {
     return { content: [{ type: 'text', text: t }] };
 }
+function ensureDbExists() {
+    const p = getDbPath();
+    if (!_isValidDb(p)) {
+        throw new Error(`Monograph index not built yet. Run monograph_build first (path: ${p}).`);
+    }
+    return p;
+}
+// ── Active watcher registry ──────────────────────────────────────────────────
+const _activeWatchers = new Map();
+function applyPprRerank(db, seedNodes, damping, maxResults) {
+    const propagated = new Map();
+    for (const r of seedNodes) {
+        propagated.set(r.id, r.score);
+    }
+    const neighborStmt = db.prepare('SELECT target_id FROM edges WHERE source_id = @id');
+    for (const r of seedNodes) {
+        const neighbors = neighborStmt.all({ id: r.id });
+        for (const n of neighbors) {
+            const boost = r.score * damping;
+            const current = propagated.get(n.target_id) ?? 0;
+            propagated.set(n.target_id, Math.max(current, boost));
+        }
+    }
+    const seedIds = new Set(seedNodes.map(r => r.id));
+    const ranked = seedNodes.map(r => ({
+        ...r,
+        combinedScore: Math.max(r.score, propagated.get(r.id) ?? 0),
+        boostedByNeighbors: false,
+    }));
+    for (const [id, score] of propagated) {
+        if (!seedIds.has(id)) {
+            const node = db.prepare('SELECT id, name, label, file_path, start_line FROM nodes WHERE id = @id').get({ id });
+            if (node) {
+                ranked.push({
+                    id: node.id, name: node.name, label: node.label,
+                    filePath: node.file_path, startLine: node.start_line,
+                    score: 0, combinedScore: score, boostedByNeighbors: true,
+                });
+            }
+        }
+    }
+    ranked.sort((a, b) => b.combinedScore - a.combinedScore);
+    return ranked.slice(0, maxResults).map(r => ({
+        id: r.id, name: r.name, label: r.label,
+        filePath: r.filePath, startLine: r.startLine,
+        score: r.combinedScore, boostedByNeighbors: r.boostedByNeighbors,
+    }));
+}
 // ── monograph_build ───────────────────────────────────────────────────────────
 const monographBuildTool = {
     name: 'monograph_build',
@@ -78,13 +132,18 @@ const monographQueryTool = {
             query: { type: 'string', description: 'Search terms' },
             limit: { type: 'number', description: 'Max results (default 20)' },
             label: { type: 'string', description: 'Filter by node type: Class, Function, Method, etc.' },
+            rerank: { type: 'boolean', description: 'Apply HippoRAG-style PPR graph reranking to boost neighbors of top hits (default: true)' },
+            damping: { type: 'number', description: 'PPR damping factor when rerank=true (0-1, default 0.5)' },
         },
         required: ['query'],
     },
     handler: async (input) => {
+        const dbPath = getDbPath();
+        if (!_isValidDb(dbPath))
+            return text('Monograph index not built yet. Run monograph_build first.');
         const { openDb, closeDb, ftsSearch } = await import('@monoes/monograph');
         const { hybridQuery } = await import('@monoes/monograph');
-        const db = openDb(getDbPath());
+        const db = openDb(dbPath);
         try {
             // Cap limit: passed directly to SQLite queries and hybridQuery; an
             // unlimited value saturates memory with rows.
@@ -101,19 +160,49 @@ const monographQueryTool = {
                 ? rawQuery.slice(0, MAX_MONOGRAPH_QUERY_LEN)
                 : rawQuery;
             const label = input.label;
+            const rerank = input.rerank ?? true;
+            const damping = input.damping ?? 0.5;
             if (process.env['MONOGRAPH_EMBEDDINGS'] === 'true') {
-                const results = await hybridQuery(db, query, { limit, label });
+                const results = await hybridQuery(db, query, { limit: rerank ? limit * 2 : limit, label });
                 if (results.length === 0)
                     return text('No results found.');
+                if (rerank) {
+                    const seeds = results.map(r => ({
+                        id: r.id, name: r.name ?? r.id, label: r.label ?? '?',
+                        filePath: r.filePath ?? '', startLine: r.startLine ?? null,
+                        score: r.score,
+                    }));
+                    const reranked = applyPprRerank(db, seeds, damping, limit);
+                    const lines = reranked.map(r => {
+                        const loc = r.filePath ? (r.startLine != null ? `${r.filePath}:${r.startLine}` : r.filePath) : '';
+                        const tag = r.boostedByNeighbors ? ' [PPR-boosted]' : '';
+                        return `[${r.label}] ${r.name}  ${loc}  (score: ${r.score.toFixed(4)})${tag}`;
+                    });
+                    return text(lines.join('\n'));
+                }
                 const lines = results.map(r => {
                     const loc = r.filePath ? (r.startLine != null ? `${r.filePath}:${r.startLine}` : r.filePath) : '';
                     return `[${r.label ?? '?'}] ${r.name ?? r.id}  ${loc}  (score: ${r.score.toFixed(4)})`;
                 });
                 return text(lines.join('\n'));
             }
-            const results = ftsSearch(db, query, limit, label);
+            const results = ftsSearch(db, query, rerank ? limit * 2 : limit, label);
             if (results.length === 0)
                 return text('No results found.');
+            if (rerank) {
+                const seeds = results.map(r => ({
+                    id: r.id, name: r.name, label: r.label,
+                    filePath: r.filePath ?? '', startLine: r.startLine ?? null,
+                    score: Math.abs(r.rank),
+                }));
+                const reranked = applyPprRerank(db, seeds, damping, limit);
+                const lines = reranked.map(r => {
+                    const loc = r.filePath ? (r.startLine != null ? `${r.filePath}:${r.startLine}` : r.filePath) : '';
+                    const tag = r.boostedByNeighbors ? ' [PPR-boosted]' : '';
+                    return `[${r.label}] ${r.name}  ${loc}  (score: ${r.score.toFixed(3)})${tag}`;
+                });
+                return text(lines.join('\n'));
+            }
             const lines = results.map(r => {
                 const loc = r.filePath ? (r.startLine != null ? `${r.filePath}:${r.startLine}` : r.filePath) : '';
                 return `[${r.label}] ${r.name}  ${loc}  (score: ${r.rank.toFixed(3)})`;
@@ -131,8 +220,11 @@ const monographStatsTool = {
     description: 'Show node/edge/community counts and index freshness.',
     inputSchema: { type: 'object', properties: {} },
     handler: async () => {
+        const dbPath = getDbPath();
+        if (!_isValidDb(dbPath))
+            return text('Monograph index not built yet. Run monograph_build first.');
         const { openDb, closeDb, countNodes, countEdges } = await import('@monoes/monograph');
-        const db = openDb(getDbPath());
+        const db = openDb(dbPath);
         try {
             const nodes = countNodes(db);
             const edges = countEdges(db);
@@ -201,8 +293,11 @@ const monographGodNodesTool = {
         properties: { limit: { type: 'number', description: 'Max nodes to return (default 20)' } },
     },
     handler: async (input) => {
+        const dbPath = getDbPath();
+        if (!_isValidDb(dbPath))
+            return text('Monograph index not built yet. Run monograph_build first.');
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const db = openDb(getDbPath());
+        const db = openDb(dbPath);
         try {
             // Cap limit: passed directly to the SQL LIMIT clause.
             const MAX_GOD_NODES_LIMIT = 1_000;
@@ -388,12 +483,27 @@ const monographSuggestTool = {
         properties: {
             task: { type: 'string', description: 'Optional task description for task-relevance scoring' },
             limit: { type: 'number', description: 'Max questions (default 10)' },
+            checkStaleness: { type: 'boolean', description: 'Check index staleness first and trigger a background rebuild when the index is behind HEAD. Appends a _staleness annotation to the result. (default false)' },
         },
     },
     handler: async (input) => {
+        // Health-aware mode (formerly monograph_suggest_auto): check staleness and
+        // trigger a background rebuild if the index is behind HEAD.
+        let stalenessAnnotation = '';
+        if (input.checkStaleness === true) {
+            const repoPath = getProjectCwd();
+            const stalenessResult = await computeCommitsBehind(repoPath);
+            const commitsBehind = stalenessResult?.commitsBehind ?? 0;
+            const triggered = triggerBackgroundBuildIfNeeded(repoPath, commitsBehind, STALENESS_THRESHOLD + 1);
+            const status = triggered ? 'building' : commitsBehind === 0 ? 'fresh' : 'stale';
+            stalenessAnnotation = `\n_staleness: ${JSON.stringify({ commitsBehind, status, triggered })}`;
+        }
+        const dbPath = getDbPath();
+        if (!_isValidDb(dbPath))
+            return text('Monograph index not built yet. Run monograph_build first.' + stalenessAnnotation);
         const { openDb, closeDb } = await import('@monoes/monograph');
         const { hybridQuery } = await import('@monoes/monograph');
-        const db = openDb(getDbPath());
+        const db = openDb(dbPath);
         try {
             // Cap limit and task: limit is passed directly to SQL LIMIT clause;
             // task is forwarded to hybridQuery (embedding path) or FTS.
@@ -421,7 +531,7 @@ const monographSuggestTool = {
                 const hits = await hybridQuery(db, task, { limit: 20 });
                 const hitIds = new Set(hits.map(h => h.id));
                 if (hitIds.size === 0) {
-                    return text('No suggestions for this task. Run monograph_build first or try a different query.');
+                    return text('No suggestions for this task. Run monograph_build first or try a different query.' + stalenessAnnotation);
                 }
                 const rows = db.prepare(`
           SELECT e.relation, e.confidence, n1.name as src, n2.name as tgt,
@@ -436,7 +546,7 @@ const monographSuggestTool = {
           LIMIT 100
         `).all(...[...hitIds], ...[...hitIds]);
                 const questions = rows.map(formatSuggestion);
-                return text(questions.slice(0, limit).join('\n') || 'No suggestions for this task. Run monograph_build first.');
+                return text((questions.slice(0, limit).join('\n') || 'No suggestions for this task. Run monograph_build first.') + stalenessAnnotation);
             }
             const rows = db.prepare(`
         SELECT e.relation, e.confidence, n1.name as src, n2.name as tgt,
@@ -454,7 +564,7 @@ const monographSuggestTool = {
             }));
             if (task)
                 scored = scored.sort((a, b) => b.relevance - a.relevance);
-            return text(scored.slice(0, limit).map(s => s.q).join('\n') || 'No suggestions. Run monograph_build first.');
+            return text((scored.slice(0, limit).map(s => s.q).join('\n') || 'No suggestions. Run monograph_build first.') + stalenessAnnotation);
         }
         finally {
             closeDb(db);
@@ -521,11 +631,15 @@ const monographWatchTool = {
     handler: async (input) => {
         const { MonographWatcher } = await import('@monoes/monograph');
         const repoPath = input.path ?? getProjectCwd();
+        if (_activeWatchers.has(repoPath)) {
+            return text(`Monograph watcher already running for ${repoPath}.`);
+        }
         const watcher = new MonographWatcher(repoPath);
         watcher.on('monograph:updated', (_paths) => {
             import('@monoes/monograph').then(({ buildAsync }) => buildAsync(repoPath)).catch(() => { });
         });
         await watcher.start();
+        _activeWatchers.set(repoPath, watcher);
         return text(`Monograph watcher started for ${repoPath}. Watching for file changes...`);
     },
 };
@@ -533,9 +647,21 @@ const monographWatchTool = {
 const monographWatchStopTool = {
     name: 'monograph_watch_stop',
     description: 'Stop the Monograph file watcher.',
-    inputSchema: { type: 'object', properties: {} },
-    handler: async () => {
-        return text('Watcher stop requested. (Restart MCP server to fully clear watchers.)');
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Repo path whose watcher to stop (defaults to project cwd)' },
+        },
+    },
+    handler: async (input) => {
+        const repoPath = input.path ?? getProjectCwd();
+        const watcher = _activeWatchers.get(repoPath);
+        if (!watcher) {
+            return text(`No active watcher found for ${repoPath}.`);
+        }
+        await watcher.stop();
+        _activeWatchers.delete(repoPath);
+        return text(`Monograph watcher stopped for ${repoPath}.`);
     },
 };
 // ── monograph_report ──────────────────────────────────────────────────────────
@@ -620,14 +746,14 @@ async function computeCommitsBehind(repoPath) {
     }
 }
 /**
- * Shared staleness threshold: both monograph_staleness and monograph_suggest_auto
+ * Shared staleness threshold: both monograph_staleness and monograph_suggest (checkStaleness)
  * trigger a background rebuild only when the index is more than this many commits behind HEAD.
  * Using a shared constant prevents conflicting rebuild pressure during active dev sessions.
  */
 const STALENESS_THRESHOLD = 10;
 /**
  * Fire-and-forget background rebuild. Uses a module-level guard so concurrent
- * MCP tool calls (e.g. repeated monograph_suggest_auto) don't pile up builds.
+ * MCP tool calls (e.g. repeated monograph_suggest checkStaleness) don't pile up builds.
  * threshold: minimum commitsBehind to trigger (default STALENESS_THRESHOLD + 1).
  */
 function triggerBackgroundBuildIfNeeded(repoPath, commitsBehind, threshold = STALENESS_THRESHOLD + 1) {
@@ -799,7 +925,7 @@ const monographExportTool = {
         required: ['format'],
     },
     handler: async (input) => {
-        const { openDb, closeDb, toJson, toSvg, toGraphml, toCypher } = await import('@monoes/monograph');
+        const { openDb, closeDb, toJson, toSvg, toGraphml, toCypher, toObsidian, toCanvas } = await import('@monoes/monograph');
         const { writeFileSync, mkdirSync } = await import('fs');
         const db = openDb(getDbPath());
         try {
@@ -833,6 +959,15 @@ const monographExportTool = {
                 writeFileSync(p, toCypher(nodes, edges));
                 return text(`Exported Cypher to ${p}`);
             }
+            if (fmt === 'obsidian') {
+                toObsidian(nodes, edges, outDir);
+                return text(`Exported Obsidian vault to ${outDir}`);
+            }
+            if (fmt === 'canvas') {
+                const p = join(outDir, 'graph.canvas');
+                writeFileSync(p, toCanvas(nodes, edges));
+                return text(`Exported Canvas to ${p}`);
+            }
             return text(`Format ${fmt} export written to ${outDir}`);
         }
         finally {
@@ -1180,21 +1315,6 @@ const monographApiImpactTool = {
         }
     },
 };
-// ── monograph_embed ───────────────────────────────────────────────────────────
-const monographEmbedTool = {
-    name: 'monograph_embed',
-    description: 'DEPRECATED — embeddings are disabled; monograph uses BM25 (FTS5) search. This tool is a no-op kept for backward compatibility.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            codeOnly: { type: 'boolean', description: 'Ignored (embeddings are disabled)' },
-            force: { type: 'boolean', description: 'Ignored (embeddings are disabled)' },
-        },
-    },
-    handler: async () => {
-        return text('Embeddings are disabled — monograph uses BM25 (FTS5) search; this tool is deprecated and does nothing. Use monograph_query instead.');
-    },
-};
 // ── monograph_cypher ──────────────────────────────────────────────────────────
 const monographCypherTool = {
     name: 'monograph_cypher',
@@ -1814,39 +1934,6 @@ const monographNeighborsTool = {
         }
     },
 };
-// ── monograph_suggest_auto ────────────────────────────────────────────────────
-const monographSuggestAutoTool = {
-    name: 'monograph_suggest_auto',
-    description: 'Like monograph_suggest but health-aware: checks staleness first and triggers a background rebuild when the index is behind HEAD before returning suggestions. Result includes a _staleness annotation.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            task: { type: 'string', description: 'Optional task description for task-relevance scoring' },
-            limit: { type: 'number', description: 'Max questions (default 10)' },
-        },
-    },
-    handler: async (input) => {
-        const repoPath = getProjectCwd();
-        // Check staleness and trigger rebuild if needed (threshold: STALENESS_THRESHOLD commits).
-        const stalenessResult = await computeCommitsBehind(repoPath);
-        const commitsBehind = stalenessResult?.commitsBehind ?? 0;
-        const triggered = triggerBackgroundBuildIfNeeded(repoPath, commitsBehind, STALENESS_THRESHOLD + 1);
-        const stalenessStatus = triggered ? 'building' : commitsBehind === 0 ? 'fresh' : 'stale';
-        // Delegate to the base suggest tool — no logic duplication.
-        const baseResult = await monographSuggestTool.handler(input);
-        // Append staleness annotation to the text content.
-        const stalenessAnnotation = `\n_staleness: ${JSON.stringify({ commitsBehind, status: stalenessStatus, triggered })}`;
-        if (baseResult && Array.isArray(baseResult.content)) {
-            const content = baseResult.content;
-            if (content.length > 0 && content[0].type === 'text') {
-                content[0].text += stalenessAnnotation;
-            }
-            return baseResult;
-        }
-        return baseResult;
-    },
-};
-// ── Export all tools ──────────────────────────────────────────────────────────
 // ── monograph_dead_code ──────────────────────────────────────────────────────
 const monographDeadCodeTool = {
     name: 'monograph_dead_code',
@@ -2048,51 +2135,239 @@ function findStaleDist(repoPath) {
         findings,
     };
 }
-export const monographTools = [
+// ── monograph_agent_history ───────────────────────────────────────────────────
+const monographAgentHistoryTool = {
+    name: 'monograph_agent_history',
+    description: 'Query past agent interactions by org, type, session, or time range. Returns rows ordered by timestamp descending.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            org_name: { type: 'string', description: 'Filter by org name' },
+            agent_type: { type: 'string', description: 'Filter by agent type' },
+            session_id: { type: 'string', description: 'Filter by session id' },
+            since: { type: 'number', description: 'Unix timestamp (ms) — only interactions after this time' },
+            limit: { type: 'number', description: 'Max rows to return (default 50)' },
+        },
+    },
+    handler: async (input) => {
+        const { openDb, closeDb } = await import('@monoes/monograph');
+        const db = openDb(getDbPath());
+        try {
+            const conditions = [];
+            const params = {};
+            if (typeof input.org_name === 'string') {
+                conditions.push('org_name = @org_name');
+                params.org_name = input.org_name;
+            }
+            if (typeof input.agent_type === 'string') {
+                conditions.push('agent_type = @agent_type');
+                params.agent_type = input.agent_type;
+            }
+            if (typeof input.session_id === 'string') {
+                conditions.push('session_id = @session_id');
+                params.session_id = input.session_id;
+            }
+            if (typeof input.since === 'number') {
+                conditions.push('timestamp >= @since');
+                params.since = input.since;
+            }
+            const MAX_LIMIT = 1_000;
+            const rawLimit = input.limit ?? 50;
+            const limit = Number.isFinite(rawLimit) && rawLimit > 0
+                ? Math.min(Math.floor(rawLimit), MAX_LIMIT)
+                : 50;
+            params.limit = limit;
+            const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+            const sql = `SELECT * FROM agent_interactions ${where} ORDER BY timestamp DESC LIMIT @limit`;
+            const rows = db.prepare(sql).all(params);
+            if (rows.length === 0)
+                return text('No agent interactions found.');
+            return text(JSON.stringify(rows, null, 2));
+        }
+        finally {
+            closeDb(db);
+        }
+    },
+};
+// ── monograph_agent_patterns ──────────────────────────────────────────────────
+const monographAgentPatternsTool = {
+    name: 'monograph_agent_patterns',
+    description: 'Aggregate agent interaction patterns: success rates, costs, and token usage grouped by agent type, org, or session.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            group_by: {
+                type: 'string',
+                description: "Column to group by: 'agent_type' | 'org_name' | 'session_id'",
+            },
+            since: { type: 'number', description: 'Unix timestamp (ms) — only interactions after this time' },
+            min_count: { type: 'number', description: 'Minimum interaction count to include in results (default 2)' },
+        },
+        required: ['group_by'],
+    },
+    handler: async (input) => {
+        const groupBy = input.group_by;
+        const ALLOWED_GROUP_COLUMNS = new Set(['agent_type', 'org_name', 'session_id']);
+        if (!ALLOWED_GROUP_COLUMNS.has(groupBy)) {
+            return text(`Invalid group_by: ${groupBy}. Must be one of: agent_type, org_name, session_id`);
+        }
+        const { openDb, closeDb } = await import('@monoes/monograph');
+        const db = openDb(getDbPath());
+        try {
+            const params = {};
+            const conditions = [];
+            if (typeof input.since === 'number') {
+                conditions.push('timestamp >= @since');
+                params.since = input.since;
+            }
+            const minCount = typeof input.min_count === 'number' && input.min_count > 0
+                ? Math.floor(input.min_count)
+                : 2;
+            params.min_count = minCount;
+            const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+            const sql = `
+        SELECT
+          ${groupBy} AS group_key,
+          COUNT(*) AS interaction_count,
+          AVG(success) AS success_rate,
+          SUM(tokens_in) AS total_tokens_in,
+          SUM(tokens_out) AS total_tokens_out,
+          SUM(cost_usd) AS total_cost_usd,
+          AVG(duration_ms) AS avg_duration_ms
+        FROM agent_interactions
+        ${where}
+        GROUP BY ${groupBy}
+        HAVING COUNT(*) >= @min_count
+        ORDER BY interaction_count DESC
+      `;
+            const rows = db.prepare(sql).all(params);
+            if (rows.length === 0)
+                return text('No agent interaction patterns found.');
+            return text(JSON.stringify(rows, null, 2));
+        }
+        finally {
+            closeDb(db);
+        }
+    },
+};
+// ── monograph_agent_record ────────────────────────────────────────────────────
+const monographAgentRecordTool = {
+    name: 'monograph_agent_record',
+    description: 'Record an agent interaction (called by capture hooks).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            session_id: { type: 'string', description: 'Session id' },
+            agent_type: { type: 'string', description: 'Agent type' },
+            org_name: { type: 'string', description: 'Org name' },
+            parent_agent: { type: 'string', description: 'Parent agent name/type, if spawned by another agent' },
+            prompt_summary: { type: 'string', description: 'Short summary of the prompt given to the agent' },
+            result_summary: { type: 'string', description: 'Short summary of the agent result' },
+            tokens_in: { type: 'number', description: 'Input tokens consumed (default 0)' },
+            tokens_out: { type: 'number', description: 'Output tokens produced (default 0)' },
+            cost_usd: { type: 'number', description: 'Cost in USD (default 0)' },
+            success: { type: 'boolean', description: 'Whether the interaction succeeded (default true)' },
+            duration_ms: { type: 'number', description: 'Duration in milliseconds (default 0)' },
+        },
+        required: ['session_id', 'agent_type'],
+    },
+    handler: async (input) => {
+        const { openDb, closeDb } = await import('@monoes/monograph');
+        const db = openDb(getDbPath());
+        try {
+            const id = randomUUID();
+            const timestamp = Date.now();
+            db.prepare(`
+        INSERT INTO agent_interactions (
+          id, session_id, org_name, agent_type, parent_agent,
+          prompt_summary, result_summary, tokens_in, tokens_out,
+          cost_usd, success, duration_ms, timestamp
+        ) VALUES (
+          @id, @session_id, @org_name, @agent_type, @parent_agent,
+          @prompt_summary, @result_summary, @tokens_in, @tokens_out,
+          @cost_usd, @success, @duration_ms, @timestamp
+        )
+      `).run({
+                id,
+                session_id: input.session_id,
+                org_name: input.org_name ?? null,
+                agent_type: input.agent_type,
+                parent_agent: input.parent_agent ?? null,
+                prompt_summary: input.prompt_summary ?? null,
+                result_summary: input.result_summary ?? null,
+                tokens_in: input.tokens_in ?? 0,
+                tokens_out: input.tokens_out ?? 0,
+                cost_usd: input.cost_usd ?? 0,
+                success: input.success === false ? 0 : 1,
+                duration_ms: input.duration_ms ?? 0,
+                timestamp,
+            });
+            return text(`Recorded agent interaction ${id} for ${input.agent_type} at ${timestamp}`);
+        }
+        finally {
+            closeDb(db);
+        }
+    },
+};
+// Advanced tools are only exposed over MCP when MONOGRAPH_MCP_ADVANCED=1.
+const ADVANCED = process.env['MONOGRAPH_MCP_ADVANCED'] === '1';
+/** Default-exposed core tools (19). */
+const coreMonographTools = [
     monographBuildTool,
     monographQueryTool,
+    monographSuggestTool,
+    monographImpactTool,
+    monographContextTool,
+    monographNeighborsTool,
+    monographDeadCodeTool,
     monographStatsTool,
     monographHealthTool,
+    monographAugmentTool,
     monographGodNodesTool,
+    monographDetectChangesTool,
     monographGetNodeTool,
+    monographApiImpactTool,
+    monographRouteMapTool,
+    monographStalenessTool,
+    monographWatchTool,
+    monographWatchStopTool,
+    monographDoctorTool,
+];
+/** Advanced tools — gated behind MONOGRAPH_MCP_ADVANCED=1. */
+const advancedMonographTools = [
+    monographCypherTool,
     monographShortestPathTool,
     monographCommunityTool,
     monographSurprisesTool,
-    monographSuggestTool,
-    monographSuggestAutoTool,
+    monographShapeCheckTool,
+    monographRenameTool,
+    monographToolMapTool,
+    monographServeTool,
     monographVisualizeTool,
-    monographWatchTool,
-    monographWatchStopTool,
-    monographReportTool,
-    monographStalenessTool,
     monographSnapshotTool,
     monographDiffTool,
-    monographNeighborsTool,
+    monographReportTool,
     monographExportTool,
-    monographContextTool,
-    monographImpactTool,
-    monographDetectChangesTool,
-    monographRenameTool,
-    monographRouteMapTool,
-    monographApiImpactTool,
-    monographCypherTool,
-    monographEmbedTool,
-    monographGroupListTool,
-    monographGroupQueryTool,
     monographWikiTool,
     monographWikiBuildTool,
-    monographServeTool,
-    monographToolMapTool,
-    monographShapeCheckTool,
-    monographGroupSyncTool,
-    monographAugmentTool,
-    monographInjectContextTool,
     monographSkillGenTool,
     monographInstallSkillsTool,
-    monographDoctorTool,
-    monographListReposTool,
+    monographInjectContextTool,
+    monographGroupListTool,
+    monographGroupQueryTool,
+    monographGroupSyncTool,
     monographGroupContractsTool,
     monographGroupStatusTool,
-    monographDeadCodeTool,
+    monographListReposTool,
+    monographAgentHistoryTool,
+    monographAgentPatternsTool,
+    monographAgentRecordTool,
 ];
+/**
+ * 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 const allMonographTools = [...coreMonographTools, ...advancedMonographTools];
+export const monographTools = ADVANCED ? allMonographTools : coreMonographTools;
 //# sourceMappingURL=monograph-tools.js.map