monomind 2.7.4 → 2.7.5

package/packages/@monomind/cli/dist/src/ui/server.mjs

@@ -1874,22 +1874,6 @@ export async function startServer({ port = 4242, projectDir, openBrowser = true
       return;
     }
 
-    // GET /api/adr-file?file=<name>&dir=<dir> — read a single ADR markdown file
-    if (req.method === 'GET' && url === '/api/adr-file') {
-      try {
-        const qs = new URL(req.url, 'http://localhost').searchParams;
-        const dir = qs.get('dir') || projectDir || process.cwd();
-        const fname = (qs.get('file') || '').replace(/[/\\]/g, '');
-        if (!fname || !fname.endsWith('.md')) { res.writeHead(400); res.end('{"error":"invalid file"}'); return; }
-        const fpath = path.join(path.resolve(dir), 'docs', 'adrs', fname);
-        if (!fs.existsSync(fpath)) { res.writeHead(404); res.end('{"error":"not found"}'); return; }
-        const content = fs.readFileSync(fpath, 'utf8');
-        res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
-        res.end(JSON.stringify({ file: fname, content }));
-      } catch (err) { res.writeHead(500); res.end(JSON.stringify({ error: err.message })); }
-      return;
-    }
-
     // ------------------------------------------------------- GET /api/memory-files
     if (req.method === 'GET' && url === '/api/memory-files') {
       try {
@@ -6331,265 +6315,6 @@ new Sigma(g,document.getElementById('g'),{renderEdgeLabels:false,labelColor:{col
       return;
     }
 
-    // GET /api/second-brain-metrics — aggregated injection analytics from second-brain.jsonl
-    if (req.method === 'GET' && url === '/api/second-brain-metrics') {
-      try {
-        const metricsFile = path.join(projectDir || process.cwd(), '.monomind', 'metrics', 'second-brain.jsonl');
-        if (!fs.existsSync(metricsFile)) {
-          res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
-          res.end(JSON.stringify({ total: 0, injected: 0, hitRate: 0, methods: {}, avgScore: 0, sparkline: [], scores: [] }));
-          return;
-        }
-        const raw = fs.readFileSync(metricsFile, 'utf8');
-        const entries = raw.split('\n').filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-        const total = entries.length;
-        const injectedCount = entries.filter(e => e.injected).length;
-        const hitRate = total > 0 ? injectedCount / total : 0;
-        // Method distribution
-        const methods = {};
-        for (const e of entries) { const m = e.method || 'unknown'; methods[m] = (methods[m] || 0) + 1; }
-        // Average top score (only for entries with hits)
-        const withScores = entries.filter(e => typeof e.topScore === 'number' && e.topScore !== null);
-        const avgScore = withScores.length > 0 ? withScores.reduce((s, e) => s + e.topScore, 0) / withScores.length : 0;
-        // Score distribution buckets
-        const scoreBuckets = [0, 0, 0, 0, 0]; // <0.3, 0.3-0.5, 0.5-0.7, 0.7-0.9, 0.9+
-        for (const e of withScores) {
-          const s = e.topScore;
-          if (s < 0.3) scoreBuckets[0]++;
-          else if (s < 0.5) scoreBuckets[1]++;
-          else if (s < 0.7) scoreBuckets[2]++;
-          else if (s < 0.9) scoreBuckets[3]++;
-          else scoreBuckets[4]++;
-        }
-        // Sparkline: group by hour for last 24h, then by day for older
-        const now = Date.now();
-        const h24 = now - 86400000;
-        const sparkline = [];
-        // Last 24 hours in 2h buckets
-        for (let t = h24; t < now; t += 7200000) {
-          const bucket = entries.filter(e => e.ts >= t && e.ts < t + 7200000);
-          const inj = bucket.filter(e => e.injected).length;
-          sparkline.push({ t, total: bucket.length, injected: inj });
-        }
-        // Top sources from recent entries (last 200)
-        const recentSlice = entries.slice(-200);
-        const misses = recentSlice.filter(e => !e.injected).length;
-        // Route overrides (misroute counts)
-        let routeOverrides = {};
-        try {
-          const overridesFile = path.join(projectDir || process.cwd(), '.monomind', 'metrics', 'route-overrides.json');
-          if (fs.existsSync(overridesFile)) routeOverrides = JSON.parse(fs.readFileSync(overridesFile, 'utf8'));
-        } catch {}
-        res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
-        res.end(JSON.stringify({ total, injected: injectedCount, hitRate: +hitRate.toFixed(3), methods, avgScore: +avgScore.toFixed(3), sparkline, scoreBuckets, recentMisses: misses, recentTotal: recentSlice.length, routeOverrides }));
-      } catch (err) {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: err.message }));
-      }
-      return;
-    }
-
-    // POST /api/second-brain-route — show query router decision for a given query
-    if (req.method === 'POST' && url === '/api/second-brain-route') {
-      let body = '';
-      req.on('data', c => { body += c; if (body.length > 65536) { req.destroy(); return; } });
-      req.on('end', async () => {
-        try {
-          const { query } = JSON.parse(body || '{}');
-          if (!query) { res.writeHead(400, { 'Content-Type': 'application/json' }); res.end('{"error":"query required"}'); return; }
-          const routerMod = await import('../memory/query-router.js');
-          const route = routerMod.routeQuery(String(query).slice(0, 2000));
-          const overrides = routerMod.getRouteOverrides(true);
-          res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
-          res.end(JSON.stringify({ route, overrides }));
-        } catch (err) {
-          res.writeHead(500, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ error: err.message }));
-        }
-      });
-      return;
-    }
-
-    // GET/PUT /api/second-brain-config — read/write Second Brain config (.monomind/second-brain.json)
-    if ((req.method === 'GET' || req.method === 'PUT') && url === '/api/second-brain-config') {
-      const configFile = path.join(projectDir || process.cwd(), '.monomind', 'second-brain.json');
-      if (req.method === 'GET') {
-        try {
-          let config = { relevanceFloor: 0.35, injectionLimit: 5 };
-          try { config = { ...config, ...JSON.parse(fs.readFileSync(configFile, 'utf8')) }; } catch {}
-          // Auto-tune suggestion: analyze telemetry to suggest optimal floor
-          let suggestion = null;
-          try {
-            const metricsFile = path.join(projectDir || process.cwd(), '.monomind', 'metrics', 'second-brain.jsonl');
-            if (fs.existsSync(metricsFile)) {
-              const entries = fs.readFileSync(metricsFile, 'utf8').split('\n').filter(Boolean)
-                .map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-              const withScores = entries.filter(e => typeof e.topScore === 'number' && e.topScore !== null);
-              if (withScores.length >= 20) {
-                const scores = withScores.map(e => e.topScore).sort((a, b) => a - b);
-                const p25 = scores[Math.floor(scores.length * 0.25)];
-                const hitRate = entries.filter(e => e.injected).length / entries.length;
-                // If hit rate is very low (<30%), suggest lowering floor
-                // If hit rate is very high (>80%) with low avg scores, suggest raising
-                if (hitRate < 0.3 && p25 > 0.2) suggestion = { floor: +(p25 - 0.05).toFixed(2), reason: 'Low hit rate (' + (hitRate * 100).toFixed(0) + '%) — lowering floor may surface more relevant results' };
-                else if (hitRate > 0.8 && scores[Math.floor(scores.length * 0.1)] < 0.35) suggestion = { floor: 0.4, reason: 'High hit rate with low-quality matches — raising floor filters noise' };
-              }
-            }
-          } catch {}
-          res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
-          res.end(JSON.stringify({ config, suggestion }));
-        } catch (err) {
-          res.writeHead(500, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ error: err.message }));
-        }
-        return;
-      }
-      if (req.method === 'PUT') {
-        let body = '';
-        req.on('data', c => { body += c; if (body.length > 4096) { req.destroy(); return; } });
-        req.on('end', () => {
-          try {
-            const raw = JSON.parse(body || '{}');
-            const updates = {};
-            if (typeof raw.relevanceFloor === 'number' && raw.relevanceFloor >= 0 && raw.relevanceFloor <= 1) updates.relevanceFloor = raw.relevanceFloor;
-            if (typeof raw.injectionLimit === 'number' && raw.injectionLimit >= 1 && raw.injectionLimit <= 50) updates.injectionLimit = Math.floor(raw.injectionLimit);
-            if (Object.keys(updates).length === 0) { res.writeHead(400, { 'Content-Type': 'application/json' }); res.end('{"error":"no valid fields to update"}'); return; }
-            let config = {};
-            try { config = JSON.parse(fs.readFileSync(configFile, 'utf8')); } catch {}
-            config = { ...config, ...updates };
-            fs.mkdirSync(path.dirname(configFile), { recursive: true });
-            fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
-            res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
-            res.end(JSON.stringify({ ok: true, config }));
-          } catch (err) {
-            res.writeHead(500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: err.message }));
-          }
-        });
-        return;
-      }
-    }
-
-    // GET /api/second-brain-docs — document-level view from doc-metadata.jsonl
-    if (req.method === 'GET' && url === '/api/second-brain-docs') {
-      try {
-        const d = path.resolve(projectDir || process.cwd());
-        const metaFile = path.join(d, '.monomind', 'knowledge', 'doc-metadata.jsonl');
-        // Also check global brain
-        const globalDir = process.env.MONOMIND_GLOBAL_BRAIN_DIR || path.join(os.homedir(), '.monomind', 'global-brain');
-        const globalMetaFile = path.join(globalDir, '.monomind', 'knowledge', 'doc-metadata.jsonl');
-        const docs = [];
-        let totalSize = 0, totalChunks = 0;
-        for (const [file, scope] of [[metaFile, 'project'], [globalMetaFile, 'global']]) {
-          if (!fs.existsSync(file)) continue;
-          const latest = new Map();
-          for (const l of fs.readFileSync(file, 'utf8').split('\n')) {
-            if (!l.trim()) continue;
-            try {
-              const m = JSON.parse(l);
-              latest.set(m.filePath + ' ' + m.scope, m);
-            } catch {}
-          }
-          for (const m of latest.values()) {
-            if (m.chunkCount < 0) continue;
-            const exists = fs.existsSync(m.filePath);
-            docs.push({ ...m, brainScope: scope, exists, name: path.basename(m.filePath) });
-            totalSize += m.size || 0;
-            totalChunks += m.chunkCount || 0;
-          }
-        }
-        docs.sort((a, b) => (b.indexedAt || '').localeCompare(a.indexedAt || ''));
-        const globalCount = docs.filter(d => d.brainScope === 'global').length;
-        res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
-        res.end(JSON.stringify({ docs, totalDocs: docs.length, totalSize, totalChunks, globalCount, projectCount: docs.length - globalCount }));
-      } catch (err) {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: err.message }));
-      }
-      return;
-    }
-
-    // GET /api/second-brain-ingest-stream — SSE stream tailing doc-metadata.jsonl for live ingest events
-    if (req.method === 'GET' && url === '/api/second-brain-ingest-stream') {
-      res.writeHead(200, {
-        'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive',
-        ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {})
-      });
-      res.write('data: {"type":"connected"}\n\n');
-      const metaFile = path.join(projectDir || process.cwd(), '.monomind', 'knowledge', 'doc-metadata.jsonl');
-      let lastSize = 0;
-      try { lastSize = fs.statSync(metaFile).size; } catch {}
-      function _sseTailFile(filePath, lastSizeRef, eventType, transform) {
-        try {
-          const stat = fs.statSync(filePath);
-          if (stat.size < lastSizeRef.v) { lastSizeRef.v = 0; }
-          if (stat.size > lastSizeRef.v) {
-            let fd;
-            try {
-              fd = fs.openSync(filePath, 'r');
-              const buf = Buffer.alloc(stat.size - lastSizeRef.v);
-              fs.readSync(fd, buf, 0, buf.length, lastSizeRef.v);
-              lastSizeRef.v = stat.size;
-              const lines = buf.toString('utf8').split('\n').filter(Boolean);
-              for (const l of lines) {
-                try { const parsed = JSON.parse(l); res.write('data: ' + JSON.stringify(transform(parsed)) + '\n\n'); } catch {}
-              }
-            } finally { if (fd !== undefined) fs.closeSync(fd); }
-          }
-        } catch {}
-      }
-      const metaSize = { v: lastSize };
-      const interval = setInterval(() => _sseTailFile(metaFile, metaSize, 'ingest', m => ({ type: 'ingest', doc: { ...m, name: path.basename(m.filePath || '') } })), 2000);
-      const metricsFile = path.join(projectDir || process.cwd(), '.monomind', 'metrics', 'second-brain.jsonl');
-      const metricsSize = { v: 0 };
-      try { metricsSize.v = fs.statSync(metricsFile).size; } catch {}
-      const metricsInterval = setInterval(() => _sseTailFile(metricsFile, metricsSize, 'injection', e => ({ type: 'injection', event: e })), 3000);
-      req.on('close', () => { clearInterval(interval); clearInterval(metricsInterval); });
-      return;
-    }
-
-    // GET /api/second-brain-kg — knowledge graph triplets + stats for the KG explorer
-    if (req.method === 'GET' && url === '/api/second-brain-kg') {
-      try {
-        const qs = new URL(req.url, 'http://localhost').searchParams;
-        const query = (qs.get('q') || '').slice(0, 200);
-        const limit = Math.min(parseInt(qs.get('limit') || '50', 10), 200);
-        const monoDir = path.join(projectDir || process.cwd(), '.monomind');
-        const dbPath = path.join(monoDir, 'memory');
-        let stats = { nodes: 0, edges: 0 }, triplets = [], glossary = [];
-        try {
-          const kg = await import('../memory/memory-kg.js');
-          stats = await kg.kgStats({ dbPath });
-          glossary = await kg.kgGlossary({ dbPath, limit: 30 });
-          if (query) {
-            const searchResult = await kg.kgSearch({ query, limit, dbPath });
-            triplets = searchResult.triplets || searchResult || [];
-          } else {
-            const searchResult = await kg.kgSearch({ query: '*', limit, dbPath }).catch(() => null);
-            triplets = searchResult ? (searchResult.triplets || searchResult) : [];
-          }
-        } catch {}
-        // Also check palace kg.json as fallback
-        if (triplets.length === 0) {
-          try {
-            const palaceDir = path.join(monoDir, 'palace');
-            const kgData = JSON.parse(fs.readFileSync(path.join(palaceDir, 'kg.json'), 'utf8'));
-            if (Array.isArray(kgData)) {
-              triplets = kgData.slice(0, limit);
-              stats.nodes = new Set(kgData.flatMap(t => [t.subject || t.s, t.object || t.o])).size;
-              stats.edges = kgData.length;
-            }
-          } catch {}
-        }
-        res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
-        res.end(JSON.stringify({ stats, triplets, glossary }));
-      } catch (err) {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: err.message }));
-      }
-      return;
-    }
-
     // GET /api/mastermind/metrics — aggregate system metrics from token-summary and swarm-activity
     if (req.method === 'GET' && url === '/api/mastermind/metrics') {
       try {

package/packages/@monomind/cli/dist/src/utils/cosine-similarity.d.ts

@@ -5,8 +5,8 @@
  *   - memory/intelligence.ts (ReasoningBank.cosineSim)
  *   - mcp-tools/neural-tools.ts (cosineSimilarity)
  *   - mcp-tools/embeddings-tools.ts (cosineSimilarity)
- *   - mcp-tools/coherence/types.ts (cosineSimilarity)
- *   - mcp-tools/coherence/coherence-check.ts (cosineSimilarity)
+ *   - mcp-tools/coherence/types.ts + coherence-check.ts (both since deleted
+ *     along with the rest of the uncalled coherence_* family)
  *
  * This is the single canonical implementation. Accepts number[] or
  * Float32Array. Handles dimension mismatches gracefully (uses the shorter

package/packages/@monomind/cli/dist/src/utils/cosine-similarity.js

@@ -5,8 +5,8 @@
  *   - memory/intelligence.ts (ReasoningBank.cosineSim)
  *   - mcp-tools/neural-tools.ts (cosineSimilarity)
  *   - mcp-tools/embeddings-tools.ts (cosineSimilarity)
- *   - mcp-tools/coherence/types.ts (cosineSimilarity)
- *   - mcp-tools/coherence/coherence-check.ts (cosineSimilarity)
+ *   - mcp-tools/coherence/types.ts + coherence-check.ts (both since deleted
+ *     along with the rest of the uncalled coherence_* family)
  *
  * This is the single canonical implementation. Accepts number[] or
  * Float32Array. Handles dimension mismatches gracefully (uses the shorter

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "2.7.4",
+  "version": "2.7.5",
   "type": "module",
   "description": "CLI engine for Monomind — an open-source MCP server that extends Claude Code with a codebase knowledge graph (tree-sitter + SQLite), persistent memory, multi-agent task coordination, and session hooks. MIT licensed, fully local.",
   "main": "dist/src/index.js",

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/causal-infer.d.ts

@@ -1,15 +0,0 @@
-/**
- * Causal Graph Analysis Tool - pr_causal_infer
- *
- * Analyzes causal graph structure to assess identifiability.
- * Identifies confounders, finds backdoor paths, and determines
- * whether a causal effect can be identified from the graph.
- * Does NOT estimate causal effect magnitude (that requires data).
- */
-import type { MCPTool } from './types.js';
-/**
- * pr_causal_infer MCP Tool Definition
- */
-export declare const causalInferTool: MCPTool;
-export default causalInferTool;
-//# sourceMappingURL=causal-infer.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/causal-infer.js

@@ -1,333 +0,0 @@
-/**
- * Causal Graph Analysis Tool - pr_causal_infer
- *
- * Analyzes causal graph structure to assess identifiability.
- * Identifies confounders, finds backdoor paths, and determines
- * whether a causal effect can be identified from the graph.
- * Does NOT estimate causal effect magnitude (that requires data).
- */
-import { CausalInputSchema, successResult, errorResult, } from './types.js';
-// Default logger
-const defaultLogger = {
-    debug: (msg, meta) => console.debug(`[pr_causal_infer] ${msg}`, meta),
-    info: (msg, meta) => console.info(`[pr_causal_infer] ${msg}`, meta),
-    warn: (msg, meta) => console.warn(`[pr_causal_infer] ${msg}`, meta),
-    error: (msg, meta) => console.error(`[pr_causal_infer] ${msg}`, meta),
-};
-function buildGraphStructure(graph) {
-    const nodes = new Map();
-    // Initialize nodes
-    for (const nodeId of graph.nodes) {
-        nodes.set(nodeId, {
-            id: nodeId,
-            parents: new Set(),
-            children: new Set(),
-        });
-    }
-    // Add edges
-    for (const [from, to] of graph.edges) {
-        const fromNode = nodes.get(from);
-        const toNode = nodes.get(to);
-        if (fromNode && toNode) {
-            fromNode.children.add(to);
-            toNode.parents.add(from);
-        }
-    }
-    return nodes;
-}
-/**
- * Find all ancestors of a node (including the node itself)
- */
-function findAncestors(nodeId, graph) {
-    const ancestors = new Set();
-    const queue = [nodeId];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (ancestors.has(current))
-            continue;
-        ancestors.add(current);
-        const node = graph.get(current);
-        if (node) {
-            for (const parent of node.parents) {
-                queue.push(parent);
-            }
-        }
-    }
-    return ancestors;
-}
-/**
- * Find all descendants of a node (including the node itself)
- */
-function findDescendants(nodeId, graph) {
-    const descendants = new Set();
-    const queue = [nodeId];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (descendants.has(current))
-            continue;
-        descendants.add(current);
-        const node = graph.get(current);
-        if (node) {
-            for (const child of node.children) {
-                queue.push(child);
-            }
-        }
-    }
-    return descendants;
-}
-/**
- * Identify confounders (common causes of treatment and outcome)
- */
-function identifyConfounders(treatment, outcome, graph) {
-    const treatmentAncestors = findAncestors(treatment, graph);
-    const outcomeAncestors = findAncestors(outcome, graph);
-    // Confounders are ancestors of both treatment and outcome
-    // that are not the treatment itself
-    const confounders = [];
-    for (const ancestor of treatmentAncestors) {
-        if (ancestor !== treatment && ancestor !== outcome && outcomeAncestors.has(ancestor)) {
-            confounders.push(ancestor);
-        }
-    }
-    return confounders;
-}
-/**
- * Find backdoor paths from treatment to outcome
- * A backdoor path is a path that goes into the treatment node
- */
-function findBackdoorPaths(treatment, outcome, graph, maxPaths = 10) {
-    const backdoorPaths = [];
-    const treatmentNode = graph.get(treatment);
-    if (!treatmentNode)
-        return [];
-    // Start from each parent of treatment (backdoor)
-    for (const parent of treatmentNode.parents) {
-        const paths = findAllPaths(parent, outcome, graph, new Set([treatment]), maxPaths - backdoorPaths.length);
-        for (const path of paths) {
-            backdoorPaths.push([treatment, ...path]);
-            if (backdoorPaths.length >= maxPaths)
-                break;
-        }
-        if (backdoorPaths.length >= maxPaths)
-            break;
-    }
-    return backdoorPaths;
-}
-/**
- * Find all paths from source to target (BFS with path tracking)
- */
-function findAllPaths(source, target, graph, exclude, maxPaths) {
-    const paths = [];
-    const queue = [{ node: source, path: [source] }];
-    while (queue.length > 0 && paths.length < maxPaths) {
-        const { node, path } = queue.shift();
-        if (node === target) {
-            paths.push(path);
-            continue;
-        }
-        const currentNode = graph.get(node);
-        if (!currentNode)
-            continue;
-        // Consider both parents and children for undirected path finding
-        const neighbors = new Set([...currentNode.parents, ...currentNode.children]);
-        for (const neighbor of neighbors) {
-            if (!path.includes(neighbor) && !exclude.has(neighbor)) {
-                queue.push({
-                    node: neighbor,
-                    path: [...path, neighbor],
-                });
-            }
-        }
-    }
-    return paths;
-}
-/**
- * Check if intervention is valid (treatment must exist and have outgoing edges)
- */
-function validateIntervention(treatment, outcome, graph) {
-    const treatmentNode = graph.get(treatment);
-    const outcomeNode = graph.get(outcome);
-    if (!treatmentNode || !outcomeNode) {
-        return false;
-    }
-    // Check if there's any path from treatment to outcome
-    const descendants = findDescendants(treatment, graph);
-    return descendants.has(outcome);
-}
-/**
- * Assess identifiability of the causal effect based on graph structure.
- * Does NOT estimate the causal effect magnitude -- that requires
- * observational or experimental data which this tool does not have.
- * Returns an identifiability score reflecting how cleanly the effect
- * can be estimated if data were available (fewer confounders and
- * unblocked backdoor paths = higher identifiability).
- */
-function assessIdentifiability(confounders, backdoorPaths) {
-    // Identifiability decreases with confounders and unblocked backdoor paths
-    const confounderPenalty = Math.min(confounders.length * 0.1, 0.3);
-    const pathPenalty = Math.min(backdoorPaths.length * 0.05, 0.2);
-    const identifiability = Math.max(0.1, 1 - confounderPenalty - pathPenalty);
-    return { identifiability };
-}
-/**
- * Get interpretation of causal graph analysis results
- */
-function getInterpretation(interventionValid, confounders, backdoorPaths, identifiability) {
-    if (!interventionValid) {
-        return 'Intervention is not valid - no causal path exists from treatment to outcome';
-    }
-    if (confounders.length === 0 && backdoorPaths.length === 0) {
-        return 'Clean causal identification - no confounding detected. Effect is identifiable with data.';
-    }
-    if (identifiability > 0.8) {
-        return 'Strong identifiability - confounders can be adjusted for with observational data';
-    }
-    if (identifiability > 0.5) {
-        return `Moderate identifiability - ${confounders.length} confounder(s) require adjustment`;
-    }
-    return `Weak identifiability - multiple confounders (${confounders.length}) and backdoor paths (${backdoorPaths.length}) detected`;
-}
-/**
- * Handler for pr_causal_infer tool
- */
-async function handler(input, context) {
-    const logger = context?.logger ?? defaultLogger;
-    const startTime = performance.now();
-    try {
-        // Validate input
-        const validationResult = CausalInputSchema.safeParse(input);
-        if (!validationResult.success) {
-            logger.error('Input validation failed', { error: validationResult.error.message });
-            return errorResult(`Invalid input: ${validationResult.error.message}`);
-        }
-        const { graph, intervention, outcome } = validationResult.data;
-        logger.debug('Processing causal inference', {
-            nodes: graph.nodes.length,
-            edges: graph.edges.length,
-            intervention,
-            outcome,
-        });
-        // Validate nodes exist
-        if (!graph.nodes.includes(intervention)) {
-            return errorResult(`Intervention variable "${intervention}" not found in graph nodes`);
-        }
-        if (!graph.nodes.includes(outcome)) {
-            return errorResult(`Outcome variable "${outcome}" not found in graph nodes`);
-        }
-        const maxBackdoorPaths = context?.config?.causal?.maxBackdoorPaths ?? 10;
-        let identifiability;
-        let confounders;
-        let backdoorPaths;
-        let interventionValid;
-        // Try to use WASM bridge if available
-        if (context?.bridge?.initialized) {
-            try {
-                logger.debug('Using WASM bridge for causal inference');
-                const result = await context.bridge.inferCausal(graph, intervention, outcome);
-                confounders = result.confounders;
-                backdoorPaths = result.backdoorPaths;
-                interventionValid = result.interventionValid;
-                identifiability = assessIdentifiability(confounders, backdoorPaths).identifiability;
-            }
-            catch (wasmError) {
-                logger.warn('WASM bridge failed, falling back to JS implementation', {
-                    error: wasmError instanceof Error ? wasmError.message : String(wasmError),
-                });
-                // Use JavaScript implementation
-                const graphStructure = buildGraphStructure(graph);
-                interventionValid = validateIntervention(intervention, outcome, graphStructure);
-                confounders = identifyConfounders(intervention, outcome, graphStructure);
-                backdoorPaths = findBackdoorPaths(intervention, outcome, graphStructure, maxBackdoorPaths);
-                identifiability = assessIdentifiability(confounders, backdoorPaths).identifiability;
-            }
-        }
-        else {
-            // Pure JavaScript fallback
-            logger.debug('Using JavaScript fallback for causal inference');
-            const graphStructure = buildGraphStructure(graph);
-            interventionValid = validateIntervention(intervention, outcome, graphStructure);
-            confounders = identifyConfounders(intervention, outcome, graphStructure);
-            backdoorPaths = findBackdoorPaths(intervention, outcome, graphStructure, maxBackdoorPaths);
-            identifiability = assessIdentifiability(confounders, backdoorPaths).identifiability;
-        }
-        const output = {
-            identifiability,
-            backdoorPaths: backdoorPaths.map(p => p.join(' -> ')),
-            details: {
-                confounders,
-                interventionValid,
-                interpretation: getInterpretation(interventionValid, confounders, backdoorPaths, identifiability),
-                nodeCount: graph.nodes.length,
-                edgeCount: graph.edges.length,
-            },
-        };
-        const duration = performance.now() - startTime;
-        logger.info('Causal graph analysis completed', {
-            identifiability: identifiability.toFixed(4),
-            confounders: confounders.length,
-            backdoorPaths: backdoorPaths.length,
-            interventionValid,
-            durationMs: duration.toFixed(2),
-        });
-        return successResult(output);
-    }
-    catch (error) {
-        const duration = performance.now() - startTime;
-        logger.error('Causal inference failed', {
-            error: error instanceof Error ? error.message : String(error),
-            durationMs: duration.toFixed(2),
-        });
-        return errorResult(error instanceof Error ? error : new Error(String(error)));
-    }
-}
-/**
- * pr_causal_infer MCP Tool Definition
- */
-export const causalInferTool = {
-    name: 'pr_causal_infer',
-    description: 'Analyze causal graph structure for identifiability. Identifies confounders, finds backdoor paths, and assesses whether a causal effect can be identified. Does not estimate effect magnitude (requires observational data).',
-    category: 'causal',
-    version: '0.1.3',
-    tags: ['causal', 'do-calculus', 'confounders', 'backdoor-paths', 'ai-interpretability'],
-    cacheable: true,
-    cacheTTL: 60000,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            graph: {
-                type: 'object',
-                properties: {
-                    nodes: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'List of variable names',
-                    },
-                    edges: {
-                        type: 'array',
-                        items: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            minItems: 2,
-                            maxItems: 2,
-                        },
-                        description: 'Directed edges as [from, to] pairs',
-                    },
-                },
-                required: ['nodes', 'edges'],
-                description: 'Causal graph with nodes and directed edges',
-            },
-            intervention: {
-                type: 'string',
-                description: 'Treatment/intervention variable',
-            },
-            outcome: {
-                type: 'string',
-                description: 'Outcome variable to measure effect on',
-            },
-        },
-        required: ['graph', 'intervention', 'outcome'],
-    },
-    handler,
-};
-export default causalInferTool;
-//# sourceMappingURL=causal-infer.js.map