@qe-mcp/server-ena 0.1.1

package/server.js

@@ -0,0 +1,1234 @@
+#!/usr/bin/env node
+/**
+ * ena-mcp-wasm — MCP server for Epistemic Network Analysis
+ *
+ * Zero-Python WASM backend using @qe-libs/rena-wasm.
+ * Tools:
+ *   ena_inspect        — triage tabular data for ENA suitability
+ *   ena_fit            — full pipeline; returns reusable model_id
+ *   ena_accumulate     — accumulation step only
+ *   ena_compare_groups — mean-rotation comparison of two groups; returns model_id
+ *   ena_plot           — render any view from a cached model_id
+ */
+
+import { readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { Server }               from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import loadENA from '@qe-libs/rena-wasm';
+
+// Path to the qeviz UMD bundle (self-contained, no external deps)
+import { createRequire } from 'module';
+const _require = createRequire(import.meta.url);
+const QEVIZ_BUNDLE = _require.resolve('@qe-libs/qeviz');
+let _qevizJS = null;
+function qevizJS() {
+    if (!_qevizJS) _qevizJS = readFileSync(QEVIZ_BUNDLE, 'utf8');
+    return _qevizJS;
+}
+
+// ── CSV parser ────────────────────────────────────────────────────────────────
+
+function parseLine(line) {
+    const fields = [];
+    let cur = '', inQ = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (ch === '"') {
+            if (inQ && line[i + 1] === '"') { cur += '"'; i++; }
+            else { inQ = !inQ; }
+        } else if (ch === ',' && !inQ) { fields.push(cur); cur = ''; }
+        else { cur += ch; }
+    }
+    fields.push(cur);
+    return fields;
+}
+
+function parseCSV(text) {
+    const lines = text.trim().split(/\r?\n/);
+    const headers = parseLine(lines[0]);
+    return lines.slice(1).filter(l => l.trim()).map(line => {
+        const vals = parseLine(line);
+        const row = {};
+        headers.forEach((h, i) => { row[h.trim()] = vals[i] ?? ''; });
+        return row;
+    });
+}
+
+function loadData(dataPath, dataCsv) {
+    if (dataPath)  return parseCSV(readFileSync(dataPath, 'utf8'));
+    if (dataCsv)   return parseCSV(dataCsv);
+    throw new Error('Provide either data_path (path to CSV) or data_csv (raw CSV string).');
+}
+
+// ── Result helpers ────────────────────────────────────────────────────────────
+
+const R = (v, places = 6) => Math.round(v * 10 ** places) / 10 ** places;
+
+function toRecords(fa, nRows, nCols, labels, prefix = 'dim') {
+    return Array.from({ length: nRows }, (_, i) => {
+        const rec = { label: labels[i] };
+        for (let j = 0; j < nCols; j++)
+            rec[`${prefix}${j + 1}`] = R(fa[i * nCols + j]);
+        return rec;
+    });
+}
+
+// Matches rena-wasm's rowKey() — separator must stay '__'
+function rowKey(row, cols) {
+    return cols.map(c => row[c]).join('__');
+}
+
+function buildUnitGroupMap(rows, unitCols, groupCol) {
+    const map = new Map();
+    for (const row of rows) {
+        const key = rowKey(row, unitCols);
+        if (!map.has(key)) map.set(key, String(row[groupCol]));
+    }
+    return map;
+}
+
+// ── Column-role heuristics ────────────────────────────────────────────────────
+
+const UNIT_HINTS  = new Set(['user','student','participant','speaker','person',
+                              'author','subject','respondent','id','name','who']);
+const CONVO_HINTS = new Set(['group','condition','session','conversation','convo',
+                              'episode','class','team','day','week','period',
+                              'context','case','trial']);
+const EXCLUDE     = new Set(['timestamp','time','date','text','utterance',
+                              'message','content','line','row','index','notes']);
+
+function isBinary(rows, col) {
+    const vals = new Set(rows.map(r => r[col]).filter(v => v !== '' && v != null));
+    return [...vals].every(v => v === '0' || v === '1' || v === 0 || v === 1);
+}
+
+function scoreUnit(col, nUnique, nRows) {
+    const name = col.toLowerCase();
+    if (nUnique < 2 || nUnique > Math.min(nRows * 0.8, 500)) return 0;
+    let s = 0.3;
+    if ([...UNIT_HINTS].some(h => name.includes(h))) s += 0.5;
+    if (nUnique >= 3 && nUnique <= 200) s += 0.2;
+    return Math.min(s, 1.0);
+}
+
+function scoreConvo(col, nUnique, nRows) {
+    const name = col.toLowerCase();
+    if (nUnique < 2 || nUnique > Math.min(nRows * 0.5, 300)) return 0;
+    let s = 0.2;
+    if ([...CONVO_HINTS].some(h => name.includes(h))) s += 0.6;
+    if (nUnique >= 2 && nUnique <= 100) s += 0.2;
+    return Math.min(s, 1.0);
+}
+
+// ── qeviz viz helpers ─────────────────────────────────────────────────────────
+
+const edgeColName = (n) => n.replace(' & ', '.');
+
+function buildQEVizData(model, unitLabels, codes, groupMap = null, groupCol = null) {
+    const { nUnits, nConnections, connectionNames } = model;
+
+    const nodes = {
+        data: codes.map((code, i) => ({
+            code,
+            x: model.positions[i * 2],
+            y: model.positions[i * 2 + 1],
+        })),
+        types: { code: 'character', x: 'numeric', y: 'numeric' },
+    };
+
+    const edgeTypes = { ENA_UNIT: 'character' };
+    if (groupCol) edgeTypes[groupCol] = 'character';
+    connectionNames.forEach(n => { edgeTypes[edgeColName(n)] = 'numeric'; });
+
+    const edges = {
+        data: unitLabels.map((lbl, i) => {
+            const row = { ENA_UNIT: lbl };
+            if (groupCol && groupMap) row[groupCol] = groupMap.get(lbl) ?? '';
+            connectionNames.forEach((n, j) => {
+                row[edgeColName(n)] = model.networks[i * nConnections + j];
+            });
+            return row;
+        }),
+        types: edgeTypes,
+    };
+
+    const pointTypes = { ENA_UNIT: 'character', x: 'numeric', y: 'numeric' };
+    if (groupCol) pointTypes[groupCol] = 'character';
+
+    const pointsFrame = {
+        data: unitLabels.map((lbl, i) => {
+            const row = { ENA_UNIT: lbl, x: model.centroids[i * 2], y: model.centroids[i * 2 + 1] };
+            if (groupCol && groupMap) row[groupCol] = groupMap.get(lbl) ?? '';
+            return row;
+        }),
+        types: pointTypes,
+    };
+
+    const modelData = {
+        directed:    false,
+        updated:     Date.now(),
+        id_col:      'ENA_UNIT',
+        node_id_col: 'code',
+        x_col:       'x',
+        y_col:       'y',
+        nodes,
+        edges,
+        points:      pointsFrame,
+    };
+    if (groupCol) modelData.group_col = groupCol;
+    return modelData;
+}
+
+function generateHTML(modelData, title = 'ENA Visualization', opts = {}) {
+    const { group1, group2 } = opts;
+    let edgesEl = '';
+    if (group1 && group2) {
+        edgesEl = `<qe-edges group="${group1}" also="${group2}"></qe-edges>`;
+    } else if (group1) {
+        edgesEl = `<qe-edges group="${group1}"></qe-edges>`;
+    }
+    const pointsEl = `<qe-points label="auto"></qe-points>`;
+    const meansEl  = group1 ? `<qe-means confidence></qe-means>` : '';
+
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>${title}</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: system-ui, sans-serif; background: #f0f0f0; padding: 1rem; }
+    h1 { font-size: 1rem; color: #333; margin-bottom: .75rem; font-weight: 500; }
+    .viz-wrap { background: #fff; border: 1px solid #ddd; border-radius: 6px; overflow: hidden; }
+    qe-visual { display: block; width: 100%; height: 620px; }
+    qe-graph  { display: block; width: 100%; height: 100%; }
+  </style>
+</head>
+<body>
+<h1>${title}</h1>
+<div class="viz-wrap">
+  <qe-visual id="vis">
+    <qe-graph width="100%" height="620" label-nodes="on">
+      ${edgesEl}
+      ${pointsEl}
+      ${meansEl}
+    </qe-graph>
+  </qe-visual>
+</div>
+<script>
+${qevizJS()}
+</script>
+<script>
+const modelData = ${JSON.stringify(modelData)};
+document.getElementById('vis').setModelData(modelData);
+</script>
+</body>
+</html>`;
+}
+
+function writeVizFile(html, name) {
+    const dir = join(tmpdir(), 'ena-viz');
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, `${name}.html`);
+    writeFileSync(path, html, 'utf8');
+    return path;
+}
+
+// ── jsdom SVG renderer ────────────────────────────────────────────────────────
+
+import { JSDOM } from 'jsdom';
+import { Resvg } from '@resvg/resvg-js';
+
+const SVG_SIZE = 600;
+
+async function renderSVG(modelData, opts = {}) {
+    const { group1, group2 } = opts;
+
+    const edgesEl = group1 && group2
+        ? `<qe-edges group="${group1}" also="${group2}"></qe-edges>`
+        : `<qe-edges group="${group1}"></qe-edges>`;
+    const childEls = `${edgesEl}<qe-points label="auto"></qe-points>${(!opts._noMeans && group1) ? '<qe-means confidence></qe-means>' : ''}`;
+
+    const dom = new JSDOM(
+        `<!DOCTYPE html><body><qe-visual id="vis"><qe-graph id="g" width="${SVG_SIZE}" height="${SVG_SIZE}" label-nodes="on">${childEls}</qe-graph></qe-visual></body>`,
+        { runScripts: 'dangerously', pretendToBeVisual: true }
+    );
+    const { window } = dom;
+
+    window.Element.prototype.getBoundingClientRect = () =>
+        ({ x:0, y:0, width:SVG_SIZE, height:SVG_SIZE, top:0, left:0, right:SVG_SIZE, bottom:SVG_SIZE });
+    window.requestAnimationFrame = cb => setTimeout(cb, 0);
+
+    const toStderr = (...a) => process.stderr.write(a.map(String).join(' ') + '\n');
+    window.console = { log: toStderr, info: toStderr, warn: toStderr, error: toStderr, debug: () => {} };
+
+    const s = window.document.createElement('script');
+    s.textContent = qevizJS();
+    window.document.head.appendChild(s);
+
+    window.document.getElementById('vis').setModelData(modelData);
+    await new Promise(r => setTimeout(r, 200));
+
+    const svgEl = window.document.getElementById('g')?.svg_element;
+    if (!svgEl) return null;
+
+    let svgHtml = svgEl.outerHTML;
+    // jsdom omits the SVG namespace declaration; resvg requires it to parse the document
+    if (!svgHtml.includes('xmlns=')) {
+        svgHtml = svgHtml.replace('<svg', '<svg xmlns="http://www.w3.org/2000/svg"');
+    }
+    return svgHtml;
+}
+
+// ── Model / accumulation cache ────────────────────────────────────────────────
+
+const accumCache = new Map();   // accumKey → { acc, rows }
+const modelCache = new Map();   // model_id → cache entry
+const fitCache   = new Map();   // fitKey   → model_id
+let   modelSeq   = 0;
+
+function accumCacheKey(p) {
+    return JSON.stringify({
+        data:          p.data_path ?? p.data_csv,
+        units:         p.units,
+        conversations: p.conversations,
+        codes:         [...p.codes].sort(),
+        window_size:   p.window_size  ?? 4,
+        binary:        p.binary       ?? true,
+    });
+}
+
+function fitCacheKey(p) {
+    return JSON.stringify({
+        data:          p.data_path   ?? p.data_csv,
+        units:         p.units,
+        conversations: p.conversations,
+        codes:         [...p.codes].sort(),
+        window_size:   p.window_size  ?? 4,
+        binary:        p.binary       ?? true,
+        rotation:      p.rotation     ?? 'svd',
+        group_col:     p.group_col    ?? null,
+        group1_value:  p.group1_value ?? null,
+        group2_value:  p.group2_value ?? null,
+    });
+}
+
+function nextModelId() { return `m${++modelSeq}`; }
+
+/**
+ * When no group filter is needed, qeviz still requires a group= attribute on
+ * <qe-edges> to know which rows to average. Inject a synthetic column that
+ * assigns every row to the same value so <qe-edges group="__g__"> draws the
+ * mean of all units in the frame.
+ */
+function injectSyntheticGroup(vizData, groupName = '__g__') {
+    vizData.edges.types[groupName]  = 'character';
+    vizData.points.types[groupName] = 'character';
+    vizData.edges.data.forEach(r  => { r[groupName] = groupName; });
+    vizData.points.data.forEach(r => { r[groupName] = groupName; });
+    vizData.group_col = groupName;
+}
+
+function computeGroupMean(networks, nConnections, idx) {
+    const mean = new Float64Array(nConnections);
+    for (const i of idx)
+        for (let j = 0; j < nConnections; j++)
+            mean[j] += networks[i * nConnections + j];
+    if (idx.length > 0)
+        for (let j = 0; j < nConnections; j++) mean[j] /= idx.length;
+    return mean;
+}
+
+// ── Tool implementations ──────────────────────────────────────────────────────
+
+/**
+ * Returns lightweight column metadata only — no raw data reaches Claude.
+ * Used for privacy-sensitive datasets where the user wants to keep data local.
+ */
+function toolProfile({ data_path }) {
+    if (!data_path)
+        throw new Error('ena_profile requires data_path. Raw CSV is never needed — the file stays on your machine.');
+
+    const rows    = loadData(data_path, null);
+    const nRows   = rows.length;
+    const headers = nRows > 0 ? Object.keys(rows[0]) : [];
+
+    const columns = headers.map(col => {
+        const vals    = rows.map(r => r[col]).filter(v => v !== '' && v != null);
+        const nUnique = new Set(vals).size;
+        const sample  = [...new Set(vals)].slice(0, 6);
+        const numericCount = vals.filter(v => !isNaN(Number(v))).length;
+        const isBin   = nUnique <= 2 && numericCount === vals.length &&
+                        sample.every(v => v === '0' || v === '1');
+        return {
+            name:     col,
+            n_unique: nUnique,
+            n_rows:   vals.length,
+            is_binary: isBin,
+            sample_values: sample,
+        };
+    });
+
+    const binaryCols = columns.filter(c => c.is_binary).map(c => c.name);
+    const summary = [
+        `Dataset profile (no raw data transmitted): ${nRows} rows × ${headers.length} columns`,
+        `Binary code columns detected (${binaryCols.length}): ${binaryCols.join(', ') || 'none'}`,
+        `All columns: ${columns.map(c => `${c.name} (${c.n_unique} unique${c.is_binary ? ', binary' : ''})`).join('; ')}`,
+    ].join('\n');
+
+    return {
+        privacy_note: 'PRIVACY SAFE — only column metadata was computed locally. No raw row data was sent to Claude.',
+        n_rows:        nRows,
+        n_cols:        headers.length,
+        columns,
+        binary_columns: binaryCols,
+        summary,
+    };
+}
+
+function toolInspect({ data_path, data_csv }) {
+    const isPrivacySafe = !!data_path && !data_csv;
+    const rows    = loadData(data_path, data_csv);
+    const nRows   = rows.length;
+    const headers = nRows > 0 ? Object.keys(rows[0]) : [];
+
+    const codeCols   = [];
+    const unitCands  = [];
+    const convoCands = [];
+    const colSummary = [];
+
+    for (const col of headers) {
+        const nameLower = col.toLowerCase();
+        const vals      = rows.map(r => r[col]).filter(v => v !== '' && v != null);
+        const nUnique   = new Set(vals).size;
+
+        if ([...EXCLUDE].some(h => nameLower.includes(h))) {
+            colSummary.push({ name: col, n_unique: nUnique, likely_role: 'metadata' });
+            continue;
+        }
+
+        if (isBinary(rows, col)) {
+            codeCols.push(col);
+            colSummary.push({ name: col, n_unique: nUnique, likely_role: 'code' });
+            continue;
+        }
+
+        const uScore = scoreUnit(col, nUnique, nRows);
+        const cScore = scoreConvo(col, nUnique, nRows);
+        if (uScore > 0 || cScore > 0) {
+            const role = uScore >= cScore ? 'unit_candidate' : 'conversation_candidate';
+            if (uScore > 0) unitCands.push([uScore, col, nUnique]);
+            if (cScore > 0) convoCands.push([cScore, col, nUnique]);
+            colSummary.push({ name: col, n_unique: nUnique, likely_role: role });
+            continue;
+        }
+
+        colSummary.push({ name: col, n_unique: nUnique, likely_role: 'other' });
+    }
+
+    unitCands.sort((a, b) => b[0] - a[0]);
+    convoCands.sort((a, b) => b[0] - a[0]);
+
+    const suggestedUnits  = unitCands.slice(0,5).map(([s,c,u]) =>
+        ({ column: c, n_unique: u, score: R(s, 2) }));
+    const suggestedConvos = convoCands.slice(0,5).map(([s,c,u]) =>
+        ({ column: c, n_unique: u, score: R(s, 2) }));
+
+    const suggestedGroups = {};
+    for (const [, col, nUnique] of convoCands.slice(0, 3)) {
+        if (nUnique >= 2 && nUnique <= 8) {
+            const vals = [...new Set(rows.map(r => String(r[col])).filter(Boolean))].sort();
+            suggestedGroups[col] = vals;
+            break;
+        }
+    }
+
+    const nCodes   = codeCols.length;
+    const hasUnits = unitCands.length > 0 && unitCands[0][0] >= 0.3;
+    const hasConvo = convoCands.length > 0 && convoCands[0][0] >= 0.2;
+
+    let recommended, confidence, reason;
+    if (nCodes >= 3 && hasUnits && hasConvo) {
+        recommended = true;
+        confidence  = nCodes >= 5 && unitCands[0][0] >= 0.7 ? 'high' : 'medium';
+        reason = `Found ${nCodes} binary code columns, a likely unit column ` +
+            `('${unitCands[0][1]}', ${unitCands[0][2]} unique values), and a ` +
+            `likely conversation column ('${convoCands[0][1]}', ${convoCands[0][2]} unique values). ` +
+            `This matches the ENA data signature: row-per-utterance with binary ` +
+            `presence/absence codes grouped by unit and conversation.`;
+    } else if (nCodes >= 2 && (hasUnits || hasConvo)) {
+        recommended = true;
+        confidence  = 'low';
+        reason = `Found ${nCodes} binary code column(s) and partial structure. ENA may be applicable.`;
+    } else if (nCodes >= 2) {
+        recommended = true;
+        confidence  = 'low';
+        reason = `Found ${nCodes} binary code columns but no clear unit/conversation columns by name.`;
+    } else {
+        recommended = false;
+        confidence  = 'low';
+        reason = `Found only ${nCodes} binary column(s). ENA typically requires 4+ binary code columns.`;
+    }
+
+    let nextStep = {};
+    if (recommended && suggestedUnits.length && suggestedConvos.length) {
+        const bestUnit  = suggestedUnits[0].column;
+        const bestConvo = suggestedConvos[0].column;
+        nextStep = {
+            tool: 'ena_fit',
+            parameters: {
+                data_path:     data_path ?? '<save CSV to a path first>',
+                units:         bestUnit,
+                conversations: bestConvo,
+                codes:         codeCols,
+                window_size:   4,
+                rotation:      'svd',
+            },
+        };
+        const grpCol = Object.keys(suggestedGroups)[0];
+        if (grpCol && suggestedGroups[grpCol].length === 2) {
+            nextStep.alternative_tool = 'ena_compare_groups';
+            nextStep.alternative_parameters = {
+                ...nextStep.parameters,
+                group_col:     grpCol,
+                group1_value:  suggestedGroups[grpCol][0],
+                group2_value:  suggestedGroups[grpCol][1],
+            };
+        }
+    }
+
+    const summaryLines = [
+        `ENA inspection: ${recommended ? 'RECOMMENDED' : 'NOT RECOMMENDED'} (confidence: ${confidence})`,
+        `  Dataset: ${nRows} rows × ${headers.length} columns`,
+        `  ${reason}`,
+        '',
+        `Binary code columns (${nCodes}): ${codeCols.join(', ') || 'none detected'}`,
+    ];
+    if (suggestedUnits.length)
+        summaryLines.push(`Top unit candidates: ` +
+            suggestedUnits.slice(0,3).map(u => `${u.column} (n=${u.n_unique}, score=${u.score})`).join(', '));
+    if (suggestedConvos.length)
+        summaryLines.push(`Top conversation candidates: ` +
+            suggestedConvos.slice(0,3).map(c => `${c.column} (n=${c.n_unique}, score=${c.score})`).join(', '));
+    for (const [col, vals] of Object.entries(suggestedGroups))
+        summaryLines.push(`Likely group column: '${col}' → ${JSON.stringify(vals)}`);
+
+    const privacyNote = isPrivacySafe
+        ? 'PRIVACY SAFE — data was read from a local file path. No raw row data was sent to Claude; only this analysis result was transmitted.'
+        : 'RAW DATA TRANSMITTED — data_csv was used, so row data passed through this conversation. For sensitive datasets, ask the user to save the file and provide data_path instead.';
+
+    return {
+        privacy_note:            privacyNote,
+        ena_recommended:         recommended,
+        confidence,
+        reason,
+        n_rows:                  nRows,
+        n_cols:                  headers.length,
+        suggested_codes:         codeCols,
+        suggested_units:         suggestedUnits,
+        suggested_conversations: suggestedConvos,
+        suggested_groups:        suggestedGroups,
+        column_summary:          colSummary,
+        next_step:               nextStep,
+        summary:                 summaryLines.join('\n'),
+    };
+}
+
+async function toolFit(ena, params) {
+    const {
+        units, conversations, codes,
+        data_path, data_csv,
+        window_size = 4, window_forward = 0, binary = true,
+        dims = 2, rotation = 'svd',
+        group_col, group1_value, group2_value,
+    } = params;
+
+    // Normalize units/conversations to arrays (rena-wasm joins with '__')
+    const unitCols = Array.isArray(units) ? units : [units];
+    const convoCols = Array.isArray(conversations) ? conversations : [conversations];
+
+    // Return cached model if params are identical
+    const fKey = fitCacheKey(params);
+    if (fitCache.has(fKey)) {
+        const model_id = fitCache.get(fKey);
+        const entry    = modelCache.get(model_id);
+        return {
+            model_id,
+            ...entry.result,
+            summary: `Using cached model ${model_id}.\n${entry.result.summary}`,
+            _vizData: entry.vizData,
+            _vizOpts: entry.vizOpts,
+        };
+    }
+
+    // Load data; reuse parsed rows if already cached for this accumulation key
+    const aKey = accumCacheKey(params);
+    let rows, acc;
+    if (accumCache.has(aKey)) {
+        ({ rows, acc } = accumCache.get(aKey));
+    } else {
+        rows = loadData(data_path, data_csv);
+        acc  = ena.accumulate(rows, {
+            codes, units: unitCols, conversations: convoCols,
+            window: window_size, binary,
+        });
+        accumCache.set(aKey, { rows, acc });
+    }
+
+    const { unitLabels, nConnections, connectionNames, nUnits } = acc;
+
+    let groupA, groupB, uMap;
+    if (group_col) uMap = buildUnitGroupMap(rows, unitCols, group_col);
+
+    if (rotation === 'mean') {
+        if (!group_col || !group1_value || !group2_value)
+            throw new Error("rotation='mean' requires group_col, group1_value, and group2_value.");
+        groupA = unitLabels.flatMap((lbl, i) => uMap.get(lbl) === String(group1_value) ? [i] : []);
+        groupB = unitLabels.flatMap((lbl, i) => uMap.get(lbl) === String(group2_value) ? [i] : []);
+        if (!groupA.length) throw new Error(`No units found for ${group_col}=${group1_value}`);
+        if (!groupB.length) throw new Error(`No units found for ${group_col}=${group2_value}`);
+    } else if (rotation !== 'svd') {
+        throw new Error(`Unknown rotation '${rotation}'. WASM backend supports: svd, mean.`);
+    }
+
+    const model = ena.fit(rows, {
+        codes, units: unitCols, conversations: convoCols,
+        window: window_size, binary, dims,
+        rotation: rotation === 'mean' ? 'mean' : 'svd',
+        groupA, groupB,
+    });
+
+    const groupMap = uMap ?? null;
+
+    // Pre-compute per-group mean networks for ena_plot use
+    let groupNetworks = null;
+    if (groupMap) {
+        const allGroups = [...new Set(groupMap.values())];
+        groupNetworks = {};
+        for (const gv of allGroups) {
+            const idx = unitLabels.flatMap((lbl, i) => groupMap.get(lbl) === gv ? [i] : []);
+            groupNetworks[gv] = computeGroupMean(acc.networks, nConnections, idx);
+        }
+    }
+
+    const dimCols    = Array.from({ length: dims }, (_, i) => `dim${i + 1}`);
+    const centroids  = toRecords(model.centroids, nUnits, dims, unitLabels);
+    const nodePos    = toRecords(model.positions, codes.length, dims, codes);
+
+    const nodeLines = nodePos.map(n =>
+        `  ${n.label.padEnd(32)}` + dimCols.map(d =>
+            `  ${(n[d] ?? 0) >= 0 ? '+' : ''}${(n[d] ?? 0).toFixed(4)}`).join('')
+    );
+
+    const model_id = nextModelId();
+    const summary = [
+        `ENA model fitted.  model_id: ${model_id}`,
+        `  Units: ${nUnits}   Codes: ${codes.length}   Connections: ${nConnections}   Dims: ${dims}`,
+        `  Rotation: ${rotation}`,
+        `  Window: back=${window_size}, forward=${window_forward}, binary=${binary}`,
+        '',
+        `Node positions (${dimCols.join(', ')}):`,
+        ...nodeLines,
+        '',
+        `Use ena_plot with model_id="${model_id}" for additional views (group, unit, subtraction, comparison).`,
+    ].join('\n');
+
+    const groups = group_col && group1_value && group2_value
+        ? { group1: String(group1_value), group2: String(group2_value) }
+        : group_col && groupMap
+            ? { group1: [...new Set(groupMap.values())][0] }
+            : {};
+    const vizData = buildQEVizData(model, unitLabels, codes, groupMap, group_col ?? null);
+    const vizOpts = groups;
+
+    const result = {
+        model_id,
+        centroids,
+        node_positions:   nodePos,
+        connection_names: model.connectionNames,
+        units:            unitLabels,
+        codes,
+        n_units:          nUnits,
+        n_codes:          codes.length,
+        n_connections:    nConnections,
+        summary,
+    };
+
+    modelCache.set(model_id, {
+        model, codes, unitLabels,
+        groupMap, groupCol: group_col ?? null,
+        groupNetworks, connectionNames, nConnections, dims,
+        vizData, vizOpts, result,
+    });
+    fitCache.set(fKey, model_id);
+
+    return { ...result, _vizData: vizData, _vizOpts: vizOpts };
+}
+
+async function toolAccumulate(ena, {
+    units, conversations, codes,
+    data_path, data_csv,
+    window_size = 4, window_forward = 0, binary = true,
+}) {
+    const unitCols  = Array.isArray(units)         ? units         : [units];
+    const convoCols = Array.isArray(conversations) ? conversations : [conversations];
+    const rows   = loadData(data_path, data_csv);
+    const result = ena.accumulate(rows, {
+        codes, units: unitCols, conversations: convoCols,
+        window: window_size, binary,
+    });
+
+    const { networks: connectionCounts, unitLabels, connectionNames, nUnits, nConnections } = result;
+
+    const networks = unitLabels.map((lbl, i) => {
+        const rec = { unit: lbl };
+        for (let j = 0; j < nConnections; j++)
+            rec[connectionNames[j]] = R(connectionCounts[i * nConnections + j], 4);
+        return rec;
+    });
+
+    const totals = new Float64Array(nConnections);
+    for (let i = 0; i < nUnits; i++)
+        for (let j = 0; j < nConnections; j++)
+            totals[j] += connectionCounts[i * nConnections + j];
+
+    const topIdx = Array.from({ length: nConnections }, (_, i) => i)
+        .sort((a, b) => totals[b] - totals[a])
+        .slice(0, 10)
+        .filter(i => totals[i] > 0);
+
+    const topConnections = topIdx.map(i => ({
+        connection:   connectionNames[i],
+        total_weight: R(totals[i], 4),
+    }));
+
+    const summary = [
+        'ENA accumulation complete.',
+        `  Units: ${nUnits}   Connections: ${nConnections}`,
+        `  Window: back=${window_size}, forward=${window_forward}, binary=${binary}`,
+        '',
+        'Top 10 connections by total weight:',
+        ...topConnections.map(t => `  ${t.connection.padEnd(40)}  ${t.total_weight.toFixed(1)}`),
+    ].join('\n');
+
+    return {
+        networks,
+        connection_names: connectionNames,
+        units:            unitLabels,
+        codes:            [...codes],
+        n_units:          nUnits,
+        n_codes:          codes.length,
+        n_connections:    nConnections,
+        top_connections:  topConnections,
+        summary,
+    };
+}
+
+async function toolCompareGroups(ena, params) {
+    const {
+        units, conversations, codes,
+        group_col, group1_value, group2_value,
+        data_path, data_csv,
+        window_size = 4, window_forward = 0, binary = true,
+        dims = 2,
+    } = params;
+
+    // Return cached model if params are identical
+    const fKey = fitCacheKey({ ...params, rotation: 'mean' });
+    if (fitCache.has(fKey)) {
+        const model_id = fitCache.get(fKey);
+        const entry    = modelCache.get(model_id);
+        return {
+            model_id,
+            ...entry.result,
+            summary: `Using cached model ${model_id}.\n${entry.result.summary}`,
+            _vizData: entry.vizData,
+            _vizOpts: entry.vizOpts,
+        };
+    }
+
+    // Normalize units/conversations to arrays
+    const unitCols  = Array.isArray(units)         ? units         : [units];
+    const convoCols = Array.isArray(conversations) ? conversations : [conversations];
+
+    // Accumulate (or use cache)
+    const aKey = accumCacheKey(params);
+    let rows, acc;
+    if (accumCache.has(aKey)) {
+        ({ rows, acc } = accumCache.get(aKey));
+    } else {
+        rows = loadData(data_path, data_csv);
+        acc  = ena.accumulate(rows, {
+            codes, units: unitCols, conversations: convoCols,
+            window: window_size, binary,
+        });
+        accumCache.set(aKey, { rows, acc });
+    }
+
+    const { unitLabels, networks: connectionCounts, connectionNames, nUnits, nConnections } = acc;
+
+    const uMap  = buildUnitGroupMap(rows, unitCols, group_col);
+    const g1Idx = unitLabels.flatMap((lbl, i) => uMap.get(lbl) === String(group1_value) ? [i] : []);
+    const g2Idx = unitLabels.flatMap((lbl, i) => uMap.get(lbl) === String(group2_value) ? [i] : []);
+
+    if (!g1Idx.length) throw new Error(`No units found for ${group_col}=${group1_value}`);
+    if (!g2Idx.length) throw new Error(`No units found for ${group_col}=${group2_value}`);
+
+    const model = ena.fit(rows, {
+        codes, units: unitCols, conversations: convoCols,
+        window: window_size, binary, dims,
+        rotation: 'mean', groupA: g1Idx, groupB: g2Idx,
+    });
+
+    const dimCols      = Array.from({ length: dims }, (_, i) => `dim${i + 1}`);
+    const allCentroids = toRecords(model.centroids, nUnits, dims, unitLabels);
+    const g1Set = new Set(g1Idx);
+    const g2Set = new Set(g2Idx);
+    const g1Centroids = allCentroids.filter((_, i) => g1Set.has(i));
+    const g2Centroids = allCentroids.filter((_, i) => g2Set.has(i));
+    const nodePos      = toRecords(model.positions, codes.length, dims, codes);
+
+    const groupMeanPos = (centroids) => Object.fromEntries(
+        dimCols.map(d => [d, R(centroids.reduce((s, c) => s + (c[d] ?? 0), 0) / centroids.length)])
+    );
+    const g1Mean = groupMeanPos(g1Centroids);
+    const g2Mean = groupMeanPos(g2Centroids);
+    const diff   = Object.fromEntries(dimCols.map(d => [d, R(g1Mean[d] - g2Mean[d])]));
+
+    const g1NetMean = computeGroupMean(connectionCounts, nConnections, g1Idx);
+    const g2NetMean = computeGroupMean(connectionCounts, nConnections, g2Idx);
+    const subNet    = g1NetMean.map((v, j) => v - g2NetMean[j]);
+
+    const groupNetworks = {
+        [String(group1_value)]: g1NetMean,
+        [String(group2_value)]: g2NetMean,
+    };
+
+    const topIdx = Array.from({ length: nConnections }, (_, i) => i)
+        .sort((a, b) => Math.abs(subNet[b]) - Math.abs(subNet[a]))
+        .slice(0, 10);
+
+    const topDiff = topIdx.map(i => ({
+        connection:              connectionNames[i],
+        [`${group1_value}_mean`]: R(g1NetMean[i], 4),
+        [`${group2_value}_mean`]: R(g2NetMean[i], 4),
+        difference:              R(subNet[i], 4),
+    }));
+
+    const netDict = (arr) => Object.fromEntries(
+        connectionNames.map((n, i) => [n, R(arr[i], 4)])
+    );
+
+    const groupMap = uMap;
+    const vizData  = buildQEVizData(model, unitLabels, codes, groupMap, group_col);
+    const vizOpts  = { group1: String(group1_value), group2: String(group2_value) };
+    const model_id = nextModelId();
+
+    const summary = [
+        `ENA group comparison: '${group1_value}' vs '${group2_value}'   model_id: ${model_id}`,
+        `  ${group1_value}: n=${g1Idx.length}   centroid = ` +
+            dimCols.map(d => `${d}=${g1Mean[d] >= 0 ? '+' : ''}${g1Mean[d].toFixed(4)}`).join(', '),
+        `  ${group2_value}: n=${g2Idx.length}   centroid = ` +
+            dimCols.map(d => `${d}=${g2Mean[d] >= 0 ? '+' : ''}${g2Mean[d].toFixed(4)}`).join(', '),
+        `  Difference (g1−g2): ` +
+            dimCols.map(d => `${d}=${diff[d] >= 0 ? '+' : ''}${diff[d].toFixed(4)}`).join(', '),
+        '',
+        'Top differential connections:',
+        ...topDiff.map(t =>
+            `  ${t.connection.padEnd(40)}  ` +
+            `${group1_value}=${t[`${group1_value}_mean`] >= 0 ? '+' : ''}${t[`${group1_value}_mean`].toFixed(3)}  ` +
+            `${group2_value}=${t[`${group2_value}_mean`] >= 0 ? '+' : ''}${t[`${group2_value}_mean`].toFixed(3)}  ` +
+            `Δ=${t.difference >= 0 ? '+' : ''}${t.difference.toFixed(3)}`
+        ),
+        '',
+        `Use ena_plot with model_id="${model_id}" for group, subtraction, comparison, or unit views.`,
+    ].join('\n');
+
+    const result = {
+        model_id,
+        group1_centroids:    g1Centroids,
+        group2_centroids:    g2Centroids,
+        group1_mean:         g1Mean,
+        group2_mean:         g2Mean,
+        difference:          diff,
+        node_positions:      nodePos,
+        connection_names:    [...connectionNames],
+        group1_networks:     netDict(g1NetMean),
+        group2_networks:     netDict(g2NetMean),
+        subtraction_network: netDict(subNet),
+        top_differential:    topDiff,
+        summary,
+    };
+
+    modelCache.set(model_id, {
+        model, codes, unitLabels,
+        groupMap, groupCol: group_col,
+        groupNetworks, connectionNames, nConnections, dims,
+        // Extra fields for compare models
+        subNet, g1Idx, g2Idx,
+        group1_value: String(group1_value),
+        group2_value: String(group2_value),
+        vizData, vizOpts, result,
+    });
+    fitCache.set(fKey, model_id);
+
+    return { ...result, _vizData: vizData, _vizOpts: vizOpts };
+}
+
+async function toolPlot({ model_id, type = 'all', group_value, group1, group2, unit_label }) {
+    const entry = modelCache.get(model_id);
+    if (!entry)
+        throw new Error(`Unknown model_id '${model_id}'. Call ena_fit or ena_compare_groups first.`);
+
+    const { model, codes, unitLabels, groupMap, groupCol, groupNetworks, nConnections, dims } = entry;
+
+    let vizData, vizOpts, label;
+
+    switch (type) {
+        case 'all':
+            vizData = buildQEVizData(model, unitLabels, codes, groupMap, groupCol);
+            injectSyntheticGroup(vizData);
+            vizOpts = { group1: '__g__', _noMeans: true };
+            label   = `ENA model ${model_id} — all units`;
+            break;
+
+        case 'group': {
+            if (!group_value)
+                throw new Error("type='group' requires group_value");
+            if (!groupCol)
+                throw new Error(`Model ${model_id} has no group column. Refit with group_col.`);
+            vizData = buildQEVizData(model, unitLabels, codes, groupMap, groupCol);
+            vizOpts = { group1: String(group_value) };
+            label   = `ENA mean network — ${group_value}`;
+            break;
+        }
+
+        case 'comparison': {
+            const g1 = group1 ?? entry.group1_value;
+            const g2 = group2 ?? entry.group2_value;
+            if (!g1 || !g2)
+                throw new Error("type='comparison' requires group1 and group2");
+            if (!groupCol)
+                throw new Error(`Model ${model_id} has no group column. Refit with group_col.`);
+            vizData = buildQEVizData(model, unitLabels, codes, groupMap, groupCol);
+            vizOpts = { group1: String(g1), group2: String(g2) };
+            label   = `ENA comparison — ${g1} vs ${g2}`;
+            break;
+        }
+
+        case 'subtraction': {
+            const g1 = group1 ?? entry.group1_value;
+            const g2 = group2 ?? entry.group2_value;
+            if (!g1 || !g2)
+                throw new Error("type='subtraction' requires group1 and group2");
+            if (!groupNetworks || !groupNetworks[g1] || !groupNetworks[g2])
+                throw new Error(
+                    `Group networks not found for '${g1}' / '${g2}'. ` +
+                    `Refit with group_col specified, or use ena_compare_groups.`
+                );
+            const subNet   = groupNetworks[g1].map((v, j) => v - groupNetworks[g2][j]);
+            const synLabel = [`${g1} − ${g2}`];
+            const synModel = {
+                ...model,
+                nUnits:   1,
+                networks: subNet,
+                centroids: new Float64Array(dims * 1),
+            };
+            vizData = buildQEVizData(synModel, synLabel, codes, null, null);
+            injectSyntheticGroup(vizData);
+            vizOpts = { group1: '__g__', _noMeans: true };
+            label   = `ENA subtraction — ${g1} − ${g2}`;
+            break;
+        }
+
+        case 'unit': {
+            if (!unit_label)
+                throw new Error("type='unit' requires unit_label");
+            const unitIdx = unitLabels.indexOf(String(unit_label));
+            if (unitIdx === -1)
+                throw new Error(
+                    `Unit '${unit_label}' not found. ` +
+                    `Available: ${unitLabels.slice(0, 20).join(', ')}`
+                );
+            const synModel = {
+                ...model,
+                nUnits:   1,
+                networks: model.networks.slice(unitIdx * nConnections, (unitIdx + 1) * nConnections),
+                centroids: model.centroids.slice(unitIdx * dims, (unitIdx + 1) * dims),
+            };
+            vizData = buildQEVizData(synModel, [String(unit_label)], codes, null, null);
+            injectSyntheticGroup(vizData);
+            vizOpts = { group1: '__g__', _noMeans: true };
+            label   = `ENA network — ${unit_label}`;
+            break;
+        }
+
+        default:
+            throw new Error(
+                `Unknown type '${type}'. Options: all, group, comparison, subtraction, unit`
+            );
+    }
+
+    return {
+        model_id,
+        plot_type: type,
+        label,
+        n_codes:   codes.length,
+        n_units:   unitLabels.length,
+        summary:   label,
+        _vizData:  vizData,
+        _vizOpts:  vizOpts,
+    };
+}
+
+// ── Tool schemas ──────────────────────────────────────────────────────────────
+
+const DATA_PROPS = {
+    data_path: {
+        type: 'string',
+        description:
+            'Absolute path to a CSV file on the user\'s machine. ' +
+            'PREFERRED for sensitive data — the file is read locally by the WASM server; ' +
+            'no raw row data is transmitted to Claude.',
+    },
+    data_csv: {
+        type: 'string',
+        description:
+            'Raw CSV text (use this OR data_path). ' +
+            'WARNING: the full dataset passes through this conversation. ' +
+            'Ask the user whether their data is sensitive before using this parameter.',
+    },
+};
+const CORE_PROPS = {
+    ...DATA_PROPS,
+    units:         { description: 'Column name(s) identifying units of analysis. Pass a string for a single column (e.g. "student_id") or an array for compound units (e.g. ["UserName","Condition"]). Compound units are joined with "__" to form labels like "alice__FirstGame".' },
+    conversations: { description: 'Column name(s) segmenting conversations — accumulation resets between conversations. Pass a string or array (e.g. ["Condition","GameDay"]).' },
+    codes:         { type: 'array', items: { type: 'string' }, description: 'List of binary code column names' },
+    window_size:   { type: 'number', description: 'Stanza window — rows to look back (default 4)' },
+    window_forward:{ type: 'number', description: 'Rows to look forward (default 0)' },
+    binary:        { type: 'boolean', description: 'Binarise co-occurrences (default true)' },
+};
+
+const TOOLS = [
+    {
+        name: 'ena_profile',
+        description:
+            'PRIVACY-SAFE dataset profiler: reads a CSV from the local file system and returns only column metadata ' +
+            '(column names, unique-value counts, sample values, binary detection). ' +
+            'No raw row data is ever sent to Claude — use this when the user has sensitive data and wants to keep it local. ' +
+            'Returns enough information to determine ENA parameters (units, conversations, codes) without exposing the data itself. ' +
+            'WHEN TO USE: before ena_inspect or ena_fit, if the user says their data is sensitive, confidential, or private, ' +
+            'or if they ask whether their data will be sent to Claude.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                data_path: {
+                    type: 'string',
+                    description: 'Absolute path to the CSV file on the user\'s machine.',
+                },
+            },
+            required: ['data_path'],
+        },
+    },
+    {
+        name: 'ena_inspect',
+        description:
+            'Inspect a dataset and recommend whether ENA is an appropriate analysis. ' +
+            'Call this FIRST whenever a user provides tabular data and asks for analysis. ' +
+            'Returns ena_recommended, confidence, suggested codes/units/conversations, and a ready-to-use next_step call. ' +
+            'PRIVACY: prefer data_path over data_csv so raw data stays local. ' +
+            'If the user has not yet indicated whether their data is sensitive, ask before using data_csv. ' +
+            'If they indicate sensitivity, use ena_profile instead (no raw data transmitted).',
+        inputSchema: {
+            type: 'object',
+            properties: DATA_PROPS,
+        },
+    },
+    {
+        name: 'ena_fit',
+        description:
+            'Fit a full ENA model: accumulate → sphere-norm → center → rotate → project → LWS node positions. ' +
+            'Returns a model_id that can be passed to ena_plot for additional views (group mean, unit, subtraction, comparison) without re-fitting. ' +
+            'Repeated calls with identical parameters return the cached model instantly. ' +
+            'Supports rotation="svd" (default) or rotation="mean" (requires group_col, group1_value, group2_value). ' +
+            'An ENA network plot is returned as an inline image in this response — do not generate your own visualization. ' +
+            'PRIVACY: use data_path (file stays local, only model results reach Claude) rather than data_csv (raw data passes through conversation). ' +
+            'The WASM model runs entirely on the user\'s machine regardless of which input method is used.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...CORE_PROPS,
+                dims:          { type: 'number', description: 'Dimensions to return (default 2)' },
+                rotation:      { type: 'string', enum: ['svd', 'mean'], description: '"svd" (default) or "mean"' },
+                group_col:     { type: 'string', description: 'Metadata column for group membership (required for rotation="mean"; enables group/subtraction plots)' },
+                group1_value:  { type: 'string', description: 'Group 1 value (required for rotation="mean")' },
+                group2_value:  { type: 'string', description: 'Group 2 value (required for rotation="mean")' },
+            },
+            required: ['units', 'conversations', 'codes'],
+        },
+    },
+    {
+        name: 'ena_accumulate',
+        description:
+            'Run only the ENA accumulation step — no rotation or projection. ' +
+            'Returns raw per-unit co-occurrence networks and top connections by weight. ' +
+            'Useful for inspecting co-occurrence patterns before committing to a model.',
+        inputSchema: {
+            type: 'object',
+            properties: CORE_PROPS,
+            required: ['units', 'conversations', 'codes'],
+        },
+    },
+    {
+        name: 'ena_compare_groups',
+        description:
+            'Fit an ENA model with mean rotation and compare two groups. ' +
+            'Axis 1 passes through the mean difference between groups. ' +
+            'Returns a model_id for use with ena_plot (group, subtraction, comparison, unit views). ' +
+            'Repeated calls with identical parameters return the cached model instantly. ' +
+            'An ENA network plot is returned as an inline image in this response — do not generate your own visualization. ' +
+            'PRIVACY: use data_path (file stays local, only model results reach Claude) rather than data_csv (raw data passes through conversation). ' +
+            'The WASM model runs entirely on the user\'s machine regardless of which input method is used.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...CORE_PROPS,
+                group_col:    { type: 'string', description: 'Column identifying group membership' },
+                group1_value: { type: 'string', description: 'Value for group 1' },
+                group2_value: { type: 'string', description: 'Value for group 2' },
+                dims:         { type: 'number', description: 'Dimensions to return (default 2)' },
+            },
+            required: ['units', 'conversations', 'codes', 'group_col', 'group1_value', 'group2_value'],
+        },
+    },
+    {
+        name: 'ena_plot',
+        description:
+            'Generate an ENA network plot from a previously fitted model without re-running the pipeline. ' +
+            'Use the model_id returned by ena_fit or ena_compare_groups. ' +
+            'View types: ' +
+            '"all" — all units with group colouring if group_col was specified; ' +
+            '"group" — mean network for a single group (requires group_value); ' +
+            '"comparison" — overlay of two group mean networks (requires group1, group2); ' +
+            '"subtraction" — difference network g1 − g2 (requires group1, group2, and group_col on the source model); ' +
+            '"unit" — individual unit network (requires unit_label). ' +
+            'An ENA network plot is returned as an inline image.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                model_id:    { type: 'string', description: 'model_id from ena_fit or ena_compare_groups' },
+                type:        {
+                    type: 'string',
+                    enum: ['all', 'group', 'comparison', 'subtraction', 'unit'],
+                    description: 'Plot view (default: all)',
+                },
+                group_value: { type: 'string', description: 'Group value for type="group"' },
+                group1:      { type: 'string', description: 'First group for type="comparison" or "subtraction"' },
+                group2:      { type: 'string', description: 'Second group for type="comparison" or "subtraction"' },
+                unit_label:  { type: 'string', description: 'Unit label for type="unit"' },
+            },
+            required: ['model_id'],
+        },
+    },
+];
+
+// ── Server setup ──────────────────────────────────────────────────────────────
+
+const server = new Server(
+    { name: 'ena', version: '0.1.0' },
+    { capabilities: { tools: {} } }
+);
+
+let enaPromise = null;
+function getENA() {
+    if (!enaPromise) enaPromise = loadENA();
+    return enaPromise;
+}
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        let result;
+        if (name === 'ena_profile') {
+            result = toolProfile(args);
+        } else if (name === 'ena_inspect') {
+            result = toolInspect(args);
+        } else if (name === 'ena_plot') {
+            result = await toolPlot(args);
+        } else {
+            const ena = await getENA();
+            if      (name === 'ena_fit')            result = await toolFit(ena, args);
+            else if (name === 'ena_accumulate')      result = await toolAccumulate(ena, args);
+            else if (name === 'ena_compare_groups')  result = await toolCompareGroups(ena, args);
+            else throw new Error(`Unknown tool: ${name}`);
+        }
+
+        // Extract viz fields before stringifying so they never appear in the text block.
+        const { _vizData, _vizOpts, ...cleanResult } = result;
+
+        const content = [{ type: 'text', text: JSON.stringify(cleanResult, null, 2) }];
+
+        if (_vizData) {
+            let renderError = null;
+            try {
+                const svg = await renderSVG(_vizData, _vizOpts ?? {});
+                if (svg) {
+                    const png = new Resvg(svg, { fitTo: { mode: 'width', value: SVG_SIZE }, background: '#ffffff' }).render().asPng();
+                    content.unshift({
+                        type:     'image',
+                        data:     png.toString('base64'),
+                        mimeType: 'image/png',
+                    });
+                } else {
+                    renderError = 'renderSVG returned null (qe-graph svg_element not found — jsdom/qeviz may have failed silently)';
+                }
+            } catch (e) {
+                renderError = e.message;
+            }
+            if (renderError) {
+                process.stderr.write(`[ena-mcp] render failed: ${renderError}\n`);
+                // Surface the failure in the text block so it's visible in chat
+                const parsed = JSON.parse(content[0].text);
+                parsed._render_error = renderError;
+                content[0].text = JSON.stringify(parsed, null, 2);
+            }
+
+            // Also write an HTML file for clients that don't render inline images (e.g. Claude Code).
+            // This is additive — the image block above still works for clients that do (e.g. Claude Chat).
+            try {
+                const vizLabel = cleanResult.label ?? name;
+                const slug = [cleanResult.model_id, cleanResult.plot_type].filter(Boolean).join('_') || name;
+                const html = generateHTML(_vizData, vizLabel, _vizOpts ?? {});
+                const htmlPath = writeVizFile(html, slug);
+                const textBlock = content.find(c => c.type === 'text');
+                if (textBlock) {
+                    const parsed = JSON.parse(textBlock.text);
+                    parsed.interactive_plot = htmlPath;
+                    textBlock.text = JSON.stringify(parsed, null, 2);
+                }
+            } catch (e) {
+                process.stderr.write(`[ena-mcp] HTML write failed: ${e.message}\n`);
+            }
+        }
+
+        return { content };
+    } catch (err) {
+        return {
+            content: [{ type: 'text', text: `Error: ${err.message}` }],
+            isError: true,
+        };
+    }
+});
+
+// ── Start ─────────────────────────────────────────────────────────────────────
+
+const transport = new StdioServerTransport();
+await server.connect(transport);