@qe-mcp/ena 0.0.0-stage → 0.1.17

package/server.js

@@ -0,0 +1,3449 @@
+#!/usr/bin/env node
+/**
+ * ena-mcp-wasm — MCP server for Epistemic Network Analysis
+ *
+ * Zero-Python WASM backend using @qe-libs/rena-wasm.
+ * Tools:
+ *   ena_profile        — privacy-safe column metadata for a local CSV
+ *   ena_inspect        — triage tabular data for ENA suitability
+ *   ena_fit            — full pipeline; returns reusable model_id
+ *   ena_accumulate     — accumulation step only
+ *   ena_window         — window-size estimate (Cross-Covariance Decay)
+ *   ena_compare_groups — mean-rotation comparison of two groups; returns model_id
+ *   tma_fit            — directed TMA / ONA model (context tensor); returns model_id
+ *   tma_accumulate     — TMA / ONA accumulation step only
+ *   ena_plot           — render any view from a cached model_id
+ *   ena_export         — write a cached model as an ENA Web Tool project ZIP
+ *
+ * Defaults, plots and exports follow the ENA Web Tool (see webena.js), so a
+ * model fit here is the same model, drawn the same way, once imported there.
+ */
+
+import { readFileSync, mkdirSync, writeFileSync, statSync, existsSync } from 'fs';
+import { tmpdir } from 'os';
+import { createHash } from 'crypto';
+import { join, basename, dirname, extname } from 'path';
+import * as web from './webena.js';
+import { xlsxToCSV, isXlsx } from './xlsx.js';
+import { connectionWindows, viewerHtml } from './lines.js';
+import { defaultTensor } from '@qe-libs/rena-wasm/src/tensor.js';
+import { Server }               from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+    ListPromptsRequestSchema,
+    GetPromptRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import loadENA, { detectParams, isBinary } 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() {
+    // The bundle is inlined into pages and jsdom, so drop its source-map comment
+    // (the .map file is not next to the inlined copy).
+    if (!_qevizJS) _qevizJS = readFileSync(QEVIZ_BUNDLE, 'utf8')
+        .replace(/\n\/\/# sourceMappingURL=\S*\s*$/, '\n');
+    return _qevizJS;
+}
+
+// ── CSV parser ────────────────────────────────────────────────────────────────
+
+// RFC 4180: quoted fields may hold commas, doubled quotes and line breaks
+// (common in discourse text), so the text is scanned as a whole rather than
+// split into lines first. A UTF-8 BOM (Excel exports) is dropped so the first
+// header matches its column name.
+function parseCSV(text) {
+    if (text.charCodeAt(0) === 0xFEFF) text = text.slice(1);
+
+    const records = [];
+    let record = [], field = '', inQ = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inQ) {
+            if (ch === '"') {
+                if (text[i + 1] === '"') { field += '"'; i++; }
+                else inQ = false;
+            } else field += ch;
+        } else if (ch === '"') inQ = true;
+        else if (ch === ',') { record.push(field); field = ''; }
+        else if (ch === '\n' || ch === '\r') {
+            if (ch === '\r' && text[i + 1] === '\n') i++;
+            record.push(field); records.push(record);
+            record = []; field = '';
+        } else field += ch;
+    }
+    if (field !== '' || record.length) { record.push(field); records.push(record); }
+
+    // Blank lines (a lone empty field) are not rows.
+    const nonBlank = records.filter(r => r.length > 1 || r[0].trim() !== '');
+    if (!nonBlank.length) return [];
+    const headers = nonBlank[0].map(h => h.trim());
+    return nonBlank.slice(1).map(vals => {
+        const row = {};
+        headers.forEach((h, i) => { row[h] = vals[i] ?? ''; });
+        return row;
+    });
+}
+
+// CSV text of a data file: a .csv as is, an .xlsx's first worksheet (as the
+// ENA Web Tool reads one).
+function dataFileText(dataPath) {
+    if (/\.xls$/i.test(dataPath))
+        throw new Error('Old-format .xls files are not supported. Save the sheet as .xlsx or .csv.');
+    if (isXlsx(dataPath)) {
+        try { return xlsxToCSV(readFileSync(dataPath)); }
+        catch (e) { throw new Error(`Could not read ${basename(dataPath)} as an Excel workbook: ${e.message}`); }
+    }
+    return readFileSync(dataPath, 'utf8');
+}
+
+function loadData(dataPath, dataCsv) {
+    if (dataPath)  return parseCSV(dataFileText(dataPath));
+    if (dataCsv)   return parseCSV(dataCsv);
+    throw new Error('Provide either data_path (path to a .csv or .xlsx file) or data_csv (raw CSV string).');
+}
+
+const toArray = (v) => (Array.isArray(v) ? v : v == null ? [] : [v]);
+
+// ── Result helpers ────────────────────────────────────────────────────────────
+
+const R = (v, places = 6) => Math.round(v * 10 ** places) / 10 ** places;
+
+// stride: the row width of fa when it holds more columns than are reported.
+function toRecords(fa, nRows, nCols, labels, prefix = 'dim', stride = nCols) {
+    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 * stride + j]);
+        return rec;
+    });
+}
+
+// Share of total variance per dimension (= R's set$model$variance), or null
+// when the backend doesn't report it.
+function varianceExplained(model, dims) {
+    const v = model.variance;
+    if (!v?.length) return null;
+    return Object.fromEntries(Array.from({ length: Math.min(dims, v.length) },
+        (_, i) => [`dim${i + 1}`, R(v[i], 4)]));
+}
+
+// Goodness of fit per dimension: how well the distances between unit points
+// match the distances between their network centroids — Pearson r and Spearman
+// rho over all pairwise differences. Ported from the ENA Web Tool
+// (js/WasmWrapper.js, "correlations (Goodness of Fit)"), which flags < 0.9.
+// Both are unaffected by rescaling, so the raw points and centroids are used.
+const GOF_THRESHOLD = 0.9;
+
+// Dimensions every fit keeps, so ena_plot can put any of them on an axis — as
+// many as the ENA Web Tool computes (config/default.json sets.dimensions).
+const PLOT_DIMS = 6;
+function goodnessOfFit(model, dims) {
+    const pts = model.centroids, cts = model.networkCentroids, n = model.nUnits;
+    const stride = model.dims ?? dims;
+    if (!pts || !cts || n < 3) return null;
+    const ranks = (arr) => {
+        const s = arr.map((v, i) => ({ v, i })).sort((a, b) => a.v - b.v);
+        const r = new Float64Array(arr.length);
+        for (let i = 0; i < s.length;) {
+            let j = i;
+            while (j < s.length && s[j].v === s[i].v) j++;
+            for (let k = i; k < j; k++) r[s[k].i] = (i + 1 + j) / 2;
+            i = j;
+        }
+        return r;
+    };
+    const pearson = (x, y) => {
+        const m = x.length;
+        let sx = 0, sy = 0;
+        for (let i = 0; i < m; i++) { sx += x[i]; sy += y[i]; }
+        const mx = sx / m, my = sy / m;
+        let num = 0, dx2 = 0, dy2 = 0;
+        for (let i = 0; i < m; i++) {
+            const dx = x[i] - mx, dy = y[i] - my;
+            num += dx * dy; dx2 += dx * dx; dy2 += dy * dy;
+        }
+        const den = Math.sqrt(dx2 * dy2);
+        return den === 0 ? 0 : Math.max(-1, Math.min(1, num / den));
+    };
+    const out = {};
+    const nPairs = n * (n - 1) / 2;
+    for (let d = 0; d < Math.min(dims, stride); d++) {
+        const pd = new Float64Array(nPairs), cd = new Float64Array(nPairs);
+        let k = 0;
+        for (let i = 0; i < n - 1; i++)
+            for (let j = i + 1; j < n; j++, k++) {
+                pd[k] = pts[i * stride + d] - pts[j * stride + d];
+                cd[k] = cts[i * stride + d] - cts[j * stride + d];
+            }
+        out[`dim${d + 1}`] = { pearson: R(pearson(pd, cd), 4), spearman: R(pearson(ranks(Array.from(pd)), ranks(Array.from(cd))), 4) };
+    }
+    return out;
+}
+
+const fitLine = (gof) => gof
+    ? [`  Goodness of fit (Pearson / Spearman): ` +
+       Object.entries(gof).map(([d, g]) => `${d}=${g.pearson.toFixed(2)} / ${g.spearman.toFixed(2)}` +
+           (Math.min(g.pearson, g.spearman) < GOF_THRESHOLD ? ' ⚠ below 0.9' : '')).join(', ')]
+    : [];
+
+const varianceLine = (ve) => ve
+    ? [`  Variance explained: ${Object.entries(ve).map(([d, v]) => `${d}=${(v * 100).toFixed(1)}%`).join(', ')}`]
+    : [];
+
+// 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;
+}
+
+// ── Generalized means rotation (GMR) parameters ─────────────────────────────
+// Mirrors rENA's ena.rotate.by.generalized(): x_var / y_var name unit-level
+// metadata columns, the first being the target and the rest covariates that
+// libqe controls for via Lasso. The model matrix is R's
+// model.matrix(~ . or ~ .^2)[, -1]: numeric columns as-is, categorical ones
+// treatment-coded against the first sorted level, pairwise interactions
+// (first term varying fastest) when there are covariates and interactions=TRUE.
+
+const MISSING = /^(|na|nan|null)$/i;
+
+// One value per modeled unit, in unitLabels order.
+function unitLevelValues(rows, unitCols, unitLabels, col) {
+    if (!rows.length || !(col in rows[0]))
+        throw new Error(`Generalized rotation: column '${col}' is not in the data.`);
+    const vals = new Map(), varies = new Set();
+    for (const row of rows) {
+        const key = rowKey(row, unitCols);
+        const v   = String(row[col] ?? '').trim();
+        if (!vals.has(key))         vals.set(key, v);
+        else if (vals.get(key) !== v) varies.add(key);
+    }
+    const out = unitLabels.map(l => vals.get(l) ?? '');
+    const variesHere = unitLabels.filter(l => varies.has(l));
+    if (variesHere.length)
+        throw new Error(`Generalized rotation: '${col}' takes more than one value within ${variesHere.length} ` +
+            `of ${unitLabels.length} unit(s). x_var / y_var must be unit-level attributes — one value per unit.`);
+    const missing = unitLabels.filter((_, i) => MISSING.test(out[i]));
+    if (missing.length)
+        throw new Error(`Generalized rotation: '${col}' is missing for ${missing.length} of ${unitLabels.length} ` +
+            'unit(s). Exclude those units with units_used (their rows still count as context; the units list ' +
+            'in an ena_accumulate result gives the labels) or fill in the values. (rENA fails on missing values here too.)');
+    return out;
+}
+
+function designTerm(name, values) {
+    const nums = values.map(Number);
+    if (nums.every(Number.isFinite)) return { name, numeric: true, cols: [{ name, vals: nums }] };
+    const levels = [...new Set(values)].sort((a, b) => a.localeCompare(b));   // R's factor() order
+    return {
+        name, numeric: false, levels,
+        cols: levels.slice(1).map(l => ({ name: `${name}${l}`, vals: values.map(v => (v === l ? 1 : 0)) })),
+    };
+}
+
+function gmrAxis(rows, unitCols, unitLabels, vars, interactions, select2) {
+    const names  = Array.isArray(vars) ? vars : [vars];
+    const values = names.map(c => unitLevelValues(rows, unitCols, unitLabels, c));
+    const terms  = names.map((c, i) => designTerm(c, values[i]));
+
+    const cols = terms.flatMap(t => t.cols);
+    if (names.length > 1 && interactions)
+        for (let i = 0; i < terms.length; i++)
+            for (let j = i + 1; j < terms.length; j++)
+                for (const b of terms[j].cols)
+                    for (const a of terms[i].cols)
+                        cols.push({ name: `${a.name}:${b.name}`, vals: a.vals.map((v, r) => v * b.vals[r]) });
+
+    const n = unitLabels.length, p = cols.length;
+    const target = terms[0];
+    if (!target.cols.length)
+        throw new Error(`Generalized rotation: '${target.name}' has a single value across the modeled units.`);
+    const mm = new Float64Array(n * p);
+    for (let r = 0; r < n; r++)
+        for (let c = 0; c < p; c++) mm[r * p + c] = cols[c].vals[r];
+
+    // Target encoding: numeric as-is; categorical as 0-based codes in order of
+    // appearance, with the select_2_groups pair first (libqe uses codes 0 / 1).
+    let enc, nGroups = 0, subset = [];
+    if (target.numeric) {
+        if (select2) throw new Error(`select_2_groups needs a categorical target; '${target.name}' is numeric.`);
+        enc = target.cols[0].vals;
+    } else {
+        const seen = [...new Set(values[0])];
+        if (select2) {
+            if (select2.length !== 2) throw new Error('select_2_groups takes exactly two values.');
+            for (const g of select2)
+                if (!seen.includes(String(g)))
+                    throw new Error(`select_2_groups: no modeled unit has ${target.name}='${g}' ` +
+                        `(${target.name} has ${seen.length} distinct values; ena_profile lists them when there are 10 or fewer).`);
+        }
+        const pair   = select2?.map(String) ?? [];
+        const levels = [...pair, ...seen.filter(v => !pair.includes(v))];
+        enc     = values[0].map(v => levels.indexOf(v));
+        nGroups = levels.length;
+        if (select2) subset = values[0].flatMap((v, i) => (pair.includes(v) ? [i] : []));
+    }
+
+    return {
+        names, terms, nCols: p,
+        modelMatrix: mm,
+        target:      Float64Array.from(enc),
+        oneCols:     Int32Array.from(target.cols.map((_, i) => i)),   // target main effects come first
+        categorical: !target.numeric,
+        nGroups,
+        subset:      Int32Array.from(subset),
+    };
+}
+
+function buildGmrParams(rows, unitCols, unitLabels, p) {
+    if (!p.x_var || (Array.isArray(p.x_var) && !p.x_var.length))
+        throw new Error("rotation='generalized' requires x_var: the target column, optionally followed by covariate columns.");
+    const interactions = p.interactions ?? true;
+    const x = gmrAxis(rows, unitCols, unitLabels, p.x_var, interactions, p.select_2_groups ?? null);
+    const y = p.y_var ? gmrAxis(rows, unitCols, unitLabels, p.y_var, interactions, null) : null;
+    const n = unitLabels.length;
+
+    const gParams = {
+        xModelMatrix: x.modelMatrix, xmRows: n, xmCols: x.nCols,
+        xTarget: x.target, x1Cols: x.oneCols,
+        xCategorical: x.categorical, xNGroups: x.nGroups, xSubset: x.subset,
+        hasY: !!y,
+        ...(y && {
+            yModelMatrix: y.modelMatrix, ymRows: n, ymCols: y.nCols,
+            yTarget: y.target, y1Cols: y.oneCols,
+            yCategorical: y.categorical, yNGroups: y.nGroups,
+        }),
+    };
+
+    const describe = (a, axis) => {
+        const t = a.terms[0];
+        const kind = t.numeric ? 'numeric' : `categorical, ${t.levels.length} levels`;
+        const cov  = a.names.slice(1);
+        return `  ${axis} target: ${t.name} (${kind})` +
+            (cov.length ? `; controlling for ${cov.join(', ')}${interactions ? ' with pairwise interactions' : ''} (Lasso)` : '');
+    };
+    const lines = [
+        describe(x, 'GMR1'),
+        ...(p.select_2_groups ? [`  GMR1 fit on ${p.select_2_groups.join(' vs ')} (${x.subset.length} units)`] : []),
+        ...(y ? [describe(y, 'GMR2')] : []),
+    ];
+    return { gParams, lines };
+}
+
+// Rotation options for rena-wasm fit(), from the tool's rotation parameters.
+// rotation_from: project into another fitted model's space — the ENA Web
+// Tool's "Use Rotation Matrix From" (WasmWrapper._rotationSetFor), rena-wasm's
+// rotationSet (= R's rotation.set): centred on the source's centerVec, rotated
+// by its rotation matrix, with its node positions.
+function rotationSetFrom(sourceId, codes, ordered) {
+    const src = cacheGet(modelCache, sourceId);
+    if (!src)
+        throw new Error(`rotation_from: unknown model_id '${sourceId}'. Fit the source model first ` +
+            `(the ${MAX_MODELS} most recently used models are kept).`);
+    const m = src.model;
+    const srcOrdered = m.ordered === true;
+    if (srcOrdered !== ordered)
+        throw new Error(`rotation_from: model ${sourceId} is ${srcOrdered ? 'ordered (ONA/TMA)' : 'undirected (ENA)'}; ` +
+            `this model is ${ordered ? 'ordered' : 'undirected'}. Project only between models of the same kind, as the web tool does.`);
+    const same = src.codes.length === codes.length && [...src.codes].sort().every((c, i) => c === [...codes].sort()[i]);
+    if (!same)
+        throw new Error(`rotation_from: model ${sourceId} has codes ${src.codes.join(', ')}; this model needs the same codes.`);
+    if (!m.rotationMatrix || !m.centerVec)
+        throw new Error(`rotation_from: model ${sourceId} has no rotation to project into. Refit it with this server version.`);
+    return {
+        rotationSet: {
+            rotationMatrix: m.rotationMatrix, rotationCols: m.dims, nodes: m.positions, centerVec: m.centerVec,
+            codes: src.codes, columnNames: m.columnNames, eigenvalues: m.eigenvalues,
+        },
+    };
+}
+
+function rotationOpts(rows, unitCols, unitLabels, params, uMap) {
+    if (params.rotation_from != null) {
+        const ordered = params._ordered === true;
+        return { opts: rotationSetFrom(String(params.rotation_from), toArray(params.codes), ordered),
+                 lines: [`  Projected into model ${params.rotation_from}'s space (its rotation, centring and node positions)`] };
+    }
+    const { rotation = 'svd', group_col, group1_value, group2_value } = params;
+    if (params._web_gmr) {
+        // The web tool's rotation by groups (resolveDefaults): its own GMR.
+        const { col, pair } = params._web_gmr;
+        const g = web.gmrParams(rows, unitCols, unitLabels, col, pair);
+        return {
+            opts: { rotation: 'generalized', gParams: g.gParams },
+            lines: [`  GMR1 through ${pair.join(' vs ')} on ${col} (${g.subsetSize} units), as the ENA Web Tool rotates grouped units`],
+        };
+    }
+    if (rotation === 'svd') return { opts: { rotation: 'svd' }, lines: [] };
+    if (rotation === 'mean') {
+        if (!group_col || !group1_value || !group2_value)
+            throw new Error("rotation='mean' requires group_col, group1_value, and group2_value.");
+        const groupA = unitLabels.flatMap((lbl, i) => uMap.get(lbl) === String(group1_value) ? [i] : []);
+        const 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}`);
+        return { opts: { rotation: 'mean', groupA, groupB }, lines: [] };
+    }
+    if (rotation === 'generalized') {
+        const { gParams, lines } = buildGmrParams(rows, unitCols, unitLabels, params);
+        return { opts: { rotation: 'generalized', gParams }, lines };
+    }
+    throw new Error(`Unknown rotation '${rotation}'. Supported: svd, mean, generalized.`);
+}
+
+// A generalized rotation on two selected groups colours the plot and runs the
+// group tests on those groups, as a means rotation would, unless the caller
+// named its own groups.
+function withGmrGroups(params) {
+    if (params.rotation !== 'generalized' || !params.select_2_groups || params.group_col) return params;
+    const target = Array.isArray(params.x_var) ? params.x_var[0] : params.x_var;
+    return {
+        ...params,
+        group_col:    target,
+        group1_value: params.group1_value ?? String(params.select_2_groups[0]),
+        group2_value: params.group2_value ?? String(params.select_2_groups[1]),
+    };
+}
+
+// ── Column-role detection ─────────────────────────────────────────────────────
+// rena-wasm's detectParams: token-based name hints and nesting-aware unit /
+// conversation suggestions. It classes a column as metadata when its name has
+// an excluded token (text, time, content, pre, ...) before testing for 0/1
+// values, which drops codes such as "Content Knowledge". A multi-word binary
+// column is kept as a code here; single-word names ("Pre", "Post", "Time")
+// stay metadata, as those are usually indicator flags.
+
+const nameTokens = (s) =>
+    s.replace(/([a-z])([A-Z])/g, '$1 $2').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+
+function detectColumns(rows) {
+    const det = detectParams(rows);
+    for (const c of det.columns) {
+        if (c.role === 'metadata' && nameTokens(c.name).length > 1 && isBinary(rows, c.name))
+            c.role = 'code';
+    }
+    det.codes = det.columns.filter(c => c.role === 'code').map(c => c.name);
+    return det;
+}
+
+// ── qeviz viz helpers ─────────────────────────────────────────────────────────
+// Plots are built by webena.buildPlot as the ENA Web Tool's comparison plot:
+// { data (qeviz ModelData), layers ([tag, attrs] child elements of
+// <qe-graph>), attrs (<qe-graph> attributes), edgePx, title }.
+
+// Group values and titles come from the data and from tool arguments; escape
+// them before they go into markup (renderSVG parses it with scripts enabled).
+const escHtml = (v) => String(v).replace(/[&<>"']/g, ch =>
+    ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[ch]);
+
+// JSON inside <script>: escape '<' so a value such as "</script>" cannot close it.
+const scriptJSON = (v) => JSON.stringify(v).replace(/</g, '\\u003c');
+
+const attrString = (attrs) => Object.entries(attrs)
+    .filter(([, v]) => v != null)
+    .map(([k, v]) => (v === '' ? ` ${k}` : ` ${k}="${escHtml(v)}"`))
+    .join('');
+
+const layerMarkup = (layers) => layers.map(([tag, a]) => `<${tag}${attrString(a)}></${tag}>`).join('');
+
+// The web tool sizes edges in px: edge-width is a weight-1 edge as a fraction
+// of the plot's shorter side.
+const edgeWidth = (edgePx, viewPx) => String(Math.min(1, edgePx / viewPx));
+
+// The interactive plot: the same <qe-graph> as the SVG, plus a control bar
+// for the web tool's Plot Settings, applied live in the page (qeviz watches
+// its layer elements; interval and node-size changes reload the model data).
+function generateHTML(plot, title = plot.title) {
+    const hasNet = plot.layers.some(([t]) => t === 'qe-edges');
+    const hasPoints = plot.layers.some(([t]) => t === 'qe-points');
+    const groupRows = plot.data.groups?.data ?? [];
+    const hasCI = groupRows.some(r => r['x.low'] != null);
+    const hasOut = groupRows.some(r => r['x.olow'] != null);
+    const style = Object.fromEntries(plot.layers);
+    const textSize = Number(plot.attrs['label-font-size']) || 12;
+    const maxW = plot.maxWeight > 0 ? plot.maxWeight : 1;
+    const minW = Number(style['qe-edges']?.threshold) || 0;
+    const check = (id, label, on) =>
+        `<label><input type="checkbox" id="${id}"${on ? ' checked' : ''}> ${label}</label>`;
+    const range = (id, label, min, max, step, value) =>
+        `<label class="rng">${label} <input type="range" id="${id}" min="${min}" max="${max}" step="${step}" value="${value}"><output for="${id}"></output></label>`;
+    const controls = [
+        hasNet && range('minw', 'Min edge weight', 0, maxW, maxW / 100, minW),
+        hasNet && range('mag', 'Scale edges', 0.5, 5, 0.1, plot.scale ?? 1),
+        range('txt', 'Text size', 8, 32, 1, textSize),
+        hasNet && check('unconn', 'Unconnected codes', style['qe-nodes']?.unconnected !== 'hide'),
+        hasNet && check('codelab', 'Code labels', true),
+        hasPoints && check('pts', 'Unit points', true),
+        hasPoints && check('ptlab', 'Unit labels', false),
+        groupRows.length && check('grplab', 'Group labels', true),
+        hasCI && check('ci', 'Confidence intervals', groupRows.some(r => r.intervals === 'box')),
+        hasOut && check('out', 'Outlier boxes', groupRows.some(r => r.outlier)),
+    ].filter(Boolean).join('\n    ');
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${escHtml(title)}</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: system-ui, sans-serif; background: #f0f0f0; padding: 1rem; color: #333; }
+    h1 { font-size: 1rem; margin-bottom: .75rem; font-weight: 500; }
+    .controls { display: flex; flex-wrap: wrap; gap: .4rem 1.1rem; align-items: center; font-size: .8rem;
+                background: #fff; border: 1px solid #ddd; border-radius: 6px; padding: .55rem .75rem; margin-bottom: .6rem; }
+    .controls label { display: inline-flex; align-items: center; gap: .3rem; white-space: nowrap; cursor: pointer; }
+    .controls input[type=range] { width: 110px; }
+    .controls output { min-width: 2.6em; font-variant-numeric: tabular-nums; color: #666; }
+    .controls button { font: inherit; padding: .15rem .6rem; border: 1px solid #ccc; border-radius: 4px; background: #f7f7f7; cursor: pointer; }
+    .viz-wrap { background: #fff; border: 1px solid #ddd; border-radius: 6px; overflow: hidden; }
+    .provenance { margin-top: .5rem; font-size: .72rem; color: #777; }
+    qe-visual { display: block; width: 100%; height: 620px; }
+    qe-graph  { display: block; width: 100%; height: 100%; }
+  </style>
+</head>
+<body>
+<h1>${escHtml(title)}</h1>
+<div class="controls">
+    ${controls}
+    <button id="reset" type="button">Reset</button>
+</div>
+<div class="viz-wrap">
+  <qe-visual id="vis">
+    <qe-graph id="g" width="100%" height="620"${attrString(plot.attrs)}>
+      ${layerMarkup(plot.layers)}
+    </qe-graph>
+  </qe-visual>
+</div>
+<p class="provenance">Drawn by ${escHtml(PROVENANCE)}</p>
+<script>
+${qevizJS()}
+</script>
+<script>
+const base = ${scriptJSON(plot.data)};
+const EDGE_PX = ${plot.edgePx}, SCALE0 = ${plot.scale ?? 1}, SUBTRACT = ${!!plot.subtract};
+const TITLE = ${scriptJSON(String(title))};
+const vis = document.getElementById('vis');
+const graph = document.getElementById('g');
+const $ = id => document.getElementById(id);
+const layer = tag => graph.querySelector(tag);
+const pointsLayer = layer('qe-points');
+const viewPx = () => Math.min(graph.clientWidth || 620, graph.clientHeight || 620);
+const initial = {};
+document.querySelectorAll('.controls input').forEach(i => initial[i.id] = i.type === 'checkbox' ? i.checked : i.value);
+
+function setAttr(el, name, value) {
+  if (!el) return;
+  if (value == null) el.removeAttribute(name); else el.setAttribute(name, value);
+}
+function show(id) {
+  const i = $(id), o = i && i.parentNode.querySelector('output');
+  if (o) o.textContent = id === 'mag' ? Number(i.value).toFixed(1) + 'x' : id === 'txt' ? i.value : Number(i.value).toPrecision(2);
+}
+
+// Interval toggles and the node sizes ("Scale edges") change the model data.
+function update() {
+  const data = JSON.parse(JSON.stringify(base));
+  data.updated = Date.now();
+  const m = $('mag') ? Number($('mag').value) / SCALE0 : 1;
+  if (data.nodes && m !== 1)
+    data.nodes.data.forEach(r => { if (r.size != null) r.size = 2 * ((r.size / 2 - 1) * m + 1); });
+  if (data.groups)
+    data.groups.data.forEach(r => {
+      if ($('ci') && r['x.low'] != null) r.intervals = $('ci').checked ? 'box' : 'none';
+      if ($('out') && r['x.olow'] != null) r.outlier = $('out').checked;
+    });
+  graph.setAttribute('edge-width', String(Math.min(1, EDGE_PX * (SUBTRACT ? 1 : m) / viewPx())));
+  vis.setModelData(data);
+}
+
+function apply() {
+  document.querySelectorAll('.controls input[type=range]').forEach(i => show(i.id));
+  graph.querySelectorAll('qe-edges').forEach(e =>
+    setAttr(e, 'threshold', $('minw') && Number($('minw').value) > 0 ? $('minw').value : null));
+  if ($('unconn')) setAttr(layer('qe-nodes'), 'unconnected', $('unconn').checked ? null : 'hide');
+  if ($('codelab')) setAttr(layer('qe-nodes'), 'label', $('codelab').checked ? 'on' : 'off');
+  if ($('grplab')) setAttr(layer('qe-means'), 'label', $('grplab').checked ? 'on' : 'off');
+  if ($('ptlab')) setAttr(pointsLayer, 'label', $('ptlab').checked ? 'on' : 'auto');
+  if ($('pts')) {
+    if ($('pts').checked && !pointsLayer.isConnected) graph.appendChild(pointsLayer);
+    if (!$('pts').checked && pointsLayer.isConnected) pointsLayer.remove();
+  }
+  graph.setAttribute('label-font-size', $('txt').value);
+  if ($('mag')) {
+    const t = TITLE.replace(/\\(scaled [\\d.]+x\\)/, '(scaled ' + Number($('mag').value).toFixed(1) + 'x)');
+    document.querySelector('h1').textContent = t;
+    document.title = t;
+  }
+}
+
+document.querySelectorAll('.controls input').forEach(i => i.addEventListener('input', () => {
+  apply();
+  if (['mag', 'ci', 'out'].includes(i.id)) update();
+}));
+$('reset').addEventListener('click', () => {
+  document.querySelectorAll('.controls input').forEach(i => {
+    if (i.type === 'checkbox') i.checked = initial[i.id]; else i.value = initial[i.id];
+  });
+  apply();
+  update();
+});
+apply();
+update();
+// Render again once the plot has its size, and whenever it is resized: qeviz
+// measures the plot to size points and edges in px, and the first render (the
+// graph has no size until it has data) measures 0 and draws them at data scale.
+let pending = 0;
+new ResizeObserver(() => {
+  clearTimeout(pending);
+  pending = setTimeout(() => { if (graph.clientWidth > 0) update(); }, 30);
+}).observe(graph);
+</script>
+</body>
+</html>`;
+}
+
+// model_ids restart at m1 in every server process, so each process writes to
+// its own folder — otherwise concurrent clients (e.g. Claude Code and Claude
+// Desktop) overwrite each other's m1.svg.
+const VIZ_DIR = join(tmpdir(), 'ena-viz', String(process.pid));
+
+function writeVizFile(content, name, ext = 'html') {
+    const dir = VIZ_DIR;
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, `${name}.${ext}`);
+    writeFileSync(path, content);
+    return path;
+}
+
+// File name for a plot: model_id + plot_type + whatever selects the view
+// (group, unit, group pair), so e.g. the FirstGame and SecondGame group plots
+// don't both land on m1_group.svg and overwrite each other.
+function vizSlug(result, args = {}) {
+    const safe = s => String(s).replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+    const selectors = {
+        group:       [args.group_value],
+        unit:        [args.unit_label],
+        comparison:  [args.group1, args.group2],
+        subtraction: [args.group1, args.group2],
+    }[result.plot_type] ?? [];
+    return [result.model_id, result.plot_type, ...selectors]
+        .filter(v => v != null && v !== '')
+        .map(safe)
+        .filter(Boolean)
+        .join('_');
+}
+
+// ── jsdom SVG renderer ────────────────────────────────────────────────────────
+
+import { JSDOM } from 'jsdom';
+
+// PNG output (the inline image block and the png_plot file) prefers the native
+// @resvg/resvg-js, an OPTIONAL dependency: fastest, and it reads system fonts.
+// Where it is absent — the cross-platform .mcpb bundle, or a platform without a
+// prebuilt binary — @resvg/resvg-wasm renders the same image. It cannot see
+// system fonts, so plot labels are drawn with the bundled Inter (fonts/, OFL).
+// Loaded lazily; if neither loads, SVG and interactive HTML are still produced.
+let _Resvg;   // undefined = not yet attempted; null = unavailable
+async function getResvg() {
+    if (_Resvg !== undefined) return _Resvg;
+    try {
+        ({ Resvg: _Resvg } = await import('@resvg/resvg-js'));
+        return _Resvg;
+    } catch { /* fall back to WASM */ }
+    try {
+        const { initWasm, Resvg } = await import('@resvg/resvg-wasm');
+        await initWasm(readFileSync(_require.resolve('@resvg/resvg-wasm/index_bg.wasm')));
+        const fontBuffers = ['Inter-Regular.ttf', 'Inter-Bold.ttf']
+            .map(f => readFileSync(new URL(`./fonts/${f}`, import.meta.url)));
+        const font = { fontBuffers, defaultFontFamily: 'Inter', sansSerifFamily: 'Inter' };
+        // Same shape as the native class — new Resvg(svg, opts).render().asPng()
+        // — but asPng() gives a Uint8Array here, so hand back a Buffer as native does.
+        _Resvg = function WasmResvg(svg, opts = {}) {
+            const r = new Resvg(svg, { ...opts, font });
+            return { render: () => { const img = r.render(); return { asPng: () => Buffer.from(img.asPng()) }; } };
+        };
+    } catch (e) {
+        _Resvg = null;
+        process.stderr.write(
+            `[ena-mcp] no PNG renderer (${e.message}) — inline PNG and png_plot ` +
+            'disabled; svg_plot and interactive_plot are still produced.\n'
+        );
+    }
+    return _Resvg;
+}
+
+const SVG_SIZE = 600;
+
+async function renderSVG(plot) {
+    const dom = new JSDOM(
+        `<!DOCTYPE html><body><qe-visual id="vis"><qe-graph id="g" width="${SVG_SIZE}" height="${SVG_SIZE}"` +
+        `${attrString({ ...plot.attrs, 'edge-width': edgeWidth(plot.edgePx, SVG_SIZE) })}>${layerMarkup(plot.layers)}</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(plot.data);
+    await new Promise(r => setTimeout(r, 200));
+
+    const svgEl = window.document.getElementById('g')?.svg_element;
+    if (!svgEl) return null;
+
+    // XML serialization: outerHTML (HTML rules) leaves '<' unescaped inside
+    // attribute values, which resvg rejects when a label contains one.
+    let svgHtml = new window.XMLSerializer().serializeToString(svgEl);
+    // resvg requires the SVG namespace declaration to parse the document
+    if (!svgHtml.includes('xmlns=')) {
+        svgHtml = svgHtml.replace('<svg', '<svg xmlns="http://www.w3.org/2000/svg"');
+    }
+    return withProvenance(withWhiteBackground(withTitle(fitLabels(scaleFixedStrokes(svgHtml, SVG_SIZE)), plot.title)));
+}
+
+// qeviz draws some outlines at a fixed on-screen width with
+// vector-effect="non-scaling-stroke" (directed edges' 1 px outline, the
+// chevrons' white halo). resvg ignores vector-effect, so it read those widths
+// in viewBox units -- about 75 px each on a typical model -- and directed (TMA /
+// ONA) edges rasterised as fat capsules. Convert each to viewBox units for the
+// size the plot is rendered at, and drop the attribute.
+function scaleFixedStrokes(svgHtml, renderedPx) {
+    const vb = svgHtml.match(/<svg[^>]*\sviewBox\s*=\s*"([^"]+)"/)?.[1].trim().split(/\s+/).map(Number);
+    if (!vb || !(vb[2] > 0)) return svgHtml;
+    const unitsPerPx = vb[2] / renderedPx;
+    return svgHtml.replace(/<[a-zA-Z]+\b[^>]*\svector-effect="non-scaling-stroke"[^>]*>/g, tag =>
+        tag.replace(/\svector-effect="non-scaling-stroke"/, '')
+           .replace(/(\sstroke-width=")([-\d.eE]+)(")/, (_, a, w, b) => `${a}${Number(w) * unitsPerPx}${b}`));
+}
+
+// qeviz sizes the square viewBox to the node and point extent, so long node
+// labels at the left / right edge ("Performance Parameters") run past it and
+// are cut off in the SVG / PNG. Widen the viewBox to the labels' estimated
+// extent (average glyph ≈ 0.6 em); it only ever grows, and the plot itself
+// stays where it is.
+function fitLabels(svgHtml) {
+    const openTag = svgHtml.match(/<svg[^>]*>/)?.[0];
+    const vb = openTag?.match(/viewBox\s*=\s*"([^"]+)"/);
+    if (!vb) return svgHtml;
+    let [x0, y0, w, h] = vb[1].trim().split(/\s+/).map(Number);
+    if (![x0, y0, w, h].every(Number.isFinite)) return svgHtml;
+
+    let minX = x0, maxX = x0 + w, minY = y0, maxY = y0 + h;
+    for (const m of svgHtml.matchAll(/<text\b([^>]*)>([^<]*)</g)) {
+        const attr = (name) => m[1].match(new RegExp(`\\s${name}="([^"]*)"`))?.[1];
+        if (attr('display') === 'none') continue;
+        const x = Number(attr('x')), y = Number(attr('y')), fs = Number(attr('font-size'));
+        if (![x, y, fs].every(Number.isFinite)) continue;
+        const width  = m[2].length * fs * 0.6;
+        const anchor = attr('text-anchor') ?? 'start';
+        const left   = anchor === 'end' ? x - width : anchor === 'middle' ? x - width / 2 : x;
+        minX = Math.min(minX, left - fs * 0.5);
+        maxX = Math.max(maxX, left + width + fs * 0.5);
+        minY = Math.min(minY, y - fs * 1.2);
+        maxY = Math.max(maxY, y + fs * 0.5);
+    }
+    if (minX === x0 && maxX === x0 + w && minY === y0 && maxY === y0 + h) return svgHtml;
+    const fitted = `${minX} ${minY} ${maxX - minX} ${maxY - minY}`;
+    return svgHtml.replace(openTag, openTag.replace(vb[0], `viewBox="${fitted}"`));
+}
+
+// The web tool names the comparison plot above it ("FirstGame – SecondGame
+// (scaled 1.0x)"). Add that title in a band over the top of the viewBox.
+// Invisible provenance in the SVG (and its <desc>), so the file says what drew it.
+function withProvenance(svgHtml) {
+    const openTag = svgHtml.match(/<svg[^>]*>/)?.[0];
+    if (!openTag) return svgHtml;
+    return svgHtml.replace(openTag, `${openTag}<desc>ENA plot drawn by ${escHtml(PROVENANCE)}</desc>`);
+}
+
+function withTitle(svgHtml, title) {
+    if (!title) return svgHtml;
+    const openTag = svgHtml.match(/<svg[^>]*>/)?.[0];
+    const vb = openTag?.match(/viewBox\s*=\s*"([^"]+)"/);
+    if (!vb) return svgHtml;
+    const [x0, y0, w, h] = vb[1].trim().split(/\s+/).map(Number);
+    if (![x0, y0, w, h].every(Number.isFinite)) return svgHtml;
+    const fs = Math.max(w, h) * 0.028, band = fs * 2.2;
+    const fitted = `${x0} ${y0 - band} ${w} ${h + band}`;
+    const text = `<text x="${x0 + fs * 0.6}" y="${y0 - band + fs * 1.4}" font-size="${fs}" ` +
+        `font-family="arial, sans-serif" fill="#444444">${escHtml(title)}</text>`;
+    return svgHtml.replace(openTag, openTag.replace(vb[0], `viewBox="${fitted}"`) + text);
+}
+
+// The qeviz SVG has a transparent background, which makes the plot invisible in
+// dark-mode viewers. Insert an opaque white rect as the first child (behind all
+// content), sized to the SVG's viewBox so it covers the full canvas.
+function withWhiteBackground(svgHtml) {
+    const openTagMatch = svgHtml.match(/<svg[^>]*>/);
+    if (!openTagMatch) return svgHtml;
+    const openTag = openTagMatch[0];
+
+    const vb = openTag.match(/viewBox\s*=\s*["']\s*([-\d.]+)\s+([-\d.]+)\s+([-\d.]+)\s+([-\d.]+)\s*["']/);
+    const rect = vb
+        ? `<rect x="${vb[1]}" y="${vb[2]}" width="${vb[3]}" height="${vb[4]}" fill="#ffffff"/>`
+        : `<rect x="0" y="0" width="100%" height="100%" fill="#ffffff"/>`;
+
+    return svgHtml.replace(openTag, openTag + rect);
+}
+
+// ── 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;
+
+// Bounded LRU caches: accumulations hold the parsed rows, so keep only a few;
+// models are small but would otherwise grow for the life of the server.
+const MAX_ACCUM  = 8;
+const MAX_MODELS = 50;
+
+function cacheGet(map, key) {
+    if (!map.has(key)) return undefined;
+    const v = map.get(key);
+    map.delete(key); map.set(key, v);   // most recently used last
+    return v;
+}
+
+function cacheSet(map, key, value, max) {
+    map.delete(key); map.set(key, value);
+    while (map.size > max) map.delete(map.keys().next().value);
+}
+
+// Identifies the input data. For a file, include its mtime and size so an
+// edited CSV is re-read instead of serving a model fitted on the old contents.
+function dataStamp(p) {
+    if (p.data_path) {
+        const st = statSync(p.data_path);
+        return `${p.data_path}@${st.mtimeMs}:${st.size}`;
+    }
+    // Hash pasted CSV so the cache keys don't hold a copy of the whole dataset.
+    return 'csv:' + createHash('sha1').update(p.data_csv ?? '').digest('hex');
+}
+
+function accumCacheKey(p) {
+    return JSON.stringify({
+        data:          dataStamp(p),
+        units:         p.units,
+        conversations: p.conversations,
+        codes:         p.codes,   // order matters: it fixes the connection order
+        window_size:   p.window_size  ?? 4,
+        binary:        p.binary       ?? true,
+        weight_model:  p.weight_model ?? null,
+        units_used:    p.units_used   ?? null,
+        mask_connections: p.mask_connections ?? null,
+        exclude_conversations: p.exclude_conversations ?? null,
+        order_by:      p.order_by ?? null,
+    });
+}
+
+// kind keeps tools apart: ena_fit and ena_compare_groups can fit the same
+// model but return different results.
+function fitCacheKey(p, kind = 'fit') {
+    return JSON.stringify({
+        kind,
+        data:          dataStamp(p),
+        units:         p.units,
+        conversations: p.conversations,
+        codes:         [...p.codes].sort(),
+        window_size:   p.window_size  ?? 4,
+        binary:        p.binary       ?? true,
+        dims:          p.dims         ?? 2,
+        rotation:      p.rotation     ?? 'svd',
+        group_col:     p.group_col    ?? null,
+        group1_value:  p.group1_value ?? null,
+        group2_value:  p.group2_value ?? null,
+        weight_model:  p.weight_model ?? null,
+        units_used:    p.units_used   ?? null,
+        mask_connections: p.mask_connections ?? null,
+        exclude_conversations: p.exclude_conversations ?? null,
+        order_by:      p.order_by ?? null,
+        sphere_norm:   p.sphere_norm  ?? true,
+        center_align_to_origin: p.center_align_to_origin ?? true,
+        x_var:           p.x_var           ?? null,
+        y_var:           p.y_var           ?? null,
+        select_2_groups: p.select_2_groups ?? null,
+        interactions:    p.interactions    ?? true,
+        web_gmr:         p._web_gmr        ?? null,
+        rotation_from:   p.rotation_from   ?? null,
+    });
+}
+
+// Accumulation options shared by every tool (rena-wasm accumulate() and fit()).
+// units_used must reach accumulate() too, so its unitLabels match the fit's.
+function accumOpts(p, ordered = false) {
+    const codeMask = codeMaskOf(p, ordered);
+    return {
+        ...(p.weight_model      && { weightModel: p.weight_model }),
+        ...(p.units_used?.length && { unitsUsed: p.units_used }),
+        ...(codeMask && { codeMask }),
+    };
+}
+
+// mask_connections → rena-wasm's codeMask: an nCodes × nCodes 0/1 matrix over
+// the model's codes (the ENA Web Tool's Code Masking Matrix, settings.model
+// codeMask / codeMaskLabels). Unordered: "A & B" drops the pair either way
+// round. Ordered: "A & B" drops A → B only (mask[from][to]).
+function codeMaskOf(p, ordered) {
+    const names = toArray(p.mask_connections);
+    if (!names.length) return null;
+    const codes = toArray(p.codes);
+    const at = new Map(codes.map((c, i) => [c, i]));
+    const mask = codes.map(() => codes.map(() => 1));
+    for (const name of names) {
+        const parts = String(name).split(' & ');
+        const [a, b] = parts.map(x => at.get(x));
+        if (parts.length !== 2 || a === undefined || b === undefined)
+            throw new Error(`mask_connections: ${name} must name two of the model's codes as A & B (codes: ${codes.join(', ')}).`);
+        if (a === b && !ordered)
+            throw new Error(`mask_connections: ${name} — an undirected model has no self-connections.`);
+        mask[a][b] = 0;
+        if (!ordered) mask[b][a] = 0;
+    }
+    return mask;
+}
+
+// Is connection "A & B" (as the model names it) masked? Unordered either way round.
+function isMasked(p, ordered, connName) {
+    const names = new Set(toArray(p.mask_connections));
+    if (names.has(connName)) return true;
+    if (ordered) return false;
+    const [a, b] = connName.split(' & ');
+    return names.has(`${b} & ${a}`);
+}
+
+// Fit-only options on top of accumOpts.
+function fitOpts(p, ordered = false) {
+    return {
+        ...accumOpts(p, ordered),
+        sphereNorm:          p.sphere_norm            ?? true,
+        centerAlignToOrigin: p.center_align_to_origin ?? true,
+    };
+}
+
+// JSON has no Infinity, so an infinite window (= rENA window.size.back = Inf)
+// arrives as the string "Inf".
+function windowValue(w) {
+    if (typeof w === 'string') {
+        if (/^(inf|infinity)$/i.test(w.trim())) return Infinity;
+        const n = Number(w);
+        if (Number.isFinite(n)) return n;
+        throw new Error(`window_size must be a number or "Inf", got '${w}'`);
+    }
+    return w;
+}
+
+// TMA-only options: flexible horizons (= tma contexts() with HOO rules).
+// hoo_flexible was never read by rena-wasm, so reject it rather than ignore it.
+function tmaOpts(p) {
+    if (p.hoo_flexible)
+        throw new Error('hoo_flexible is no longer supported (it had no effect). Use horizons: ' +
+            '{ by: <column>, rules: { <value>: [<columns>], ... } } for flexible horizons of observation.');
+    const h = p.horizons;
+    if (!h) return {};
+    if (typeof h.by !== 'string' || !h.rules || typeof h.rules !== 'object' || Array.isArray(h.rules))
+        throw new Error('horizons must be { by: <column>, rules: { <value of by>: [<columns>], ... } }.');
+    return { horizons: h };
+}
+
+// Summary lines for the non-default options, so the model's setup is visible.
+function optsLines(p, nUnits) {
+    return [
+        ...(p.weight_model       ? [`  Weight model: ${p.weight_model}`] : []),
+        ...(p.units_used?.length ? [`  Units modeled: ${nUnits} of ${p.units_used.length} listed (other units' rows kept as context)`] : []),
+        ...(p.sphere_norm === false ? ['  Sphere normalization: off (networks scaled by the longest)'] : []),
+        ...(p.center_align_to_origin === false ? ['  Centering: on every unit, including zero-network units'] : []),
+        ...(toArray(p.mask_connections).length ? [`  Masked connections: ${toArray(p.mask_connections).join(', ')}`] : []),
+        ...(toArray(p.exclude_conversations).length ? [`  Excluded conversations: ${toArray(p.exclude_conversations).join(', ')} (their lines removed)`] : []),
+        ...(p.order_by ? [`  Lines ordered by ${p.order_by}`] : []),
+        ...(p.horizons ? [`  Horizons: by ${p.horizons.by} — ` +
+            Object.entries(p.horizons.rules).map(([v, cols]) => `${v}: ${[].concat(cols).join(' + ')}`).join('; ')] : []),
+    ];
+}
+
+function nextModelId() { return `m${++modelSeq}`; }
+
+// ── Web tool defaults ─────────────────────────────────────────────────────────
+
+// Parsed rows by input, so resolving defaults and accumulating parse once.
+const rowsCache = new Map();
+const MAX_ROWS  = 4;
+function loadRows(p) {
+    const key = dataStamp(p);
+    let rows;
+    if (rowsCache.has(key)) rows = cacheGet(rowsCache, key);
+    else { rows = loadData(p.data_path, p.data_csv); cacheSet(rowsCache, key, rows, MAX_ROWS); }
+    if (!toArray(p.exclude_conversations).length && !p.order_by) return rows;
+
+    const vKey = JSON.stringify([key, toArray(p.conversations), toArray(p.exclude_conversations), p.order_by ?? null]);
+    if (rowsCache.has(vKey)) return cacheGet(rowsCache, vKey);
+    const view = prepareRows(rows, p);
+    cacheSet(rowsCache, vKey, view, MAX_ROWS);
+    return view;
+}
+
+// Missing values (rENA-api / R: NA, data.table sorts them first).
+const isMissing = (v) => v == null || /^\s*(|NA|NaN|#N\/A)\s*$/.test(String(v));
+
+// exclude_conversations and order_by, as the ENA Web Tool's former R backend
+// applied them (rENA-api ena.generate: conversations.used, then
+// data.table::setorderv(file, order)). Excluded conversations' rows are
+// dropped before anything else — they are neither lines nor context. order_by
+// sorts every row by that column, ascending and stable (ties keep file order,
+// missing first; numeric when every value is a number, else C-locale text),
+// which orders the lines within each conversation. The result keeps each row's
+// position in the file as rows.fileRow, so row numbers still refer to the file.
+function prepareRows(rows, p) {
+    const convoCols = toArray(p.conversations);
+    const allCols = rows.length ? Object.keys(rows[0]) : [];
+    let idx = rows.map((_, i) => i);
+
+    const excl = toArray(p.exclude_conversations).map(String);
+    if (excl.length) {
+        if (!convoCols.length) throw new Error('exclude_conversations needs conversations.');
+        const keyOf = (r) => convoCols.map(c => String(r[c])).join('::');
+        const known = new Set(rows.map(keyOf));
+        const want = new Set(excl.map(e => e.split('__').join('::')));
+        for (const e of want)
+            if (!known.has(e))
+                throw new Error(`exclude_conversations: no conversation ${e}. Conversations are named by their ` +
+                    `${convoCols.join(' + ')} values joined by ::, e.g. ${[...known][0]}.`);
+        idx = idx.filter(i => !want.has(keyOf(rows[i])));
+        if (!idx.length) throw new Error('exclude_conversations leaves no rows.');
+    }
+
+    if (p.order_by) {
+        const col = String(p.order_by);
+        if (!allCols.includes(col)) throw new Error(`order_by: column ${col} is not in the data.`);
+        const vals = idx.map(i => rows[i][col]);
+        const numeric = vals.every(v => isMissing(v) || Number.isFinite(Number(v)));
+        const key = (v) => (isMissing(v) ? null : numeric ? Number(v) : String(v));
+        const decorated = idx.map((i, pos) => ({ i, pos, k: key(rows[i][col]) }));
+        decorated.sort((a, b) => {
+            if (a.k === null || b.k === null) return a.k === b.k ? a.pos - b.pos : (a.k === null ? -1 : 1);
+            if (a.k < b.k) return -1;
+            if (a.k > b.k) return 1;
+            return a.pos - b.pos;
+        });
+        idx = decorated.map(d => d.i);
+    }
+
+    const view = idx.map(i => rows[i]);
+    Object.defineProperty(view, 'fileRow', { value: Int32Array.from(idx), enumerable: false });
+    return view;
+}
+
+// A row's position in the data file (0-based), through exclude_conversations / order_by.
+const fileRowOf = (rows, i) => (rows.fileRow ? rows.fileRow[i] : i);
+
+/**
+ * Fill in what a call leaves out as the ENA Web Tool does for a new set:
+ *   window    the Cross-Covariance Decay estimate (line windows only)
+ *   rotation  with two or more groups in the first unit column, its GMR
+ *             through the first two (or group1/group2, when named on that column)
+ *   groups    units are grouped (and coloured) by the first unit column,
+ *             unless group_col names another column
+ * kind: 'fit' | 'compare' | 'accumulate' (window only). ena_compare_groups
+ * always takes the web tool's GMR through its two groups.
+ */
+function resolveDefaults(ena, params, kind = 'fit') {
+    const p = { ...params };
+    const unitCols = toArray(p.units), convoCols = toArray(p.conversations);
+    const rows = loadRows(p);
+    if (p.window_size == null && (p.window_type ?? 'lines') === 'lines') {
+        let w = null;
+        try { w = ena.ccdWindow(rows, { codes: p.codes, conversations: convoCols, ...web.CCD_OPTS }); }
+        catch { /* too little data for an estimate: the fallback below */ }
+        p.window_size = Number.isFinite(w) && w > 0 ? w : web.FALLBACK_WINDOW;
+        p._window_auto = true;
+    }
+    if (kind === 'accumulate') return p;
+
+    const groups = web.unitGroups(rows, unitCols);
+    if (kind === 'compare') {
+        p.rotation = 'generalized';
+        p._web_gmr = { col: p.group_col, pair: [String(p.group1_value), String(p.group2_value)] };
+    } else if (p.rotation_from != null) {
+        p.rotation = 'projected';               // rotation_from replaces any rotation
+    } else if (p.rotation == null) {
+        const def = web.defaultRotation(groups);
+        if (def) {
+            const named = p.group_col === def.col && p.group1_value != null && p.group2_value != null;
+            const pair  = named ? [String(p.group1_value), String(p.group2_value)] : def.pair;
+            p.rotation = 'generalized';
+            p._web_gmr = { col: def.col, pair };
+            if (!p.group_col) Object.assign(p, { group_col: def.col, group1_value: pair[0], group2_value: pair[1] });
+        } else {
+            p.rotation = 'svd';
+        }
+    }
+    if (!p.group_col && !groups.wrapper) p.group_col = groups.col;
+    return p;
+}
+
+const windowLine = (p) => `  Window: back=${p.window_size}` +
+    (p._window_auto ? ' (Cross-Covariance Decay estimate — the web tool\'s default for a new set)' : '');
+
+const rotationLabel = (p) => p.rotation_from != null ? `projected into model ${p.rotation_from}'s space`
+    : p._web_gmr ? 'generalized (GMR, the web tool\'s rotation for grouped units)' : p.rotation;
+
+// Plot groups: group_col's values in the web tool's order, or one group of
+// every unit for a single unit column (the web tool's wrapper group).
+function plotGroups(rows, unitCols, unitLabels, groupCol) {
+    if (groupCol) {
+        const uMap = buildUnitGroupMap(rows, unitCols, groupCol);
+        return { names: web.groupOrder(rows, groupCol), members: (i) => uMap.get(unitLabels[i]), uMap };
+    }
+    const name = unitCols.length === 1 ? unitCols[0] : 'All units';
+    return { names: [name], members: () => name, uMap: null };
+}
+
+// What the plots and the export need, computed as the web tool does.
+function webEntry(ena, model, unitLabels, rows, unitCols, p) {
+    const pg = plotGroups(rows, unitCols, unitLabels, p.group_col ?? null);
+    return {
+        web:      web.webSet(ena, model, unitLabels, pg.names, pg.members),
+        dimNames: model.columnNames ? Array.from(model.columnNames) : null,
+        variance: model.variance ? Array.from(model.variance) : null,
+    };
+}
+
+// The plot a fit returns, and the one an exported set opens with: the two
+// named groups as first − second, else the first group's mean network.
+function defaultView(p, w) {
+    const g1 = p.group1_value != null ? String(p.group1_value) : null;
+    const g2 = p.group2_value != null ? String(p.group2_value) : null;
+    if (g1 && g2 && w.byName.has(g1) && w.byName.has(g2))
+        return { first: { kind: 'group', name: g1 }, second: { kind: 'group', name: g2 } };
+    const g = w.groups.find(x => x.n > 0);
+    return g ? { first: { kind: 'group', name: g.name } } : { first: { kind: 'all' } };
+}
+
+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;
+}
+
+// Per-dimension two-group tests on the projected unit points, computed by
+// libqe::group_stats (rena-wasm compareGroups). Values are passed through as
+// libqe reports them: the Mann-Whitney p uses the normal approximation with
+// continuity correction, and effect_r = 1 − 2U/(n1·n2) (negative when group 1
+// tends higher).
+const P = (v) => Number(v.toPrecision(4));   // p-values: significant figures, not places
+
+function groupStats(ena, points, dims, g1Idx, g2Idx, group1, group2, stride = dims) {
+    const pick = (idx) => Float64Array.from(
+        idx.flatMap(i => Array.from({ length: dims }, (_, j) => points[i * stride + j])));
+    const s = ena.compareGroups(pick(g1Idx), g1Idx.length, pick(g2Idx), g2Idx.length, dims);
+
+    // means/sds/medians are row-major {data, rows: 2 groups, cols: dims}
+    const cell = (m, g, d) => m.data[g * m.cols + d];
+    const dimensions = Array.from({ length: dims }, (_, d) => ({
+        dim: `dim${d + 1}`,
+        group1: { name: group1, n: s.n1, mean: R(cell(s.means, 0, d)), sd: R(cell(s.sds, 0, d)), median: R(cell(s.medians, 0, d)) },
+        group2: { name: group2, n: s.n2, mean: R(cell(s.means, 1, d)), sd: R(cell(s.sds, 1, d)), median: R(cell(s.medians, 1, d)) },
+        welch_t:      { t: R(s.t[d], 4), df: R(s.df[d], 2), p: P(s.pvalue_t[d]), cohens_d: R(s.cohens_d[d], 4) },
+        mann_whitney: { U: s.U[d], p: P(s.pvalue_u[d]), effect_r: R(s.effect_r[d], 4) },
+    }));
+
+    const lines = [
+        `Group tests (${group1} n=${s.n1} vs ${group2} n=${s.n2}):`,
+        ...dimensions.map(x =>
+            `  ${x.dim}: Welch t(${x.welch_t.df})=${x.welch_t.t}, p=${x.welch_t.p}, d=${x.welch_t.cohens_d}` +
+            `   Mann-Whitney U=${x.mann_whitney.U}, p=${x.mann_whitney.p}, r=${x.mann_whitney.effect_r}`),
+        '  (Mann-Whitney p: normal approximation with continuity correction; r = 1 − 2U/(n1·n2), negative when group 1 is higher.' +
+            ' Under rotation=mean, dim1 is constructed to separate these groups.)',
+    ];
+
+    return {
+        stats: {
+            method: 'libqe group_stats: Welch two-sample t-test; Mann-Whitney U (normal approximation, ' +
+                'continuity correction); effect_r = 1 − 2U/(n1·n2), negative when group 1 tends higher',
+            dimensions,
+        },
+        lines,
+    };
+}
+
+function buildContextTensor(rows, params) {
+    const {
+        stanza_ground = [],
+        stanza_response = [],
+        stanza_modality = [],
+        window_type = 'lines',
+        time_column = null,
+        time_unit = null,
+        stanza_overrides = null,
+    } = params;
+    const window_size = windowValue(params.window_size ?? 4);
+
+    const stanzaModality = Array.isArray(stanza_modality)
+        ? stanza_modality
+        : (stanza_modality ? [stanza_modality] : []);
+    const stanzaGround = Array.isArray(stanza_ground) ? stanza_ground : [stanza_ground];
+    const stanzaResponse = Array.isArray(stanza_response) ? stanza_response : [stanza_response];
+
+    const ml = stanzaModality.length;
+    const gl = stanzaGround.length;
+    const rl = stanzaResponse.length;
+
+    // Axis order: [mode..., ground..., response...]
+    const factors      = [...stanzaModality, ...stanzaGround, ...stanzaResponse];
+    const dimsSender   = Array.from({ length: gl }, (_, i) => ml + i);
+    const dimsReceiver = Array.from({ length: rl }, (_, i) => ml + gl + i);
+    const dimsMode     = Array.from({ length: ml }, (_, i) => i);
+
+    // infer unique values per factor from the full dataset
+    const factorLevels = {};
+    for (const col of factors) {
+        factorLevels[col] = {};
+        let idx = 0;
+        for (const row of rows) {
+            const v = row[col];
+            if (v != null && v !== '' && !(v in factorLevels[col])) {
+                factorLevels[col][v] = idx++;
+            }
+        }
+    }
+
+    // tensor shape & flat data array
+    const dimsShape     = factors.map(col => Math.max(1, Object.keys(factorLevels[col]).length));
+    const dims          = [...dimsShape, 2];
+    const nCombinations = dimsShape.reduce((a, b) => a * b, 1);
+    const data          = new Float64Array(nCombinations * 2);
+
+    // Default: every combination -> weight=1, window=stanzaSize (window_size)
+    for (let c = 0; c < nCombinations; c++) {
+        data[c]                 = 1;
+        data[c + nCombinations] = window_size;
+    }
+
+    // apply overrides if flat array
+    if (stanza_overrides && Array.isArray(stanza_overrides)) {
+        for (const ov of stanza_overrides) {
+            if (!ov.path) continue;
+            const w    = parseFloat(ov.weight ?? 1);
+            const win  = windowValue(ov.window ?? window_size);
+
+            // A wrong path must not fall back to some other combination.
+            const order = factors.join(', ');
+            if (!factors.length)
+                throw new Error('stanza_overrides needs stanza_modality, stanza_ground or stanza_response columns to override.');
+            if (ov.path.length !== factors.length)
+                throw new Error(`stanza_overrides path ${JSON.stringify(ov.path)} has ${ov.path.length} value(s); ` +
+                    `it needs one per factor, in this order: ${order} (modality, then ground, then response).`);
+
+            // Column-major flat index into data
+            let c = 0, stride = 1;
+            for (let f = 0; f < factors.length; f++) {
+                const val  = ov.path[f];
+                const fIdx = factorLevels[factors[f]][val];
+                if (fIdx === undefined)
+                    throw new Error(`stanza_overrides path ${JSON.stringify(ov.path)}: '${val}' is not a value of ` +
+                        `${factors[f]} (position ${f + 1} of ${order}). ${factors[f]} has ` +
+                        `${Object.keys(factorLevels[factors[f]]).length} distinct values; ena_profile lists them when there are 10 or fewer.`);
+                c += fIdx * stride;
+                stride *= dimsShape[f];
+            }
+            data[c]                 = w;
+            data[c + nCombinations] = win;
+        }
+    }
+
+    const tensorDef = { dims, dimsSender, dimsReceiver, dimsMode, factors, factorLevels, data };
+    if ((window_type === 'time' || window_type === 'time_duration') && time_column) {
+        tensorDef.timesCol = time_column;
+        if (time_unit) tensorDef.timeUnit = time_unit;
+    }
+
+    return tensorDef;
+}
+
+async function toolTmaFit(ena, params) {
+    params = resolveDefaults(ena, withGmrGroups(params), 'fit');
+    const {
+        units, conversations, codes,
+        window_size = 4, window_type = 'lines', time_column = null,
+        stanza_overrides = null,
+        ordered = true, dims: requestedDims = 2, rotation,
+        group_col, group1_value, group2_value,
+    } = params;
+
+    const unitCols  = toArray(units);
+    const convoCols = toArray(conversations);
+
+    // Load data and build tensor definition
+    const rows = loadRows(params);
+    const tensorDef = buildContextTensor(rows, params);
+
+    const acc = ena.accumulate(rows, {
+        codes, units: unitCols, conversations: convoCols,
+        ordered, tensor: tensorDef, ...tmaOpts(params), ...accumOpts(params, ordered),
+    });
+    const { unitLabels, nConnections, nUnits } = acc;
+
+    let uMap;
+    if (group_col) uMap = buildUnitGroupMap(rows, unitCols, group_col);
+    const rot = rotationOpts(rows, unitCols, unitLabels, { ...params, _ordered: ordered }, uMap);
+
+    const fitArgs = {
+        codes, units: unitCols, conversations: convoCols,
+        dims: Math.max(requestedDims, PLOT_DIMS), ...rot.opts,
+        ordered, tensor: tensorDef, ...tmaOpts(params), ...fitOpts(params, ordered),
+    };
+    const rawModel = ena.fit(rows, fitArgs);
+
+    const model = adaptModel(rawModel);
+    // Fits keep PLOT_DIMS dimensions for ena_plot's axis choice; results report
+    // the requested ones. rena-wasm caps both at the rotation's columns.
+    const stride = model.dims ?? requestedDims;
+    const dims   = Math.min(requestedDims, stride);
+
+    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(model.networks, model.nConnections, idx);
+        }
+    }
+
+    const dimCols    = Array.from({ length: dims }, (_, i) => `dim${i + 1}`);
+    const variance   = varianceExplained(model, dims);
+    const fit        = goodnessOfFit(model, dims);
+    const centroids  = toRecords(model.centroids, model.nUnits, dims, model.unitLabels, 'dim', stride);
+    const nodePos    = toRecords(model.positions, codes.length, dims, codes, 'dim', stride);
+
+    // Group tests whenever two groups are named, whatever the rotation.
+    let tests = null;
+    if (groupMap && group1_value && group2_value) {
+        const idxOf = (gv) => unitLabels.flatMap((lbl, i) => groupMap.get(lbl) === String(gv) ? [i] : []);
+        const [i1, i2] = [idxOf(group1_value), idxOf(group2_value)];
+        if (i1.length && i2.length)
+            tests = groupStats(ena, model.centroids, dims, i1, i2, String(group1_value), String(group2_value), stride);
+    }
+
+    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 = [
+        `TMA model fitted.  model_id: ${model_id}`,
+        `  Units: ${model.nUnits}   Codes: ${codes.length}   Connections: ${model.nConnections}   Dims: ${dims}`,
+        `  Rotation: ${rotationLabel(params)}` + (rotation === 'generalized' ? `   Axes: ${model.columnNames?.slice(0, dims).join(', ')}` : ''),
+        ...rot.lines,
+        ...varianceLine(variance),
+        ...fitLine(fit),
+        `  Window: type=${window_type}, size=${window_size}${params._window_auto ? ' (Cross-Covariance Decay estimate)' : ''}, ordered=${ordered}`,
+        ...optsLines(params, model.nUnits),
+        '',
+        `Node positions (${dimCols.join(', ')}):`,
+        ...nodeLines,
+        ...(tests ? ['', ...tests.lines] : []),
+        '',
+        `Use ena_plot with model_id="${model_id}" for additional views (group, unit, subtraction, comparison).`,
+    ].join('\n');
+
+    const result = {
+        model_id,
+        centroids,
+        node_positions:   nodePos,
+        connection_names: model.connectionNames,
+        units:            model.unitLabels,
+        codes,
+        n_units:          model.nUnits,
+        n_codes:          codes.length,
+        n_connections:    model.nConnections,
+        window_size,
+        rotation:         rotationLabel(params),
+        variance_explained: variance,
+        goodness_of_fit: fit,
+        ...(tests && { stats: tests.stats }),
+        summary,
+    };
+
+    const entry = {
+        kind: 'tma', params, fitArgs,
+        model, codes, unitLabels: model.unitLabels,
+        groupMap, groupCol: group_col ?? null,
+        groupNetworks, connectionNames: model.connectionNames, nConnections: model.nConnections, dims,
+        ...webEntry(ena, model, model.unitLabels, rows, unitCols, params),
+        result,
+    };
+    entry.view = defaultView(params, entry.web);
+    cacheSet(modelCache, model_id, entry, MAX_MODELS);
+
+    return { ...result, _plot: web.buildPlot(entry, entry.view) };
+}
+
+async function toolTmaAccumulate(ena, params) {
+    params = resolveDefaults(ena, params, 'accumulate');
+    const {
+        units, conversations, codes,
+        window_size = 4, window_type = 'lines', time_column = null,
+        stanza_overrides = null,
+        ordered = true,
+    } = params;
+
+    const unitCols  = toArray(units);
+    const convoCols = toArray(conversations);
+    const rows   = loadRows(params);
+    const tensorDef = buildContextTensor(rows, params);
+
+    const result = ena.accumulate(rows, {
+        codes, units: unitCols, conversations: convoCols,
+        ordered, tensor: tensorDef, ...tmaOpts(params), ...accumOpts(params, ordered),
+    });
+
+    const adapted = adaptAccum(result);
+    const { networks: connectionCounts, unitLabels, connectionNames, nUnits, nConnections } = adapted;
+
+    const networks = unitLabels.map((lbl, i) => {
+        const counts = Array.from(connectionCounts.subarray(i * nConnections, (i + 1) * nConnections));
+        const nonZero = counts.flatMap((val, j) => val > 0 ? [{ connection: connectionNames[j], co_occurrences: val }] : []);
+        return {
+            unit: lbl,
+            total_co_occurrences: counts.reduce((a, b) => a + b, 0),
+            connections: nonZero.sort((a, b) => b.co_occurrences - a.co_occurrences).slice(0, 15),
+        };
+    });
+
+    return {
+        n_units:       nUnits,
+        n_connections: nConnections,
+        networks,
+        summary: [
+            'TMA context tensor accumulated.',
+            `  Units: ${nUnits}   Directed Connections: ${nConnections}`,
+            `  Window: size=${window_size}, type=${window_type}`,
+            ...optsLines(params, nUnits),
+        ].join('\n'),
+    };
+}
+
+// ── 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.
+ */
+const PROFILE_MAX_LEVELS = 10;
+
+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 uniq    = [...new Set(vals)];
+        const nUnique = uniq.length;
+        const numericCount = vals.filter(v => !isNaN(Number(v))).length;
+        const isBin   = nUnique <= 2 && numericCount === vals.length &&
+                        uniq.every(v => v === '0' || v === '1');
+        const info = {
+            name:     col,
+            n_unique: nUnique,
+            n_rows:   vals.length,
+            is_binary: isBin,
+        };
+        // Category labels (e.g. condition names) are needed to choose group
+        // values; anything higher-cardinality — utterance text, names, IDs,
+        // timestamps — is row-level data and is never returned.
+        if (nUnique <= PROFILE_MAX_LEVELS) info.values = uniq.slice().sort();
+        else info.values_withheld = true;
+        return info;
+    });
+
+    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: names, counts, and the distinct ` +
+            `labels of columns with ≤${PROFILE_MAX_LEVELS} values (e.g. condition names). No row-level values ` +
+            `(text, names, IDs, timestamps) were 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 det     = detectColumns(rows);
+    const nRows   = det.nRows;
+    const headers = nRows > 0 ? Object.keys(rows[0]) : [];
+
+    const codeCols   = det.codes;
+    const toSuggestion = ({ column, nUnique, score }) => ({ column, n_unique: nUnique, score });
+    const suggestedUnits  = det.units.map(toSuggestion);
+    const suggestedConvos = det.conversations.map(toSuggestion);
+    const suggestedGroups = det.groups;
+    const colSummary = det.columns.map(c => ({ name: c.name, n_unique: c.nUnique, likely_role: c.role }));
+
+    const nCodes   = codeCols.length;
+    const topUnit  = suggestedUnits[0];
+    const topConvo = suggestedConvos[0];
+    const hasUnits = !!topUnit  && topUnit.score  >= 0.3;
+    const hasConvo = !!topConvo && topConvo.score >= 0.2;
+
+    let recommended, confidence, reason;
+    if (nCodes >= 3 && hasUnits && hasConvo) {
+        recommended = true;
+        confidence  = nCodes >= 5 && topUnit.score >= 0.7 ? 'high' : 'medium';
+        reason = `Found ${nCodes} binary code columns, a likely unit column ` +
+            `('${topUnit.column}', ${topUnit.n_unique} unique values), and a ` +
+            `likely conversation column ('${topConvo.column}', ${topConvo.n_unique} 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 if (nCodes === 1) {
+        recommended = false;
+        confidence  = 'low';
+        reason = `Only 1 binary code column was detected. ENA models co-occurrence ` +
+            `*between* codes, so it needs at least 2 (ideally 4+) binary presence/absence columns.`;
+    } else {
+        recommended = false;
+        confidence  = 'low';
+        reason = `No binary (0/1) code columns were detected in this dataset. ENA models the ` +
+            `co-occurrence of *codes* — columns that mark, for each row, whether a concept, ` +
+            `behavior, or feature is present (1) or absent (0). This dataset has none, so ENA ` +
+            `cannot be run on it as-is.`;
+    }
+
+    // Actionable guidance for the not-applicable cases, so Claude can explain
+    // to the user *why* ENA doesn't fit and what would be needed.
+    let guidance = null;
+    if (!recommended) {
+        const needs =
+            'For a dataset to be analyzable with ENA it needs:\n' +
+            '  • 2+ binary (0/1) CODE columns — each marking presence/absence of a concept or behavior per row\n' +
+            '  • a UNIT column identifying who or what each row belongs to\n' +
+            '  • a CONVERSATION column grouping rows into episodes';
+        guidance = nCodes === 0
+            ? `${needs}\n\nThis dataset appears to contain no coded columns. If it is uncoded text or ` +
+              `raw events, each concept of interest must first be turned into a 0/1 column (a ` +
+              `qualitative-coding step) before ENA can be applied. If you expected coded columns, ` +
+              `check that they use 0/1 values rather than text labels.`
+            : `${needs}\n\nAdd more binary code columns, or use a standard statistical analysis instead.`;
+    }
+
+    let nextStep = {};
+    if (recommended && suggestedUnits.length && suggestedConvos.length) {
+        // detectParams' combined selections: nesting unit columns (broadest
+        // first) and up to two crossed conversation columns.
+        const pick = (cols, fallback) =>
+            cols?.length > 1 ? cols : (cols?.[0] ?? fallback);
+        const bestUnit  = pick(det.suggestedUnits, suggestedUnits[0].column);
+        const bestConvo = pick(det.suggestedConversations, 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)}`);
+    if (guidance)
+        summaryLines.push('', guidance);
+
+    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,
+        guidance,
+        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) {
+    params = resolveDefaults(ena, withGmrGroups(params), 'fit');
+    const {
+        units, conversations, codes,
+        window_size, binary = true,
+        dims: requestedDims = 2, rotation,
+        group_col, group1_value, group2_value,
+    } = params;
+
+    // Normalize units/conversations to arrays (rena-wasm joins with '__')
+    const unitCols  = toArray(units);
+    const convoCols = toArray(conversations);
+
+    // Return cached model if params are identical
+    const fKey = fitCacheKey(params);
+    const cachedId = fitCache.get(fKey);
+    if (cachedId && modelCache.has(cachedId)) {   // the model may have been evicted
+        const model_id = cachedId;
+        const entry    = cacheGet(modelCache, model_id);
+        return {
+            model_id,
+            ...entry.result,
+            summary: `Using cached model ${model_id}.\n${entry.result.summary}`,
+            _plot: web.buildPlot(entry, entry.view),
+        };
+    }
+
+    // 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 } = cacheGet(accumCache, aKey));
+    } else {
+        rows = loadRows(params);
+        acc  = ena.accumulate(rows, {
+            codes, units: unitCols, conversations: convoCols,
+            window: windowValue(window_size), binary, ...accumOpts(params),
+        });
+        cacheSet(accumCache, aKey, { rows, acc }, MAX_ACCUM);
+    }
+
+    const { unitLabels, nConnections, connectionNames, nUnits } = acc;
+
+    let uMap;
+    if (group_col) uMap = buildUnitGroupMap(rows, unitCols, group_col);
+    const rot = rotationOpts(rows, unitCols, unitLabels, params, uMap);
+
+    const fitArgs = {
+        codes, units: unitCols, conversations: convoCols,
+        window: windowValue(window_size), binary, dims: Math.max(requestedDims, PLOT_DIMS),
+        ...rot.opts, ...fitOpts(params),
+    };
+    const model = ena.fit(rows, fitArgs);
+    // Fits keep PLOT_DIMS dimensions for ena_plot's axis choice; results report
+    // the requested ones. rena-wasm caps both at the rotation's columns.
+    const stride = model.dims ?? requestedDims;
+    const dims   = Math.min(requestedDims, stride);
+
+    const groupMap = uMap ?? null;
+
+    // Per-group mean networks (the reported numbers) — from the sphere-normed
+    // line weights (as rENA does), not raw counts, so they share the plotted space
+    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(model.networks, nConnections, idx);
+        }
+    }
+
+    const dimCols    = Array.from({ length: dims }, (_, i) => `dim${i + 1}`);
+    const variance   = varianceExplained(model, dims);
+    const fit        = goodnessOfFit(model, dims);
+    const centroids  = toRecords(model.centroids, nUnits, dims, unitLabels, 'dim', stride);
+    const nodePos    = toRecords(model.positions, codes.length, dims, codes, 'dim', stride);
+
+    // Group tests whenever two groups are named, whatever the rotation.
+    let tests = null;
+    if (groupMap && group1_value && group2_value) {
+        const idxOf = (gv) => unitLabels.flatMap((lbl, i) => groupMap.get(lbl) === String(gv) ? [i] : []);
+        const [i1, i2] = [idxOf(group1_value), idxOf(group2_value)];
+        if (i1.length && i2.length)
+            tests = groupStats(ena, model.centroids, dims, i1, i2, String(group1_value), String(group2_value), stride);
+    }
+
+    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: ${rotationLabel(params)}` + (rotation === 'generalized' ? `   Axes: ${model.columnNames?.slice(0, dims).join(', ')}` : ''),
+        ...rot.lines,
+        ...varianceLine(variance),
+        ...fitLine(fit),
+        `${windowLine(params)}, binary=${binary}`,
+        ...optsLines(params, nUnits),
+        '',
+        `Node positions (${dimCols.join(', ')}):`,
+        ...nodeLines,
+        ...(tests ? ['', ...tests.lines] : []),
+        '',
+        `Use ena_plot with model_id="${model_id}" for additional views (group, unit, subtraction, comparison), ` +
+            `or ena_export to open the model in the ENA Web Tool.`,
+    ].join('\n');
+
+    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,
+        window_size,
+        rotation:         rotationLabel(params),
+        variance_explained: variance,
+        goodness_of_fit: fit,
+        ...(tests && { stats: tests.stats }),
+        summary,
+    };
+
+    const entry = {
+        kind: 'ena', params, fitArgs,
+        model, codes, unitLabels,
+        groupMap, groupCol: group_col ?? null,
+        groupNetworks, connectionNames, nConnections, dims,
+        ...webEntry(ena, model, unitLabels, rows, unitCols, params),
+        result,
+    };
+    entry.view = defaultView(params, entry.web);
+    cacheSet(modelCache, model_id, entry, MAX_MODELS);
+    cacheSet(fitCache, fKey, model_id, MAX_MODELS);
+
+    return { ...result, _plot: web.buildPlot(entry, entry.view) };
+}
+
+async function toolAccumulate(ena, params) {
+    params = resolveDefaults(ena, params, 'accumulate');
+    const {
+        units, conversations, codes,
+        window_size, binary = true,
+    } = params;
+    const unitCols  = toArray(units);
+    const convoCols = toArray(conversations);
+    const rows   = loadRows(params);
+    const result = ena.accumulate(rows, {
+        codes, units: unitCols, conversations: convoCols,
+        window: windowValue(window_size), binary, ...accumOpts(params),
+    });
+
+    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}`,
+        `${windowLine(params)}, binary=${binary}`,
+        ...optsLines(params, nUnits),
+        '',
+        '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,
+        window_size,
+        top_connections:  topConnections,
+        summary,
+    };
+}
+
+// Window-size estimate by Cross-Covariance Decay (= rENA ena.ccd). Runs on the
+// raw code matrix per conversation; no accumulation or rotation.
+async function toolWindow(ena, {
+    conversations, codes,
+    data_path, data_csv, exclude_conversations, order_by,
+    max_window = 20, min_overlap = 10,
+}) {
+    const convoCols = toArray(conversations);
+    const rows = loadRows({ data_path, data_csv, conversations, exclude_conversations, order_by });
+    const r = ena.ccd(rows, { codes, conversations: convoCols, maxWindow: max_window, minOverlap: min_overlap });
+
+    const curve = Array.from(r.lag, (lag, i) => ({
+        lag,
+        cross_covariance: R(r.frob_unbiased_signed[i], 4),
+        weight:           r.total_weight[i],
+    }));
+    const peak = Math.max(...curve.map(c => Math.abs(c.cross_covariance))) || 1;
+
+    const summary = [
+        `Estimated window size: ${r.window_size}   (Cross-Covariance Decay, = rENA ena.ccd)`,
+        `  Peak lag: ${r.peak_lag}   Lags evaluated: 0–${curve.at(-1)?.lag ?? 0}`,
+        '',
+        'Noise-corrected cross-covariance by lag:',
+        ...curve.map(c => `  ${String(c.lag).padStart(3)}  ${c.cross_covariance.toFixed(4).padStart(8)}  ` +
+            '#'.repeat(Math.round(30 * Math.abs(c.cross_covariance) / peak))),
+        '',
+        `Pass window_size=${r.window_size} to ena_fit / tma_fit, or compare against a nearby value.`,
+    ].join('\n');
+
+    return {
+        window_size: r.window_size,
+        peak_lag:    r.peak_lag,
+        curve,
+        summary,
+    };
+}
+
+async function toolCompareGroups(ena, params) {
+    if (!params.group_col || params.group1_value == null || params.group2_value == null)
+        throw new Error('ena_compare_groups requires group_col, group1_value and group2_value.');
+    if (params.rotation_from != null)
+        throw new Error('ena_compare_groups is defined by its rotation through the two groups; use ena_fit with rotation_from to project into another model.');
+    params = resolveDefaults(ena, params, 'compare');
+    const {
+        units, conversations, codes,
+        group_col, group1_value, group2_value,
+        window_size, binary = true,
+        dims: requestedDims = 2,
+    } = params;
+
+    // Return cached model if params are identical
+    const fKey = fitCacheKey(params, 'compare');
+    const cachedId = fitCache.get(fKey);
+    if (cachedId && modelCache.has(cachedId)) {   // the model may have been evicted
+        const model_id = cachedId;
+        const entry    = cacheGet(modelCache, model_id);
+        return {
+            model_id,
+            ...entry.result,
+            summary: `Using cached model ${model_id}.\n${entry.result.summary}`,
+            _plot: web.buildPlot(entry, entry.view),
+        };
+    }
+
+    // Normalize units/conversations to arrays
+    const unitCols  = toArray(units);
+    const convoCols = toArray(conversations);
+
+    // Accumulate (or use cache)
+    const aKey = accumCacheKey(params);
+    let rows, acc;
+    if (accumCache.has(aKey)) {
+        ({ rows, acc } = cacheGet(accumCache, aKey));
+    } else {
+        rows = loadRows(params);
+        acc  = ena.accumulate(rows, {
+            codes, units: unitCols, conversations: convoCols,
+            window: windowValue(window_size), binary, ...accumOpts(params),
+        });
+        cacheSet(accumCache, aKey, { rows, acc }, MAX_ACCUM);
+    }
+
+    const { unitLabels, 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 rot = rotationOpts(rows, unitCols, unitLabels, params, uMap);
+    const fitArgs = {
+        codes, units: unitCols, conversations: convoCols,
+        window: windowValue(window_size), binary, dims: Math.max(requestedDims, PLOT_DIMS),
+        ...rot.opts, ...fitOpts(params),
+    };
+    const model = ena.fit(rows, fitArgs);
+    // Fits keep PLOT_DIMS dimensions for ena_plot's axis choice; results report
+    // the requested ones. rena-wasm caps both at the rotation's columns.
+    const stride = model.dims ?? requestedDims;
+    const dims   = Math.min(requestedDims, stride);
+
+    const dimCols      = Array.from({ length: dims }, (_, i) => `dim${i + 1}`);
+    const variance   = varianceExplained(model, dims);
+    const fit        = goodnessOfFit(model, dims);
+    const allCentroids = toRecords(model.centroids, nUnits, dims, unitLabels, 'dim', stride);
+    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, 'dim', stride);
+
+    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 tests  = groupStats(ena, model.centroids, dims, g1Idx, g2Idx, String(group1_value), String(group2_value), stride);
+
+    const g1NetMean = computeGroupMean(model.networks, nConnections, g1Idx);
+    const g2NetMean = computeGroupMean(model.networks, 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 model_id = nextModelId();
+
+    const summary = [
+        `ENA group comparison: '${group1_value}' vs '${group2_value}'   model_id: ${model_id}`,
+        `  Rotation: ${rotationLabel(params)}   Axes: ${model.columnNames?.slice(0, dims).join(', ')}`,
+        ...rot.lines,
+        ...varianceLine(variance),
+        ...fitLine(fit),
+        windowLine(params),
+        ...optsLines(params, nUnits),
+        `  ${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(', '),
+        '',
+        ...tests.lines,
+        '',
+        'Top differential connections (difference of group-mean line weights):',
+        ...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, ` +
+            `or ena_export to open the model in the ENA Web Tool.`,
+    ].join('\n');
+
+    const result = {
+        model_id,
+        group1_centroids:    g1Centroids,
+        group2_centroids:    g2Centroids,
+        group1_mean:         g1Mean,
+        group2_mean:         g2Mean,
+        difference:          diff,
+        stats:               tests.stats,
+        window_size,
+        rotation:            rotationLabel(params),
+        node_positions:      nodePos,
+        variance_explained:  variance,
+        goodness_of_fit: fit,
+        connection_names:    [...connectionNames],
+        group1_networks:     netDict(g1NetMean),
+        group2_networks:     netDict(g2NetMean),
+        subtraction_network: netDict(subNet),
+        top_differential:    topDiff,
+        summary,
+    };
+
+    const entry = {
+        kind: 'compare', params, fitArgs,
+        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),
+        ...webEntry(ena, model, unitLabels, rows, unitCols, params),
+        result,
+    };
+    entry.view = defaultView(params, entry.web);
+    cacheSet(modelCache, model_id, entry, MAX_MODELS);
+    cacheSet(fitCache, fKey, model_id, MAX_MODELS);
+
+    return { ...result, _plot: web.buildPlot(entry, entry.view) };
+}
+
+// ena_plot's display options → buildPlot's view.style (the web tool's Plot
+// Settings). Validated here so a bad colour or group fails with a message
+// instead of a blank plot.
+// qeviz resolves colour names through a canvas, which the SVG renderer
+// (jsdom) lacks, so names are turned into hex here: the CSS named colours.
+const CSS_NAMED = Object.fromEntries((
+    'aliceblue:f0f8ff antiquewhite:faebd7 aqua:00ffff aquamarine:7fffd4 azure:f0ffff beige:f5f5dc ' +
+    'bisque:ffe4c4 black:000000 blanchedalmond:ffebcd blue:0000ff blueviolet:8a2be2 brown:a52a2a ' +
+    'burlywood:deb887 cadetblue:5f9ea0 chartreuse:7fff00 chocolate:d2691e coral:ff7f50 ' +
+    'cornflowerblue:6495ed cornsilk:fff8dc crimson:dc143c cyan:00ffff darkblue:00008b darkcyan:008b8b ' +
+    'darkgoldenrod:b8860b darkgray:a9a9a9 darkgreen:006400 darkgrey:a9a9a9 darkkhaki:bdb76b ' +
+    'darkmagenta:8b008b darkolivegreen:556b2f darkorange:ff8c00 darkorchid:9932cc darkred:8b0000 ' +
+    'darksalmon:e9967a darkseagreen:8fbc8f darkslateblue:483d8b darkslategray:2f4f4f darkslategrey:2f4f4f ' +
+    'darkturquoise:00ced1 darkviolet:9400d3 deeppink:ff1493 deepskyblue:00bfff dimgray:696969 ' +
+    'dimgrey:696969 dodgerblue:1e90ff firebrick:b22222 floralwhite:fffaf0 forestgreen:228b22 ' +
+    'fuchsia:ff00ff gainsboro:dcdcdc ghostwhite:f8f8ff gold:ffd700 goldenrod:daa520 gray:808080 ' +
+    'green:008000 greenyellow:adff2f grey:808080 honeydew:f0fff0 hotpink:ff69b4 indianred:cd5c5c ' +
+    'indigo:4b0082 ivory:fffff0 khaki:f0e68c lavender:e6e6fa lavenderblush:fff0f5 lawngreen:7cfc00 ' +
+    'lemonchiffon:fffacd lightblue:add8e6 lightcoral:f08080 lightcyan:e0ffff lightgoldenrodyellow:fafad2 ' +
+    'lightgray:d3d3d3 lightgreen:90ee90 lightgrey:d3d3d3 lightpink:ffb6c1 lightsalmon:ffa07a ' +
+    'lightseagreen:20b2aa lightskyblue:87cefa lightslategray:778899 lightslategrey:778899 ' +
+    'lightsteelblue:b0c4de lightyellow:ffffe0 lime:00ff00 limegreen:32cd32 linen:faf0e6 magenta:ff00ff ' +
+    'maroon:800000 mediumaquamarine:66cdaa mediumblue:0000cd mediumorchid:ba55d3 mediumpurple:9370db ' +
+    'mediumseagreen:3cb371 mediumslateblue:7b68ee mediumspringgreen:00fa9a mediumturquoise:48d1cc ' +
+    'mediumvioletred:c71585 midnightblue:191970 mintcream:f5fffa mistyrose:ffe4e1 moccasin:ffe4b5 ' +
+    'navajowhite:ffdead navy:000080 oldlace:fdf5e6 olive:808000 olivedrab:6b8e23 orange:ffa500 ' +
+    'orangered:ff4500 orchid:da70d6 palegoldenrod:eee8aa palegreen:98fb98 paleturquoise:afeeee ' +
+    'palevioletred:db7093 papayawhip:ffefd5 peachpuff:ffdab9 peru:cd853f pink:ffc0cb plum:dda0dd ' +
+    'powderblue:b0e0e6 purple:800080 rebeccapurple:663399 red:ff0000 rosybrown:bc8f8f royalblue:4169e1 ' +
+    'saddlebrown:8b4513 salmon:fa8072 sandybrown:f4a460 seagreen:2e8b57 seashell:fff5ee sienna:a0522d ' +
+    'silver:c0c0c0 skyblue:87ceeb slateblue:6a5acd slategray:708090 slategrey:708090 snow:fffafa ' +
+    'springgreen:00ff7f steelblue:4682b4 tan:d2b48c teal:008080 thistle:d8bfd8 tomato:ff6347 ' +
+    'turquoise:40e0d0 violet:ee82ee wheat:f5deb3 white:ffffff whitesmoke:f5f5f5 yellow:ffff00 ' +
+    'yellowgreen:9acd32'
+).trim().split(/\s+/).map(p => p.split(':')));
+function cssColor(c) {
+    const v = String(c).trim().toLowerCase();
+    if (/^#[0-9a-f]{6}$/.test(v)) return v;
+    if (/^#[0-9a-f]{3}$/.test(v)) return '#' + [...v.slice(1)].map(h => h + h).join('');
+    return CSS_NAMED[v] ? `#${CSS_NAMED[v]}` : null;
+}
+function plotStyle(w, o) {
+    const style = {};
+    if (o.min_edge_weight != null) {
+        const v = Number(o.min_edge_weight);
+        if (!(v >= 0)) throw new Error('min_edge_weight must be a number ≥ 0');
+        style.minWeight = v;
+    }
+    if (o.hide_unconnected_codes) style.hideUnconnected = true;
+    if (o.text_size != null) {
+        const v = Number(o.text_size);
+        if (!(v >= 6 && v <= 48)) throw new Error('text_size must be between 6 and 48 (px)');
+        style.textSize = v;
+    }
+    if (o.colors != null) {
+        if (typeof o.colors !== 'object' || Array.isArray(o.colors))
+            throw new Error('colors must be an object: { "<group>": "<colour>" }');
+        const groups = w.groups.map(g => g.name);
+        for (const [g, c] of Object.entries(o.colors)) {
+            if (!w.byName.has(g)) throw new Error(`colors: no group '${g}'. Groups: ${groups.join(', ')}`);
+            if (!cssColor(c)) throw new Error(`colors: '${c}' is not a colour. Use #rgb, #rrggbb or a CSS colour name such as orange or steelblue.`);
+        }
+        style.colors = Object.fromEntries(Object.entries(o.colors).map(([g, c]) => [g, cssColor(c)]));
+    }
+    if (o.confidence_intervals === false) style.ci = false;
+    if (o.outlier_intervals === true) style.outliers = true;
+    return style;
+}
+
+async function toolPlot({ model_id, type = 'all', group_value, group1, group2, unit_label, magnify,
+                          x_dim = 1, y_dim = 2, flip_x = false, flip_y = false,
+                          min_edge_weight, hide_unconnected_codes, text_size, colors,
+                          confidence_intervals, outlier_intervals }) {
+    const entry = cacheGet(modelCache, model_id);
+    if (!entry)
+        throw new Error(`Unknown model_id '${model_id}'. Call ena_fit, ena_compare_groups or tma_fit first ` +
+            `(the ${MAX_MODELS} most recently used models are kept; refitting is cheap).`);
+
+    const { codes, unitLabels, groupCol, web: w } = entry;
+    const groupNames = w.groups.map(g => g.name);
+    const needGroup = (g, what) => {
+        if (!groupCol && w.groups.length < 2)
+            throw new Error(`Model ${model_id} has no groups. Refit with group_col (or two or more unit columns).`);
+        if (!w.byName.has(String(g)))
+            throw new Error(`${what}: no group '${g}'. Groups: ${groupNames.join(', ')}`);
+        return { kind: 'group', name: String(g) };
+    };
+    const pair = () => {
+        const g1 = group1 ?? entry.group1_value ?? entry.params?.group1_value;
+        const g2 = group2 ?? entry.group2_value ?? entry.params?.group2_value;
+        if (g1 == null || g2 == null) throw new Error(`type='${type}' requires group1 and group2`);
+        return [needGroup(g1, 'group1'), needGroup(g2, 'group2')];
+    };
+
+    let view, label;
+    switch (type) {
+        case 'all':
+            view  = { first: { kind: 'all' } };
+            label = `ENA model ${model_id} — all units`;
+            break;
+        case 'group': {
+            if (group_value == null) throw new Error("type='group' requires group_value");
+            view  = { first: needGroup(group_value, 'group_value') };
+            label = `ENA mean network — ${group_value}`;
+            break;
+        }
+        case 'comparison': {
+            const [a, b] = pair();
+            view  = { first: a, second: b, overlay: true };
+            label = `ENA comparison — ${a.name} vs ${b.name}`;
+            break;
+        }
+        case 'subtraction': {
+            const [a, b] = pair();
+            view  = { first: a, second: b };
+            label = `ENA subtraction — ${a.name} − ${b.name}`;
+            break;
+        }
+        case 'unit': {
+            if (unit_label == null) throw new Error("type='unit' requires unit_label");
+            if (!unitLabels.includes(String(unit_label)))
+                throw new Error(`Unit '${unit_label}' not found. Available: ${unitLabels.slice(0, 20).join(', ')}`);
+            view  = { first: { kind: 'unit', name: String(unit_label) } };
+            label = `ENA network — ${unit_label}`;
+            break;
+        }
+        default:
+            throw new Error(`Unknown type '${type}'. Options: all, group, comparison, subtraction, unit`);
+    }
+
+    if (magnify != null) {
+        if (!(Number(magnify) > 0)) throw new Error('magnify must be a positive number');
+        view.scale = Number(magnify);
+    }
+
+    // Axes: dimensions are 1-based here, as in the results (dim1, dim2, ...).
+    const nDims = entry.model.dims ?? 2;
+    const names = entry.dimNames ?? [];
+    for (const [k, v] of [['x_dim', x_dim], ['y_dim', y_dim]])
+        if (!Number.isInteger(Number(v)) || v < 1 || v > nDims)
+            throw new Error(`${k} must be a dimension from 1 to ${nDims} (this model has ${nDims}: ` +
+                `${Array.from({ length: nDims }, (_, i) => names[i] ?? `dim${i + 1}`).join(', ')}).`);
+    if (Number(x_dim) === Number(y_dim)) throw new Error('x_dim and y_dim must be different dimensions.');
+    view.axes = [Number(x_dim) - 1, Number(y_dim) - 1];
+    view.flip = [!!flip_x, !!flip_y];
+    const axesNote = (x_dim != 1 || y_dim != 2 || flip_x || flip_y)
+        ? ` [x: ${flip_x ? '−' : ''}${names[x_dim - 1] ?? `dim${x_dim}`}, y: ${flip_y ? '−' : ''}${names[y_dim - 1] ?? `dim${y_dim}`}]` : '';
+
+    view.style = plotStyle(w, { min_edge_weight, hide_unconnected_codes, text_size, colors,
+        confidence_intervals, outlier_intervals });
+
+    const plot = web.buildPlot(entry, view);
+    label += ` (scaled ${(view.scale ?? 1).toFixed(1)}x)${axesNote}`;
+    const st = view.style;
+    const settings = {
+        ...(st.minWeight > 0 && { min_edge_weight: st.minWeight }),
+        ...(st.hideUnconnected && { hide_unconnected_codes: true }),
+        ...(st.textSize && { text_size: st.textSize }),
+        ...(st.colors && { colors: st.colors }),
+        ...(st.ci === false && { confidence_intervals: false }),
+        ...(st.outliers && { outlier_intervals: true }),
+    };
+
+    return {
+        model_id,
+        plot_type: type,
+        magnify:   view.scale ?? 1,
+        axes:      { x: names[x_dim - 1] ?? `dim${x_dim}`, y: names[y_dim - 1] ?? `dim${y_dim}`, flip_x: !!flip_x, flip_y: !!flip_y },
+        label,
+        title:     plot.title,
+        ...(plot.maxWeight > 0 && { max_edge_weight: Number(plot.maxWeight.toPrecision(4)) }),
+        ...(Object.keys(settings).length && { plot_settings: settings }),
+        n_codes:   codes.length,
+        n_units:   unitLabels.length,
+        summary:   label,
+        _plot:     plot,
+    };
+}
+
+// ── Export to the ENA Web Tool ────────────────────────────────────────────────
+
+// Choices the web tool has no setting for: a model that uses them would open
+// there as a different model, so it is not exported.
+function exportBlockers(entry) {
+    const p = entry.params ?? {};
+    const unitCols = toArray(p.units);
+    const out = [];
+    if (p.center_align_to_origin === false) out.push('center_align_to_origin=false (the web tool always keeps zero-network units at the origin)');
+    if (p.binary === false && !p.weight_model) out.push('binary=false (weight_model="product" keeps raw counts and exports)');
+    if (entry.kind === 'tma') {
+        if (toArray(p.stanza_modality).length || toArray(p.stanza_ground).length || toArray(p.stanza_response).length ||
+            p.stanza_overrides || p.horizons)
+            out.push('transmodal windows (stanza_modality / stanza_ground / stanza_response / stanza_overrides / horizons)');
+        if ((p.window_type ?? 'lines') !== 'lines') out.push('time-based windows');
+        if (p.ordered === false) out.push('an unordered tma_fit model (use ena_fit)');
+    }
+    if (p.rotation_from != null)
+        out.push(`a projection into model ${p.rotation_from}'s space (in the web tool, "Use Rotation Matrix From" refers to another set in the same project; export the source and set it there)`);
+    const rot = p.rotation ?? 'svd';
+    if (p.rotation_from != null) { /* reported above */ }
+    else if (p._web_gmr) {
+        if (p._web_gmr.col !== unitCols[0] || unitCols.length < 2)
+            out.push(`a rotation by ${p._web_gmr.col} (the web tool rotates by the groups of the first of two or more unit columns` +
+                `${unitCols.length > 1 ? `, here ${unitCols[0]}` : ''})`);
+    } else if (rot === 'generalized') {
+        out.push('a generalized rotation on x_var (the web tool rotates only by its unit groups)');
+    } else if (rot === 'mean' && (p.group_col !== unitCols[0] || unitCols.length < 2)) {
+        out.push(`a means rotation on ${p.group_col} (the web tool rotates by the groups of its first unit column)`);
+    }
+    return out;
+}
+
+// The web tool's rotation switches for this model.
+function exportRotation(entry) {
+    const p = entry.params;
+    if (p._web_gmr) {
+        const nGroups = entry.web.groups.length;
+        return { meansRotated: nGroups === 2 ? 1 : null, regressionRotated: 1, meansRotatedBy: [...p._web_gmr.pair] };
+    }
+    if (p.rotation === 'mean')
+        return { meansRotated: 1, regressionRotated: null, meansRotatedBy: [String(p.group1_value), String(p.group2_value)] };
+    return { meansRotated: null, regressionRotated: null, meansRotatedBy: [] };
+}
+
+const safeFileName = (s) => String(s).replace(/[\/\\:*?"<>|\u0000-\u001f]+/g, '-').trim() || 'ENA model';
+
+function freePath(path) {
+    if (!existsSync(path)) return path;
+    const ext = extname(path), stem = ext ? path.slice(0, -ext.length) : path;
+    for (let i = 2; ; i++) if (!existsSync(`${stem} (${i})${ext}`)) return `${stem} (${i})${ext}`;
+}
+
+// ── ena_tables: the model's data tables as CSV ──────────────────────────────
+// The ENA Web Tool's "Download Model" tables (js/ena.controllers.js export()):
+// nodes.csv and points.csv as it writes them (code / ENA_UNIT, then one column
+// per dimension, named as the dimensions are), and line-weights.csv and
+// connection-counts.csv with one "A & B" column per connection. Those two lead
+// with ENA_UNIT and the unit columns, as rENA's meta.data did — the web tool's
+// WASM sets no longer carry meta.data, which leaves its rows unlabelled.
+function csvCell(v) {
+    if (v == null) return '';
+    const raw = typeof v === 'number' ? (Number.isFinite(v) ? String(v) : '') : String(v);
+    return /[",\n]/.test(raw) ? `"${raw.replace(/"/g, '""')}"` : raw;
+}
+const csvText = (header, rows) => [header, ...rows].map(r => r.map(csvCell).join(',')).join('\n') + '\n';
+
+async function toolTables(ena, { model_id, out_path }) {
+    const entry = cacheGet(modelCache, model_id);
+    if (!entry)
+        throw new Error(`Unknown model_id '${model_id}'. Fit the model first (ena_fit, ena_compare_groups or tma_fit).`);
+    const { model, codes, unitLabels } = entry;
+    const p = entry.params ?? {};
+    const unitCols = toArray(p.units);
+    const stride = model.dims ?? 2;
+    const dimNames = Array.from({ length: stride }, (_, d) => entry.dimNames?.[d] ?? `dimension_${d + 1}`);
+    const nConn = model.nConnections;
+
+    const rowsOf = (flat, n, width) => Array.from({ length: n }, (_, i) => Array.from(flat.subarray
+        ? flat.subarray(i * width, (i + 1) * width) : flat.slice(i * width, (i + 1) * width)));
+    const unitMeta = unitLabels.map(lbl => {
+        const parts = lbl.split('__');
+        return [web.unitPath(lbl), ...unitCols.map((_, j) => parts[j] ?? '')];
+    });
+    const metaHeader = ['ENA_UNIT', ...unitCols];
+
+    const tables = {
+        'nodes.csv':  csvText(['code', ...dimNames], rowsOf(model.positions, codes.length, stride).map((r, c) => [codes[c], ...r])),
+        'points.csv': csvText(['ENA_UNIT', ...dimNames], rowsOf(model.centroids, unitLabels.length, stride).map((r, i) => [unitMeta[i][0], ...r])),
+        'line-weights.csv': csvText([...metaHeader, ...model.connectionNames],
+            rowsOf(model.networks, unitLabels.length, nConn).map((r, i) => [...unitMeta[i], ...r])),
+    };
+    if (model.connectionCounts)
+        tables['connection-counts.csv'] = csvText([...metaHeader, ...model.connectionNames],
+            rowsOf(model.connectionCounts, unitLabels.length, nConn).map((r, i) => [...unitMeta[i], ...r]));
+
+    const base = safeFileName(`ENA model ${model_id} tables`);
+    const dir = freePath(out_path ?? join(p.data_path ? dirname(p.data_path) : VIZ_DIR, base));
+    mkdirSync(dir, { recursive: true });
+    const files = Object.entries(tables).map(([name, text]) => {
+        const path = join(dir, name);
+        writeFileSync(path, text);
+        return { file: name, path, rows: text.split('\n').length - 2 };
+    });
+
+    const summary = [
+        `Wrote model ${model_id}'s tables to ${dir}`,
+        ...files.map(f => `  ${f.file.padEnd(22)} ${f.rows} rows`),
+        `  Dimensions: ${dimNames.join(', ')}   Connections: ${nConn}${model.ordered ? ' (directed: "A & B" is A → B)' : ''}`,
+        '  points.csv holds the unit points as fitted (unscaled); line-weights.csv the normalized networks;',
+        '  connection-counts.csv the raw accumulated counts. No rows of the data file are included.',
+    ].join('\n');
+    return { model_id, folder: dir, files, dimensions: dimNames, summary };
+}
+
+// ── ena_simplify: PRIA, the ENA Web Tool's Simplify Model ───────────────────
+// rena-wasm pria() (= R's PRIA::pria) finds the largest set of codes, up to
+// remove_num and never leaving fewer than 3, whose removal keeps the model
+// within threshold of the full one. Run with the fit's own options, as the web
+// tool does (WasmWrapper: ena.pria(rows, { ...fitOpts, removeNum, threshold })),
+// then, as the web tool does, refit without the removed codes.
+const PRIA_MIN = 0.8, PRIA_MAX = 0.99;
+
+async function toolSimplify(ena, { model_id, threshold = 0.95, remove_num = 3 }) {
+    const entry = cacheGet(modelCache, model_id);
+    if (!entry)
+        throw new Error(`Unknown model_id '${model_id}'. Fit the model first (ena_fit, ena_compare_groups or tma_fit).`);
+    if (!entry.fitArgs) throw new Error(`Model ${model_id} can't be simplified. Refit it with this server version.`);
+    const p = entry.params ?? {};
+    const codes = entry.codes;
+    if (codes.length < 4)
+        throw new Error(`Model ${model_id} has ${codes.length} codes; PRIA needs more than 3 (it never leaves fewer than 3).`);
+    if (!(threshold >= PRIA_MIN && threshold <= PRIA_MAX))
+        throw new Error(`threshold must be between ${PRIA_MIN} and ${PRIA_MAX}, as in the ENA Web Tool (default 0.95).`);
+    if (!(Number.isInteger(remove_num) && remove_num >= 1))
+        throw new Error('remove_num must be a whole number of codes, 1 or more (default 3).');
+
+    const rows = loadRows(p);
+    const pr = ena.pria(rows, { ...entry.fitArgs, removeNum: remove_num, threshold });
+    const removed = pr.removed ?? [];
+    const header = `PRIA (threshold ${threshold}, up to ${Math.min(remove_num, codes.length - 3)} codes) on model ${model_id}: `;
+    if (!removed.length) {
+        return {
+            model_id, removed_codes: [], kept_codes: codes, threshold,
+            summary: header + 'no codes can be removed — every code is needed to keep the model within the threshold.',
+        };
+    }
+
+    // Refit without them, as the web tool excludes them and regenerates.
+    const gone = new Set(removed);
+    const kept = codes.filter(c => !gone.has(c));
+    const mask = toArray(p.mask_connections).filter(n => !String(n).split(' & ').some(c => gone.has(c)));
+    const next = { ...p, codes: kept, mask_connections: mask.length ? mask : undefined };
+    const refit = entry.kind === 'tma' ? await toolTmaFit(ena, next)
+        : entry.kind === 'compare' ? await toolCompareGroups(ena, next)
+        : await toolFit(ena, next);
+    return {
+        ...refit,
+        simplified_from: model_id,
+        removed_codes: removed,
+        kept_codes: kept,
+        threshold,
+        summary: header + `removed ${removed.join(', ')} (${removed.length} of ${codes.length} codes). ` +
+            `Refit with the remaining ${kept.length} as model ${refit.model_id}; the window and every other setting are unchanged.\n\n` +
+            refit.summary,
+    };
+}
+
+// ── ena_lines: the lines behind a connection ────────────────────────────────
+// A local HTML viewer of the lines and windows that produced a connection
+// (the ENA Web Tool's Data View), from the model's own rowConnectionCounts and
+// libtma's window rule (lines.js). Returns counts and row numbers, never text.
+const DEFAULT_MAX_WINDOWS = 500;
+
+async function toolLines(ena, { model_id, connection, units, group, columns, max_windows, out_path }) {
+    const entry = cacheGet(modelCache, model_id);
+    if (!entry)
+        throw new Error(`Unknown model_id '${model_id}'. Fit the model first (ena_fit, ena_compare_groups or tma_fit).`);
+    const { model, codes, unitLabels } = entry;
+    const p = entry.params ?? {};
+    if (!model.rowConnectionCounts)
+        throw new Error(`Model ${model_id} has no per-line counts. Refit it with this server version.`);
+    const rows = loadRows(p);
+    const unitCols = toArray(p.units), convoCols = toArray(p.conversations);
+    const isTma = entry.kind === 'tma';
+    const ordered = isTma ? (p.ordered ?? true) : false;
+
+    // Connection: as named in connection_names; unordered pairs either way round.
+    let conn = null;
+    if (connection != null) {
+        const names = model.connectionNames;
+        conn = names.indexOf(String(connection));
+        if (conn < 0 && !ordered) {
+            const [a, b] = String(connection).split(' & ');
+            conn = names.indexOf(`${b} & ${a}`);
+        }
+        if (conn < 0)
+            throw new Error(`Model ${model_id} has no connection '${connection}'. Connections: ${names.join(', ')}` +
+                (ordered ? ' (directed: "A & B" is A → B).' : '.'));
+    }
+
+    // Selection: units by label ("a::b" or "a__b"), or a group.
+    const norm = (l) => String(l).split('::').join('__');
+    let selected;
+    if (units?.length) {
+        selected = new Set(toArray(units).map(u => {
+            const i = unitLabels.indexOf(norm(u));
+            if (i < 0) throw new Error(`Unit '${u}' is not in model ${model_id}.`);
+            return i;
+        }));
+    } else if (group != null) {
+        const g = entry.web?.byName.get(String(group));
+        if (!g) throw new Error(`Model ${model_id} has no group '${group}'. Groups: ${(entry.web?.groups ?? []).map(x => x.name).join(', ')}`);
+        selected = new Set(g.idx);
+    } else if (unitLabels.length === 1) {
+        selected = new Set([0]);
+    } else {
+        throw new Error('Choose the lines to show with units (unit labels) or group.');
+    }
+
+    const allCols = rows.length ? Object.keys(rows[0]) : [];
+    for (const c of toArray(columns))
+        if (!allCols.includes(c)) throw new Error(`Column '${c}' is not in the data.`);
+
+    if (conn != null && isMasked(p, ordered, model.connectionNames[conn]))
+        throw new Error(`${model.connectionNames[conn]} is masked in model ${model_id} (mask_connections), so no lines count toward it. ` +
+            'Fit the model without the mask to see its lines.');
+    const tensorDef = isTma ? buildContextTensor(rows, p) : defaultTensor(windowValue(p.window_size ?? 4));
+    const res = connectionWindows({
+        rows, codes, unitCols, convoCols, unitsUsed: p.units_used ?? null,
+        tensorDef, horizons: isTma ? (p.horizons ?? null) : null, ordered,
+        unitLabels, rowCounts: model.rowConnectionCounts, connectionNames: model.connectionNames,
+        conn, selected,
+    });
+
+    const connName = conn == null ? null : model.connectionNames[conn];
+    const highlight = connName ? [...new Set(connName.split(' & '))] : [];
+    const stanzaCols = isTma ? [...toArray(p.stanza_modality), ...toArray(p.stanza_ground), ...toArray(p.stanza_response)] : [];
+    // The web tool's Data View: units, conversations, codes (the connection's
+    // when one is shown); plus what the user adds, and TMA's stanza columns.
+    const shown = [...new Set([...unitCols, ...convoCols, ...stanzaCols, ...toArray(columns),
+                                ...(highlight.length ? highlight : codes)])];
+    const maxWindows = Number.isInteger(max_windows) && max_windows > 0 ? max_windows : DEFAULT_MAX_WINDOWS;
+
+    const unitPath = (i) => unitLabels[i].split('__').join('::');
+    const selLabel = group != null ? `${group} (${selected.size} units)`
+        : selected.size === 1 ? unitPath([...selected][0]) : `${selected.size} units`;
+    const dataFile = p.data_path ? basename(p.data_path) : 'pasted data';
+    const html = viewerHtml({
+        title: connName ? `${connName}${ordered ? ' (→)' : ''} — ${selLabel}` : `Lines — ${selLabel}`,
+        subtitle: `Model ${model_id}: units ${unitCols.join(' + ')} · conversations ${convoCols.join(' + ')} · ` +
+            `window ${p.window_size ?? 4}${isTma ? ' (TMA)' : ''} · ${res.windows.length} windows` +
+            (conn != null ? ` · check: ${res.check.mismatches.length ? `${res.check.mismatches.length} MISMATCHES` : 'every line matches the model'}` : ''),
+        note: `This file contains rows of ${dataFile}. Row numbers are data rows (the header is not counted). ` +
+            (ordered && connName ? `Directed: ground lines carrying ${highlight[0]} in the window, response line carrying ${highlight[highlight.length - 1]}.` : ''),
+        dataFile, columns: allCols,
+        roles: { units: unitCols, conversations: convoCols, codes, shown },
+        highlight, ordered, rows, result: res, unitLabels, maxWindows,
+        rowNumber: (i) => fileRowOf(rows, i) + 1,
+    });
+
+    const base = safeFileName(`ENA lines ${model_id} ${connName ?? 'all'} ${selLabel}`).slice(0, 120);
+    const target = freePath(out_path
+        ? (extname(out_path).toLowerCase() === '.html' ? out_path : join(out_path, `${base}.html`))
+        : join(p.data_path ? dirname(p.data_path) : VIZ_DIR, `${base}.html`));
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, html);
+
+    const byUnit = new Map();
+    for (const w of res.windows) {
+        const b = byUnit.get(w.unit) ?? { unit: unitPath(w.unit), windows: 0, count: 0 };
+        b.windows++; b.count += w.count ?? 0; byUnit.set(w.unit, b);
+    }
+    const ctxUsed = new Set(res.windows.map(w => w.context));
+    let modelTotal = 0;
+    if (conn != null) for (const u of selected) modelTotal += model.connectionCounts[u * model.nConnections + conn];
+    const linesTotal = res.windows.reduce((s, w) => s + (w.count ?? 0), 0);
+    const match = conn == null ? null : (res.check.mismatches.length === 0 && Math.abs(linesTotal - modelTotal) < 1e-9);
+
+    const summary = [
+        connName
+            ? `${res.windows.length} windows behind ${connName}${ordered ? ' (directed)' : ''} for ${selLabel}, in ${ctxUsed.size} conversation(s).`
+            : `${res.windows.length} lines for ${selLabel}, in ${ctxUsed.size} conversation(s).`,
+        ...(conn != null ? [match
+            ? `  Check: every one of the selection's ${res.check.checked} lines agrees with the model, and the windows' counts sum to the model's (${R(modelTotal, 4)}).`
+            : `  CHECK FAILED: ${res.check.mismatches.length} line(s) disagree with the model — please report this.`] : []),
+        `  Viewer: ${target}`,
+        `  Open it in a browser. It contains rows of ${dataFile}, so treat it like the data file. Row numbers are data rows; add 1 for the spreadsheet row (header).`,
+        ...(res.windows.length > maxWindows ? [`  The viewer shows the first ${maxWindows} windows; window_rows lists the same.`] : []),
+    ].join('\n');
+
+    return {
+        model_id,
+        connection: connName,
+        units: selected.size,
+        windows: res.windows.length,
+        conversations: ctxUsed.size,
+        ...(conn != null && { count_check: { lines_checked: res.check.checked, mismatches: res.check.mismatches.length,
+                                              lines_total: R(linesTotal, 6), model_total: R(modelTotal, 6), match } }),
+        by_unit: [...byUnit.values()].map(b => ({ ...b, count: R(b.count, 6) })),
+        window_rows: res.windows.slice(0, maxWindows).map(w => ({
+            unit: unitPath(w.unit), response_row: fileRowOf(rows, w.response) + 1,
+            context_rows: w.members.map(r => fileRowOf(rows, r) + 1), ...(w.count != null && { count: R(w.count, 6) }),
+        })),
+        viewer: target,
+        summary,
+    };
+}
+
+async function toolExport(ena, { model_id, set_name, out_path }) {
+    const entry = cacheGet(modelCache, model_id);
+    if (!entry)
+        throw new Error(`Unknown model_id '${model_id}'. Fit the model first (ena_fit, ena_compare_groups or tma_fit).`);
+    const blockers = exportBlockers(entry);
+    if (blockers.length)
+        throw new Error(`Model ${model_id} can't be exported to the ENA Web Tool, which has no setting for: ${blockers.join('; ')}. ` +
+            'Refit without these to export it.');
+
+    const p = entry.params;
+    const unitCols = toArray(p.units);
+    const warnings = [];
+
+    // The web tool groups units by their first unit column; take that column's
+    // groups (order, colours) for the stored set.
+    let groups = [];
+    let groupCol = null;
+    if (unitCols.length > 1) {
+        groupCol = unitCols[0];
+        if (entry.groupCol === groupCol) {
+            groups = entry.web.groups.map(g => ({ name: g.name, color: g.color, secondaryColor: g.secondaryColor, showMean: g.showMean }));
+        } else {
+            const rows = loadRows(p);
+            groups = web.groupOrder(rows, groupCol).map((name, i) => ({ name, ...web.groupStyle(i) }));
+            if (entry.groupCol)
+                warnings.push(`The web tool groups units by ${groupCol}, so its plots show ${groupCol} groups, not ${entry.groupCol}.`);
+        }
+    }
+
+    // What the set opens with: the model's default view, when it names groups
+    // the web tool has.
+    const names = new Set(groups.map(g => g.name));
+    const asNode = (sel) => (sel?.kind === 'group' && names.has(sel.name) ? sel.name : null);
+    const plotted = { primary: asNode(entry.view?.first), secondary: asNode(entry.view?.second) };
+    if (!plotted.primary) plotted.secondary = null;
+
+    // The web tool's project holds a CSV; an .xlsx goes in as its first sheet.
+    const csvName = p.data_path ? basename(p.data_path).replace(/\.xlsx$/i, '.csv') : 'data.csv';
+    const csv = p.data_path
+        ? (isXlsx(p.data_path) ? Buffer.from(dataFileText(p.data_path), 'utf8') : readFileSync(p.data_path))
+        : Buffer.from(p.data_csv ?? '', 'utf8');
+    const setName = safeFileName(set_name ??
+        (plotted.secondary ? `${plotted.primary} vs ${plotted.secondary}` : `ENA model ${model_id}`));
+
+    // Excluded units (units_used): the web tool's Units tab excludes units the
+    // same way — their lines stay as context — so the set stores which.
+    // Built from the whole file: the web tool applies exclude_conversations
+    // and order_by itself (WasmWrapper._modelRowIndices), on the data file the
+    // ZIP carries unchanged.
+    const fileRows = loadRows({ data_path: p.data_path, data_csv: p.data_csv });
+    const exclConvos = toArray(p.exclude_conversations).map(e => String(e).split('__').join('::'));
+    let unitTree = null, excluded = 0;
+    if (p.units_used?.length || exclConvos.length) {
+        // With excluded horizons the full units tree goes in too: a partial one
+        // fails the web tool's unitsTreeMatchesModel(), and rebuilding the units
+        // rebuilds the conversation tree, which drops its include flags.
+        const used = p.units_used?.length ? new Set(p.units_used.map(String)) : null;
+        const seen = new Map();
+        for (const r of fileRows) {
+            const values = unitCols.map(c => String(r[c]));
+            const key = values.join('__');
+            if (!seen.has(key)) seen.set(key, { values, include: used ? used.has(key) : true });
+        }
+        unitTree = [...seen.values()];
+        excluded = unitTree.filter(u => !u.include).length;
+    }
+    let convoTree = null;
+    if (exclConvos.length) {
+        const convoCols = toArray(p.conversations);
+        const out = new Set(exclConvos);
+        const seen = new Map();
+        for (const r of fileRows) {
+            const values = convoCols.map(c => String(r[c]));
+            const key = values.join('::');
+            if (!seen.has(key)) seen.set(key, { values, include: !out.has(key) });
+        }
+        convoTree = [...seen.values()];
+    }
+
+    const set = web.setFile({
+        unitTree, convoTree, order: p.order_by ?? null,
+        codeMask: codeMaskOf(p, entry.kind === 'tma' ? (p.ordered ?? true) : false),
+        setName, csvName,
+        units: unitCols, conversation: toArray(p.conversations), codes: entry.codes,
+        groups, groupCol,
+        window: windowValue(p.window_size),
+        weightModel: p.weight_model ?? null,
+        sphereNorm: p.sphere_norm !== false,
+        ordered: entry.kind === 'tma' ? (p.ordered ?? true) : false,
+        rotation: exportRotation(entry),
+        plotted,
+        description: `Exported from ${PKG.name} ${PKG.version} (model ${model_id}).`,
+        source: { tool: PKG.name, version: PKG.version, model_id, exported: new Date().toISOString() },
+    });
+
+    const zipBuf = web.zip([
+        { name: csvName, data: csv },
+        { name: 'Folder/' },
+        { name: `Folder/${setName}.json`, data: JSON.stringify(set, null, 2) },
+    ]);
+
+    let target = out_path
+        ? (extname(out_path).toLowerCase() === '.zip' ? out_path : join(out_path, `${setName}.zip`))
+        : join(p.data_path ? dirname(p.data_path) : VIZ_DIR, `${setName}.zip`);
+    target = freePath(target);
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, zipBuf);
+
+    const rot = set.settings.model;
+    const settings = {
+        units: unitCols, conversations: toArray(p.conversations), codes: entry.codes,
+        window: rot.stanza === 'infinite' ? 'infinite' : rot.stanzaSize,
+        rotation: rotationLabel(p),
+        means_rotated_by: rot.meansRotatedBy,
+        weight_model: rot.weightModelBy, sphere_norm: rot.sphereNorm, ordered: rot.ordered,
+        groups: groups.map(g => `${g.name} ${g.color}`),
+        opens_with: plotted.primary ? (plotted.secondary ? `${plotted.primary} – ${plotted.secondary}` : plotted.primary) : 'nothing plotted',
+        ...(p.units_used?.length && { excluded_units: excluded }),
+        ...(convoTree && { excluded_conversations: exclConvos }),
+        ...(p.order_by && { order_by: p.order_by }),
+        ...(toArray(p.mask_connections).length && { masked_connections: toArray(p.mask_connections) }),
+    };
+    const summary = [
+        `Exported model ${model_id} as an ENA Web Tool project: ${target}`,
+        `  Set: Folder / ${setName}   Data: ${csvName}`,
+        `  Opens with: ${settings.opens_with}`,
+        ...warnings.map(w => `  Note: ${w}`),
+        '',
+        'To open it: start a local session in the ENA Web Tool ("Run Offline"), click Import in the Sets panel,',
+        `choose the ZIP, then open Folder › ${setName}. (Project import works in local sessions only.)`,
+    ].join('\n');
+
+    return {
+        zip_path: target,
+        set_name: setName,
+        data_file: csvName,
+        settings,
+        warnings,
+        privacy_note: 'The ZIP contains your data file. It was written on this machine; no rows were sent to Claude.',
+        summary,
+    };
+}
+
+// ── Tool schemas ──────────────────────────────────────────────────────────────
+
+const DATA_PROPS = {
+    data_path: {
+        type: 'string',
+        description:
+            'Absolute path to a .csv or .xlsx file on the user\'s machine (for .xlsx, the first worksheet, as in the ENA Web Tool). ' +
+            '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:         { type: ['string', 'array'], items: { type: 'string' }, 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: { type: ['string', 'array'], items: { type: 'string' }, 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', 'string'], description: 'Stanza window — rows to look back. Omitted: the Cross-Covariance Decay estimate (as ena_window gives, and as a new set in the ENA Web Tool takes), or 4 when the data is too sparse for one. Pass "Inf" for an infinite window (= rENA window.size.back = Inf): each line connects to every earlier line in its conversation. Use ena_window to estimate a window size from the data.' },
+    binary:        { type: 'boolean', description: 'Binarise co-occurrences (default true)' },
+    weight_model:  { type: 'string', enum: ['product', 'sqrt', 'log'], description: 'Weight each line\'s co-occurrence counts before they are summed per unit (= rENA weight.by / tma weight_by): "product" keeps raw counts, "sqrt" square root, "log" log(1 + x). Omit for the default (binary per line; raw directed counts for ordered models). Overrides binary.' },
+    units_used:    { type: 'array', items: { type: 'string' }, description: 'Model only these units (= rENA units.used), as unit labels — the unit column values joined with "__", as returned in units. Other units\' rows stay in the data as context in the modeled units\' windows but get no network. Unlike dropping rows, this keeps e.g. teacher talk as context for student units.' },
+    mask_connections: { type: 'array', items: { type: 'string' }, description: 'Connections to switch off, as in connection_names, e.g. ["Data & Technical Constraints"] — the ENA Web Tool\'s Code Masking Matrix. A masked connection counts as 0 for every unit before normalization and rotation. Undirected models: either order of the two codes. Ordered (tma_fit) models: "A & B" masks A → B only.' },
+    exclude_conversations: { type: 'array', items: { type: 'string' }, description: 'Conversations to leave out, named by their conversation column values joined by :: (e.g. "FirstGame::Electric"). Their lines are removed from the data before anything else — not modeled and not context — as the ENA Web Tool\'s former R backend did for excluded horizons.' },
+    order_by:      { type: 'string', description: 'Column to order the lines by before windowing (the web tool\'s Order setting): rows are sorted by it, ascending and stable, so ties keep file order; numeric if every value is a number. Default: file order. Row numbers in results still refer to the file.' },
+};
+
+// Fit-only options (ena_fit, ena_compare_groups, tma_fit).
+const FIT_PROPS = {
+    sphere_norm:   { type: 'boolean', description: 'Sphere-normalize each unit network (default true). false scales all networks by the longest one instead (= rENA fun_skip_sphere_norm; ona normalize = skip_sphere_norm), keeping differences in network size.' },
+    center_align_to_origin: { type: 'boolean', description: 'Keep units with an all-zero network at the origin and out of the centering mean (default true, = rENA center.align.to.origin). false centers on every unit. Unordered models only; ordered models always center as ona::model() does.' },
+};
+
+// Rotation parameters shared by ena_fit and tma_fit.
+const ROTATION_PROPS = {
+    rotation_from:   { type: 'string', description: 'model_id of a fitted model to project this one into — the ENA Web Tool\'s "Use Rotation Matrix From" (= rENA rotation.set): this model\'s units are centred and rotated by the source\'s rotation and drawn with its node positions, so both models share one space (e.g. a second cohort, a post-test). Needs the same codes and the same kind of network (ordered or not). Replaces rotation.' },
+    rotation:        { type: 'string', enum: ['svd', 'mean', 'generalized'], description: '"svd", "mean" (requires group_col, group1_value, group2_value) or "generalized" — generalized means rotation, GMR (= rENA ena.rotate.by.generalized; requires x_var). Omitted: as the ENA Web Tool rotates — with two or more unit columns and two or more values in the first, a GMR through that column\'s first two groups in data order (or group1_value / group2_value when group_col is that column); otherwise "svd".' },
+    x_var:           { type: ['string', 'array'], items: { type: 'string' }, description: 'For rotation="generalized": unit-level metadata column(s) — one value per unit, none missing. The first is the target that dimension 1 (GMR1) is built to represent: categorical (axis through the group means) or numeric (axis along the variable). Further columns are covariates, controlled for by Lasso.' },
+    y_var:           { type: ['string', 'array'], items: { type: 'string' }, description: 'For rotation="generalized", optional: same format as x_var; builds dimension 2 (GMR2) for a second target instead of the next SVD dimension.' },
+    select_2_groups: { type: 'array', items: { type: 'string' }, minItems: 2, maxItems: 2, description: 'For rotation="generalized" with a categorical target: fit GMR1 on these two target values only (other units are still projected). Also colours the plot and runs the group tests on these two groups unless group_col is given.' },
+    interactions:    { type: 'boolean', description: 'For rotation="generalized" with covariates: include pairwise interaction terms in the Lasso model (default true, as in rENA). false for main effects only.' },
+};
+
+// ── Analysis guide ────────────────────────────────────────────────────────────
+// The ena-analysis skill ships inside the package and is served by ena_guide,
+// so every MCP client gets the workflow without installing the skill
+// separately. Sections are the skill's "## " headings.
+
+const GUIDE = (() => {
+    let md;
+    try { md = readFileSync(new URL('./skill/ena-analysis/SKILL.md', import.meta.url), 'utf8'); }
+    catch { return null; }
+    md = md.replace(/^---\n[\s\S]*?\n---\n+/, '');                 // frontmatter
+    const sections = [];
+    for (const part of md.split(/^(?=## )/m).slice(1)) {
+        const heading = part.match(/^## (.*)/)[1].trim();
+        const topic = heading.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+        sections.push({ topic, heading, text: part.trim() });
+    }
+    return { text: md.trim(), sections };
+})();
+const GUIDE_TOPICS = GUIDE?.sections.map(s => s.topic) ?? [];
+
+function toolGuide({ topic } = {}) {
+    if (!GUIDE) throw new Error('The analysis guide is missing from this installation (skill/ena-analysis/SKILL.md).');
+    const footer = `\n\n---\nTopics: ${GUIDE_TOPICS.join(', ')}`;
+    if (!topic) return GUIDE.text + footer;
+    const t = String(topic).toLowerCase().trim();
+    const hit = GUIDE.sections.find(s => s.topic === t)
+        ?? GUIDE.sections.find(s => s.topic.includes(t.replace(/[^a-z0-9]+/g, '-')));
+    if (!hit) throw new Error(`Unknown topic. Topics: ${GUIDE_TOPICS.join(', ')}`);
+    return hit.text + footer;
+}
+
+const TOOLS = [
+    {
+        name: 'ena_guide',
+        description:
+            'The ENA analysis guide: how to run an ENA / ONA / TMA analysis with these tools — the privacy gate, triage, choosing a window, ' +
+            'fitting and comparing groups, rotations (means, generalized, projection), masking, simplifying, ONA/TMA, tables, the lines behind a ' +
+            'connection, export, and reading the results. Call it once with no arguments before the first analysis in a conversation; ' +
+            'pass topic for one section.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                topic: { type: 'string', enum: GUIDE_TOPICS.length ? GUIDE_TOPICS : undefined, description: 'One section of the guide (default: the whole guide).' },
+            },
+        },
+    },
+    {
+        name: 'ena_profile',
+        description:
+            'PRIVACY-SAFE dataset profiler: reads a CSV or .xlsx file from the local file system and returns only column metadata ' +
+            '(column names, unique-value counts, binary detection, and the distinct labels of low-cardinality columns ' +
+            '— at most 10 values, e.g. condition names — so group values can be chosen). ' +
+            'No row-level values (text, names, IDs, timestamps) are 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 or .xlsx file on the user\'s machine (.xlsx: the first worksheet).',
+                },
+            },
+            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. ' +
+            'When ena_recommended is false, the result includes a "guidance" field explaining why the data is not ENA-shaped ' +
+            '(e.g. no binary code columns) and what would be needed — relay this to the user rather than silently failing or ' +
+            'claiming the connector is unavailable. ' +
+            '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", rotation="mean" (requires group_col, group1_value, group2_value), or rotation="generalized" (GMR: dimension 1 built to represent a unit-level variable given by x_var, controlling for covariates; optional second target y_var); omitted, it rotates as the ENA Web Tool does (see rotation). ' +
+            'Includes a stats block (per dimension: Welch t-test, Cohen\'s d, Mann-Whitney U with effect size r, group means/SDs/medians) whenever group_col, group1_value and group2_value are given — which a default rotation by groups fills in. ' +
+            'Defaults and plots follow the ENA Web Tool, so the model and its plot match it there (see ena_export): ' +
+            'the plot is the web tool\'s comparison plot — points scaled to the network, group means with 95% CI boxes, ' +
+            'group colours #cc423a, #218ebf, … in data order, and group 1 − group 2 when two groups are named. ' +
+            'The ENA network plot is written to disk as SVG (svg_plot) and interactive HTML (interactive_plot), and — when the optional PNG rasterizer is installed — also as PNG (png_plot) plus an inline image block. Use these paths to show the plot; 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)' },
+                ...FIT_PROPS,
+                ...ROTATION_PROPS,
+                group_col:     { type: 'string', description: 'Metadata column for group membership (required for rotation="mean"; enables group/subtraction plots). Defaults to the first unit column when there are two or more, as the ENA Web Tool groups units.' },
+                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_window',
+        description:
+            'Estimate the stanza window size from the data by Cross-Covariance Decay (= rENA ena.ccd): how many lines back ' +
+            'co-occurrence between codes stays above noise. Runs on the coded lines within each conversation — no model is fitted. ' +
+            'Use before ena_fit / tma_fit when the user has no theoretically motivated window size, and report the estimate ' +
+            'and curve so the choice is transparent. ' +
+            'PRIVACY: use data_path rather than data_csv.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...DATA_PROPS,
+                conversations: CORE_PROPS.conversations,
+                codes:         CORE_PROPS.codes,
+                exclude_conversations: CORE_PROPS.exclude_conversations,
+                order_by:      CORE_PROPS.order_by,
+                max_window:    { type: 'number', description: 'Largest lag to evaluate (default 20)' },
+                min_overlap:   { type: 'number', description: 'Minimum overlapping lines per conversation at a lag (default 10)' },
+            },
+            required: ['conversations', 'codes'],
+        },
+    },
+    {
+        name: 'tma_fit',
+        description:
+            'Fit a full TMA (Transmodal Analysis) or ONA (Ordered Network Analysis) model using context tensor accumulation and directed networks. ' +
+            'Returns a model_id that can be passed to ena_plot. ' +
+            'Supports rotation="svd", rotation="mean" (requires group_col, group1_value, group2_value), or rotation="generalized" (GMR: dimension 1 built to represent a unit-level variable given by x_var, controlling for covariates; optional second target y_var); omitted, it rotates as the ENA Web Tool does (see rotation). ' +
+            'Includes a stats block (per dimension: Welch t-test, Cohen\'s d, Mann-Whitney U with effect size r, group means/SDs/medians) whenever group_col, group1_value and group2_value are given. ' +
+            'Plots follow the ENA Web Tool, as for ena_fit.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...CORE_PROPS,
+                stanza_ground:    { type: 'array', items: { type: 'string' }, description: 'Column name(s) representing sender/ground roles.' },
+                stanza_response:  { type: 'array', items: { type: 'string' }, description: 'Column name(s) representing receiver/response roles.' },
+                stanza_modality:  { type: ['string', 'array'], items: { type: 'string' }, description: 'Column name(s) representing modalities/modes.' },
+                window_type:      { type: 'string', enum: ['lines', 'time', 'time_duration'], description: 'Measure windows in lines (default) or in time ("time", with time_column and time_unit)' },
+                time_column:      { type: 'string', description: 'Timestamp column for timing windows' },
+                time_unit:        { type: 'string', enum: ['secs', 'mins', 'hours', 'days', 'weeks'], description: 'Unit of window_size and override windows for time-based windows (default secs). Numeric time columns are used as-is; others are parsed as elapsed time (MM:SS, HH:MM:SS) or a date-time.' },
+                horizons:         {
+                    type: 'object',
+                    description: 'Flexible horizons of observation (= tma contexts() with HOO rules): each unit sees its own horizon instead of the conversations. by is a discriminator column; rules maps each of its values to the columns that define that horizon — a row is in unit U\'s horizon when each of those columns holds a value U has. Rows whose by value has no rule are left out. Example: { "by": "Modality", "rules": { "chat": ["GroupName"], "log": ["UserName"] } } — chat lines are seen by the whole group, log lines only by their author.',
+                    properties: {
+                        by:    { type: 'string' },
+                        rules: { type: 'object', additionalProperties: { type: 'array', items: { type: 'string' } } },
+                    },
+                    required: ['by', 'rules'],
+                },
+                stanza_overrides: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            path:   { type: 'array', items: { type: 'string' }, description: 'Combination values path' },
+                            weight: { type: 'number', description: 'Weight override' },
+                            window: { type: ['number', 'string'], description: 'Window override (a number, or "Inf")' },
+                        },
+                        required: ['path'],
+                    },
+                },
+                ordered:       { type: 'boolean', description: 'Directed networks (defaults to true for TMA/ONA)' },
+                dims:          { type: 'number', description: 'Dimensions to return (default 2)' },
+                ...FIT_PROPS,
+                ...ROTATION_PROPS,
+                group_col:     { type: 'string', description: 'Metadata column for group membership (required for rotation="mean"; enables group/subtraction plots). Defaults to the first unit column when there are two or more, as the ENA Web Tool groups units.' },
+                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: 'tma_accumulate',
+        description:
+            'Run only the TMA / ONA context tensor accumulation step — no rotation or projection. ' +
+            'Returns raw per-unit directed co-occurrence networks and top connections.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...CORE_PROPS,
+                stanza_ground:    { type: 'array', items: { type: 'string' }, description: 'Column name(s) representing sender/ground roles.' },
+                stanza_response:  { type: 'array', items: { type: 'string' }, description: 'Column name(s) representing receiver/response roles.' },
+                stanza_modality:  { type: ['string', 'array'], items: { type: 'string' }, description: 'Column name(s) representing modalities/modes.' },
+                window_type:      { type: 'string', enum: ['lines', 'time', 'time_duration'], description: 'Measure windows in lines (default) or in time ("time", with time_column and time_unit)' },
+                time_column:      { type: 'string', description: 'Timestamp column for timing windows' },
+                time_unit:        { type: 'string', enum: ['secs', 'mins', 'hours', 'days', 'weeks'], description: 'Unit of window_size and override windows for time-based windows (default secs). Numeric time columns are used as-is; others are parsed as elapsed time (MM:SS, HH:MM:SS) or a date-time.' },
+                horizons:         {
+                    type: 'object',
+                    description: 'Flexible horizons of observation (= tma contexts() with HOO rules): each unit sees its own horizon instead of the conversations. by is a discriminator column; rules maps each of its values to the columns that define that horizon — a row is in unit U\'s horizon when each of those columns holds a value U has. Rows whose by value has no rule are left out. Example: { "by": "Modality", "rules": { "chat": ["GroupName"], "log": ["UserName"] } } — chat lines are seen by the whole group, log lines only by their author.',
+                    properties: {
+                        by:    { type: 'string' },
+                        rules: { type: 'object', additionalProperties: { type: 'array', items: { type: 'string' } } },
+                    },
+                    required: ['by', 'rules'],
+                },
+                stanza_overrides: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            path:   { type: 'array', items: { type: 'string' }, description: 'Combination values path' },
+                            weight: { type: 'number', description: 'Weight override' },
+                            window: { type: ['number', 'string'], description: 'Window override (a number, or "Inf")' },
+                        },
+                        required: ['path'],
+                    },
+                },
+                ordered:       { type: 'boolean', description: 'Directed networks (defaults to true for TMA/ONA)' },
+            },
+            required: ['units', 'conversations', 'codes'],
+        },
+    },
+    {
+        name: 'ena_compare_groups',
+        description:
+            'Fit an ENA model rotated through two groups and compare them. ' +
+            'The rotation is the ENA Web Tool\'s for grouped units: a GMR whose dimension 1 (GMR1) passes through the two group means, group 1 the reference — the same axes as a means rotation. ' +
+            'Defaults and plots follow the ENA Web Tool, so the model and its plot match it there (see ena_export): ' +
+            'the plot is the web tool\'s comparison plot — points scaled to the network, group means with 95% CI boxes, ' +
+            'group colours #cc423a, #218ebf, … in data order, and group 1 − group 2 when two groups are named. ' +
+            'Returns a stats block testing the groups on each dimension (Welch t-test, Cohen\'s d, Mann-Whitney U with effect size r). ' +
+            'Returns a model_id for use with ena_plot (group, subtraction, comparison, unit views). ' +
+            'Repeated calls with identical parameters return the cached model instantly. ' +
+            'The ENA network plot is written to disk as SVG (svg_plot) and interactive HTML (interactive_plot), and — when the optional PNG rasterizer is installed — also as PNG (png_plot) plus an inline image block. Use these paths to show the plot; 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)' },
+                ...FIT_PROPS,
+            },
+            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 and group means, with the mean network of every unit; ' +
+            '"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 (the web tool\'s comparison plot), edges in the colour of the group they are stronger in (requires group1, group2, and groups on the source model); ' +
+            '"unit" — individual unit network (requires unit_label). ' +
+            'Every view draws the unit points and group means as the ENA Web Tool\'s comparison plot does. ' +
+            'Display options match the web tool\'s Plot Settings (minimum edge weight, unconnected codes, text size, group colours, CI and outlier boxes); they change only the drawing. ' +
+            'The interactive HTML has its own controls for the same settings, so for fine-tuning point the user to it rather than re-plotting repeatedly. ' +
+            'The ENA network plot is written to disk as SVG (svg_plot) and interactive HTML (interactive_plot), plus PNG (png_plot) and an inline image when the optional PNG rasterizer is installed.',
+        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"' },
+                magnify:     { type: 'number', description: 'The web tool\'s "Scale edge weights" (default 1): multiplies edge widths and node sizes, not colour; the plot is titled "(scaled N.Nx)". A subtraction\'s strongest edge is always drawn 4 px wide, as in the web tool, so magnify only grows its nodes.' },
+                x_dim:       { type: 'integer', minimum: 1, description: 'Dimension on the x-axis (default 1). Fits keep up to 6 dimensions, as the ENA Web Tool does, so e.g. x_dim=1, y_dim=3 shows SVD1 against SVD3.' },
+                y_dim:       { type: 'integer', minimum: 1, description: 'Dimension on the y-axis (default 2).' },
+                flip_x:      { type: 'boolean', description: 'Mirror the x-axis (the web tool\'s Flip X): points, nodes and means change sides; the model is unchanged.' },
+                flip_y:      { type: 'boolean', description: 'Mirror the y-axis (the web tool\'s Flip Y).' },
+                min_edge_weight: { type: 'number', minimum: 0, description: 'Hide connections whose |weight| is below this (the web tool\'s Minimum edge weight). Weights are on the plotted network\'s own scale — the result reports max_edge_weight; group means are rescaled to 0.1–1. Use it when a network is too dense to read ("hide the weak connections").' },
+                hide_unconnected_codes: { type: 'boolean', description: 'Hide codes with no drawn connection (the web tool\'s Show unconnected codes, off). Pairs well with min_edge_weight.' },
+                text_size:   { type: 'number', minimum: 6, maximum: 48, description: 'Label size in px (default 12), e.g. 16–20 for slides.' },
+                colors:      { type: 'object', additionalProperties: { type: 'string' }, description: 'Group colours: { "<group>": "<colour>" }, as #rgb, #rrggbb or a CSS colour name (orange, steelblue, ...). Colours the group\'s points, mean and network.' },
+                confidence_intervals: { type: 'boolean', description: 'Draw the 95% confidence-interval boxes around group means (default true).' },
+                outlier_intervals:    { type: 'boolean', description: 'Draw the outlier boxes (Tukey fences, 1.5 × IQR) around group means (default false).' },
+            },
+            required: ['model_id'],
+        },
+    },
+    {
+        name: 'ena_simplify',
+        description:
+            'Simplify a model with PRIA — the ENA Web Tool\'s "Simplify Model" (= R\'s PRIA::pria): find the largest set of codes, up to remove_num and never ' +
+            'leaving fewer than 3, that can be removed while the model stays within threshold of the full one. Runs with the model\'s own settings; if codes ' +
+            'can go, refits without them (window and every other setting unchanged) and returns the new model, with removed_codes and kept_codes. ' +
+            'Needs more than 3 codes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                model_id:   { type: 'string', description: 'model_id from ena_fit, ena_compare_groups or tma_fit' },
+                threshold:  { type: 'number', minimum: 0.8, maximum: 0.99, description: 'How close the simplified model must stay to the full one (default 0.95; the web tool allows 0.80–0.99).' },
+                remove_num: { type: 'integer', minimum: 1, description: 'Most codes to remove (default 3).' },
+            },
+            required: ['model_id'],
+        },
+    },
+    {
+        name: 'ena_lines',
+        description:
+            'Show the lines behind a connection — the ENA Web Tool\'s Data View, for closing the interpretive loop. ' +
+            'Writes a local HTML viewer of every line that contributed to the connection for the chosen units or group, each with the window ' +
+            'of lines it was connected to, grouped by conversation, with the connection\'s codes highlighted (and direction for ordered models). ' +
+            'The lines are exactly the ones the model counted (from its own per-line counts), for ENA, ONA and TMA; a check against the model is reported. ' +
+            'Returns the viewer\'s path, counts and data-row numbers — never the text. The viewer contains rows of the data file: tell the user to open it ' +
+            'in a browser; do not open, read or summarize it yourself. Omit connection to show all of the selection\'s lines.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                model_id:    { type: 'string', description: 'model_id from ena_fit, ena_compare_groups or tma_fit' },
+                connection:  { type: 'string', description: 'Connection as in connection_names, e.g. "Data & Design Reasoning" (for ordered models "A & B" is A → B). Omit for all lines.' },
+                units:       { type: 'array', items: { type: 'string' }, description: 'Unit labels to show (as in the results, e.g. "FirstGame::steven z").' },
+                group:       { type: 'string', description: 'All units of this group (one of the model\'s groups). Use units or group.' },
+                columns:     { type: 'array', items: { type: 'string' }, description: 'Extra columns to show, e.g. the text column (the web tool\'s "add metadata column"). By default: unit, conversation and code columns; every column can be switched on in the viewer.' },
+                max_windows: { type: 'integer', minimum: 1, description: 'Most windows to put in the viewer and window_rows (default 500).' },
+                out_path:    { type: 'string', description: 'A .html path or a folder. Default: next to the data file, never overwriting.' },
+            },
+            required: ['model_id'],
+        },
+    },
+    {
+        name: 'ena_tables',
+        description:
+            'Write a fitted model\'s data tables as CSV files for R, Excel or a paper — the ENA Web Tool\'s "Download Model" tables: ' +
+            'nodes.csv (code positions per dimension), points.csv (unit points per dimension), line-weights.csv (normalized networks, one "A & B" column per connection) ' +
+            'and connection-counts.csv (raw accumulated counts). The last two lead with ENA_UNIT and the unit columns. ' +
+            'Takes a model_id from ena_fit, ena_compare_groups or tma_fit; writes a new folder (by default next to the data file, never overwriting one) and returns only the paths. ' +
+            'The tables hold unit labels and model values, not rows of the data file.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                model_id: { type: 'string', description: 'model_id of the model' },
+                out_path: { type: 'string', description: 'Folder to create for the CSVs. Default: "ENA model <id> tables" next to the data file (a number is added rather than overwrite).' },
+            },
+            required: ['model_id'],
+        },
+    },
+    {
+        name: 'ena_export',
+        description:
+            'Export a fitted model (model_id from ena_fit, ena_compare_groups or an ordered tma_fit) as an ENA Web Tool project ZIP: ' +
+            'the data file plus a set holding every setting that produced the model (units, conversations, codes, window, rotation, weight model, ' +
+            'sphere normalization), the group colours, and the plot it opens with. Imported in the web tool (local session → Sets → Import), ' +
+            'it rebuilds the same model and opens on the same comparison plot. ' +
+            'Excluded units (units_used) are stored as excluded in the web tool\'s Units tab. Models the web tool has no setting for (transmodal or time windows, a GMR on x_var, rotations by a column other than the first unit column, ' +
+            'center_align_to_origin=false) are refused with the reason. ' +
+            'PRIVACY: the ZIP contains the data file. It is written locally (by default next to the data file, never overwriting one) and no rows are sent to Claude.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                model_id: { type: 'string', description: 'model_id of the model to export' },
+                set_name: { type: 'string', description: 'Name of the set in the web tool (default: "<group 1> vs <group 2>", or "ENA model <id>")' },
+                out_path: { type: 'string', description: 'Where to write: a .zip path, or a folder. Default: the data file\'s folder, as "<set name>.zip" (a number is added rather than overwrite).' },
+            },
+            required: ['model_id'],
+        },
+    },
+];
+
+// ── Server setup ──────────────────────────────────────────────────────────────
+
+const PKG = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8'));
+const RENA_VERSION = (() => {
+    try { return JSON.parse(readFileSync(_require.resolve('@qe-libs/rena-wasm/package.json'), 'utf8')).version; }
+    catch { return 'unknown'; }
+})();
+// Stamped on every result and plot, so results from this server can be told
+// apart from anything computed in the conversation.
+const PROVENANCE = `${PKG.name} ${PKG.version} (rena-wasm ${RENA_VERSION})`;
+
+// Appended to every tool error. When a tool fails, the model must not make
+// up the analysis some other way and present it as ENA.
+const NO_SUBSTITUTE =
+    'Do not work around this error by doing the analysis yourself: no accumulation, rotation, projection, ' +
+    'statistics or network plots computed in code (Python, R, JavaScript, a notebook or by hand), and no ' +
+    'estimated, approximate or illustrative results. Fix the call using the message above and retry, or tell ' +
+    'the user what failed and stop. Every ENA result shown to the user must come from these tools.';
+
+// Tool errors go back to the model, so they must not carry values read from
+// the data file (rena-wasm quotes the offending value, e.g. a code cell or a
+// time it could not parse). Quoted strings are withheld unless the model
+// passed them in itself — column names and other arguments stay readable.
+const WITHHELD = '[value withheld]';
+function withholdDataValues(msg, args) {
+    const known = new Set(['Inf']);
+    const collect = (v) => {
+        if (typeof v === 'string' || typeof v === 'number') known.add(String(v));
+        else if (Array.isArray(v)) v.forEach(collect);
+        else if (v && typeof v === 'object') Object.entries(v).forEach(([k, x]) => { known.add(k); collect(x); });
+    };
+    collect(args);
+    // A quote opens after a boundary and closes before one, so apostrophes
+    // inside words ("don't", "units'") are left alone.
+    return String(msg).replace(/(^|[\s(=:,\[])(["'])([^"'\n]{0,200})\2(?=$|[\s).,:;\]])/g,
+        (m, pre, q, inner) => (known.has(inner) ? m : `${pre}${q}${WITHHELD}${q}`));
+}
+
+// Sent to the client at connection; MCP clients (Claude, Codex, Gemini CLI,
+// Cursor, ...) pass it to the model, so the privacy rule reaches every one.
+const SERVER_INSTRUCTIONS = [
+    'ENA / ONA / TMA analysis that runs locally on the user\'s machine.',
+    '',
+    'Data privacy — follow in every conversation:',
+    '- Pass data files to these tools with data_path. The server reads the file locally; the raw rows never need to enter the conversation.',
+    '- Do not open, read, print, cat, head or summarize the data file yourself with any other tool (file readers, shells, code execution). Learn its structure with ena_profile (column names, counts, binary detection; values only for columns with at most 10 distinct values) or ena_inspect.',
+    '- Do not ask the user to paste their data. If they offer to, ask for the file path instead. data_csv is for small demo or toy data only.',
+    '- Ask whether the data is sensitive before the first analysis; if it is, start with ena_profile.',
+    '- Results include unit labels (the values of the unit columns, often participant names or IDs) and group values. If those are identifying, tell the user before fitting so they can pseudonymize the file first.',
+    '- ena_export writes a ZIP that contains the data file itself, for the ENA Web Tool. Tell the user so before they share it.',
+    '- ena_lines writes an HTML viewer that contains rows of the data file. Give the user its path to open in a browser; never open, read or summarize it yourself.',
+    '',
+    'Results come only from these tools — follow in every conversation:',
+    '- Every ENA, ONA or TMA result shown to the user (accumulated networks, points, rotations, statistics, plots) must come from these tools. Do not compute any part of an ENA analysis yourself — in code, a notebook, R, Python or by hand — and do not draw ENA-style network plots of your own.',
+    '- If a tool fails, read its error, fix the call and retry, or tell the user what failed and stop. Never fill the gap with a substitute that looks like ENA, and never present estimated or illustrative numbers as results.',
+    '- If the user wants something these tools cannot do, say so, and suggest rENA in R or the ENA Web Tool, rather than improvising it.',
+    `- Results carry provenance ("${PKG.name} <version>"); anything without it did not come from this server.`,
+    '',
+    'Before the first analysis in a conversation, call ena_guide (no arguments) for the analysis workflow: triage, window, rotations, masking, ONA/TMA and reading the results. ena_guide with a topic returns one section.',
+].join('\n');
+
+// MCP prompts — slash commands / templates in clients that support them.
+const PROMPTS = [
+    {
+        name: 'analyze_data',
+        description: 'Analyze a coded data file with ENA, following the analysis guide.',
+        arguments: [
+            { name: 'data_path', description: 'Absolute path to the .csv or .xlsx file', required: true },
+            { name: 'question',  description: 'What you want to learn (optional)', required: false },
+        ],
+        text: a => `Analyze the data at ${a.data_path} with Epistemic Network Analysis.` +
+            (a.question ? ` My question: ${a.question}` : '') +
+            ' Call ena_guide first and follow it: ask me whether the data is sensitive, learn its structure with ena_profile or ena_inspect, estimate a window, fit, plot, and interpret the result.',
+    },
+    {
+        name: 'compare_groups',
+        description: 'Compare two groups\' networks with ENA: means rotation, difference plot and statistics.',
+        arguments: [
+            { name: 'data_path',    description: 'Absolute path to the .csv or .xlsx file', required: true },
+            { name: 'group_column', description: 'Column that holds the groups (optional)', required: false },
+        ],
+        text: a => `Compare the groups in ${a.data_path}` +
+            (a.group_column ? ` (groups in the ${a.group_column} column)` : '') +
+            ' with ENA. Call ena_guide first and follow it: ask me whether the data is sensitive, profile the data, fit with ena_compare_groups, show the difference plot, and report the group statistics and which connections drive the difference.',
+    },
+    {
+        name: 'order_and_sequence',
+        description: 'Model order and sequence with directed ONA / transmodal TMA networks.',
+        arguments: [
+            { name: 'data_path', description: 'Absolute path to the .csv or .xlsx file', required: true },
+        ],
+        text: a => `Analyze order and sequence in ${a.data_path} with directed (ONA) or transmodal (TMA) networks.` +
+            ' Call ena_guide with topic "ordered-and-transmodal-networks-ona-tma" first and follow it, after asking me whether the data is sensitive.',
+    },
+];
+
+const server = new Server(
+    { name: 'ena', version: PKG.version },
+    { capabilities: { tools: {}, prompts: {} }, instructions: SERVER_INSTRUCTIONS }
+);
+
+// ── rena-wasm API adapter ─────────────────────────────────────────────────────
+// rena-wasm ≥ the R-mirroring rewrite returns an R-style ENA set object
+// (lineWeights / points / rotation.nodes / model.unitLabels) instead of the
+// original flat object (networks / centroids / positions / unitLabels).
+// These shims expose the flat field names this server is written against, and
+// are idempotent no-ops on the older flat API.
+
+function adaptModel(m) {
+    if (!m) return m;
+    let mClean = m;
+    if (m.lineWeights !== undefined && m.networks === undefined) {
+        mClean = {
+            networks:        m.lineWeights,          // sphere-normed adjacency (nUnits × nConn)
+            centroids:       m.points,               // projected unit positions (nUnits × dims)
+            positions:       m.rotation?.nodes,      // code node positions (nCodes × dims)
+            connectionNames: m.connectionNames,
+            unitLabels:      m.model?.unitLabels ?? m.unitLabels,
+            columnNames:     m.rotation?.columnNames,
+            eigenvalues:     m.rotation?.eigenvalues,
+            variance:        m.model?.variance,     // share of total variance per dim (rena-wasm >= 0.1.11)
+            rotationMatrix:  m.rotationMatrix,      // nConn × dims, for rotation_from
+            centerVec:       m.rotation?.centerVec, // for rotation_from
+            networkCentroids: m.model?.centroids,   // network centroids (nUnits × dims), for goodness of fit
+            connectionCounts: m.connectionCounts,   // raw accumulated counts (nUnits × nConn), for ena_tables
+            rowConnectionCounts: m.rowConnectionCounts ?? m.model?.rowConnectionCounts, // per line (nRows × nConn), for ena_lines
+            nUnits:          m.nUnits,
+            nConnections:    m.nConnections,
+            dims:            m.dims,
+        };
+    }
+
+    // Ordered (ONA/TMA) models have n² directed connections. rena-wasm already
+    // names them in network column order ("ground & response", column j*n + i =
+    // codes[i] → codes[j]), so the names are kept as-is — only flag direction.
+    const nCodes = m.rotation?.codes?.length;
+    if (nCodes > 1 && mClean.nConnections === nCodes * nCodes) mClean.ordered = true;
+
+    return mClean;
+}
+
+function adaptAccum(a) {
+    if (!a) return a;
+    if (a.networks === undefined && a.connectionCounts !== undefined) {
+        return { ...a, networks: a.connectionCounts };
+    }
+    return a;
+}
+
+// A WASM abort (raised by libqe on a degenerate SVD / means rotation) leaves the
+// module instance unusable — every later call would also abort. Detect it,
+// discard the cached instance so the next call reloads a fresh one, and surface
+// an actionable message instead of the raw "Aborted(undefined)".
+function isWasmAbort(e) {
+    return /abort|RuntimeError|out of bounds|memory access|table index/i.test(e?.message ?? '');
+}
+
+const DEGENERATE_FIT_MSG =
+    'ENA rotation could not be computed — the data is too sparse or degenerate. ' +
+    'Common causes: fewer than 2 units have any code co-occurrences within the ' +
+    'stanza window; only one code column; or all units have identical networks. ' +
+    'Use ena_accumulate to inspect the raw co-occurrence networks, and check that ' +
+    'you have 2+ code columns that actually co-occur and 2+ units with non-empty networks.';
+
+let enaPromise = null;
+function getENA() {
+    if (!enaPromise) enaPromise = loadENA().then(ena => {
+        const guard = (fn, adapt) => (rows, opts) => {
+            try {
+                return adapt(fn.call(ena, rows, opts));
+            } catch (e) {
+                if (isWasmAbort(e)) {
+                    enaPromise = null;              // force a fresh WASM instance next call
+                    throw new Error(DEGENERATE_FIT_MSG);
+                }
+                throw e;
+            }
+        };
+        return {
+            ...ena,
+            fit:        guard(ena.fit,        adaptModel),
+            accumulate: guard(ena.accumulate, adaptAccum),
+        };
+    });
+    return enaPromise;
+}
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: PROMPTS.map(({ text, ...p }) => p),
+}));
+
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: a = {} } = request.params;
+    const p = PROMPTS.find(x => x.name === name);
+    if (!p) throw new Error(`Unknown prompt: ${name}`);
+    for (const arg of p.arguments)
+        if (arg.required && !a[arg.name]) throw new Error(`Missing argument: ${arg.name}`);
+    return {
+        description: p.description,
+        messages: [{ role: 'user', content: { type: 'text', text: p.text(a) } }],
+    };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        // rena-wasm windows look backward only (= rENA's window.size.back); a
+        // forward window would otherwise be silently ignored.
+        if (Number(args?.window_forward) > 0)
+            throw new Error('window_forward is not supported by the WASM backend — ' +
+                'stanza windows look backward only. Omit it, or use rENA in R for forward windows.');
+        // The guide is markdown; return it as-is, not JSON-encoded.
+        if (name === 'ena_guide') return { content: [{ type: 'text', text: toolGuide(args) }] };
+        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 === 'tma_fit')            result = await toolTmaFit(ena, args);
+            else if (name === 'ena_accumulate')      result = await toolAccumulate(ena, args);
+            else if (name === 'tma_accumulate')      result = await toolTmaAccumulate(ena, args);
+            else if (name === 'ena_compare_groups')  result = await toolCompareGroups(ena, args);
+            else if (name === 'ena_window')          result = await toolWindow(ena, args);
+            else if (name === 'ena_tables')          result = await toolTables(ena, args);
+            else if (name === 'ena_lines')           result = await toolLines(ena, args);
+            else if (name === 'ena_simplify')        result = await toolSimplify(ena, args);
+            else if (name === 'ena_export')          result = await toolExport(ena, args);
+            else throw new Error(`Unknown tool: ${name}`);
+        }
+
+        // Extract viz fields before stringifying so they never appear in the text block.
+        const { _plot, ...cleanResult } = result;
+
+        cleanResult.provenance = PROVENANCE;
+        const content = [{ type: 'text', text: JSON.stringify(cleanResult, null, 2) }];
+
+        if (_plot) {
+            const slug = vizSlug(cleanResult, args) || name;
+            const artifacts = {};     // fields to merge into the text block
+            let renderError = null;
+            let svg = null;
+
+            try {
+                svg = await renderSVG(_plot);
+                if (svg) {
+                    // SVG file — always available (pure JS/WASM), vector, embeddable.
+                    try { artifacts.svg_plot = writeVizFile(svg, slug, 'svg'); }
+                    catch (e) { process.stderr.write(`[ena-mcp] SVG write failed: ${e.message}\n`); }
+
+                    // PNG (inline image block + png_plot file) only when the optional
+                    // native rasterizer is present. Absent in cross-platform bundles.
+                    const Resvg = await getResvg();
+                    if (Resvg) {
+                        const png = new Resvg(svg, { fitTo: { mode: 'height', value: SVG_SIZE }, background: '#ffffff' }).render().asPng();
+                        content.unshift({
+                            type:     'image',
+                            data:     png.toString('base64'),
+                            mimeType: 'image/png',
+                        });
+                        try { artifacts.png_plot = writeVizFile(png, slug, 'png'); }
+                        catch (e) { process.stderr.write(`[ena-mcp] PNG write failed: ${e.message}\n`); }
+                    }
+                } 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`);
+                artifacts._render_error = renderError;
+                artifacts.render_note = 'The model is fine, but the static plot could not be drawn. Give the user interactive_plot ' +
+                    'if it is listed, or report the error; do not draw a substitute plot yourself.';
+            }
+
+            // Self-contained interactive HTML for clients that don't render inline images.
+            try {
+                const html = generateHTML(_plot, _plot.title ?? cleanResult.label ?? name);
+                artifacts.interactive_plot = writeVizFile(html, slug, 'html');
+            } catch (e) {
+                process.stderr.write(`[ena-mcp] HTML write failed: ${e.message}\n`);
+            }
+
+            // Merge all artifact paths into the text block in one pass.
+            const textBlock = content.find(c => c.type === 'text');
+            if (textBlock && Object.keys(artifacts).length) {
+                const parsed = JSON.parse(textBlock.text);
+                Object.assign(parsed, artifacts);
+                textBlock.text = JSON.stringify(parsed, null, 2);
+            }
+        }
+
+        return { content };
+    } catch (err) {
+        return {
+            content: [{ type: 'text', text: `Error: ${withholdDataValues(err.message, args)}\n\n${NO_SUBSTITUTE}` }],
+            isError: true,
+        };
+    }
+});
+
+// ── Start ─────────────────────────────────────────────────────────────────────
+
+const transport = new StdioServerTransport();
+await server.connect(transport);