@qe-mcp/ena 0.1.18 → 0.1.19

package/README.md

@@ -176,7 +176,13 @@ A hosted server has no access to anyone's files, so this mode is a different
 privacy promise, and it says so to the model. In `--http` mode:
 
 - Data arrives inline as `data_csv`; `data_path` is refused. The server
-  processes it in memory and stores nothing.
+  parses it in memory and discards it when the call returns: no rows and no
+  CSV text are kept, in memory or on disk (locally, parsed rows are cached for
+  speed). What stays is the fitted model behind a `model_id` — points,
+  networks, unit labels and group values — for `$ENA_MCP_MODEL_TTL_MIN`
+  minutes after its last use (default 60), then it is forgotten.
+  `ena_simplify` refits, so hosted it takes `data_csv` again and checks that
+  it is the data the model was fitted on.
 - `ena_profile`, `ena_tables`, `ena_lines` and `ena_export` are not offered
   (they read or write files), and the prompts are not listed (they take a
   path). Plots come back as the inline PNG plus the SVG as text; no files are
@@ -187,11 +193,67 @@ privacy promise, and it says so to the model. In `--http` mode:
   model.
 
 Each request is answered statelessly, so any replica can take any request,
-but fitted models are cached in the process that fitted them: run one
-replica, or use sticky sessions, for `model_id`s to stay valid across calls.
+but fitted models live in the process that fitted them, until they expire:
+run one replica, or use sticky sessions, for `model_id`s to stay valid
+across calls.
 Put TLS and whatever authentication or rate limiting you need in front of it;
 the server itself does neither. `node test-http.mjs` starts it on a free port
-and checks all of the above.
+and checks all of the above; with `ENA_MCP_TEST_URL=http://host:port` it
+checks a server that is already running instead.
+
+#### Kubernetes
+
+The `Dockerfile` builds the server as `node server.js --http` on port 8000
+from the files the package ships plus production dependencies (no token
+needed: the `@qe-libs` packages resolve from a public registry endpoint).
+CI builds it for every main commit that touches those files and re-tags it
+with each `vX.Y.Z` release tag, at
+`registry.gitlab.com/epistemic-analytics/qe-packages/server-ena`.
+
+`inst/k8s/` is a Helm chart in the shape the other qe apps use: one replica
+with readiness and liveness on `/healthz`, and an nginx Ingress for
+`hostUrl` with a body limit above the server's, buffering off, and a
+per-client-IP rate limit (`rateLimit` in `values.yaml`: requests per second,
+burst, concurrent connections; over it nginx answers 503). The limiter keys
+on the address nginx sees, so it only tells clients apart if the controller
+takes the real client address from the load balancer; and all claude.ai
+users share Anthropic's egress addresses, so the defaults are generous.
+`ENA_MCP_MODEL_TTL_MIN` and `ENA_MCP_MAX_BODY_MB` come from the chart
+values. `inst/k8s/argo/production.yaml` is the Argo CD Application to copy
+into the argo-deployments repository; its image updater follows the
+semver image tags, so a release rolls out by itself.
+
+Locally:
+
+```bash
+docker build -t qe-mcp-ena . && docker run --rm -p 8000:8000 qe-mcp-ena
+ENA_MCP_TEST_URL=http://127.0.0.1:8000 node test-http.mjs
+```
+
+#### Cloudflare Workers
+
+The same server runs as a Worker, without Node. `worker/build.mjs` bundles it
+with esbuild into `worker/dist/`: the files the server reads from disk
+(fonts, the qeviz bundle, the skill text) are embedded, and the WASM modules
+are imported precompiled, as Workers require. Then wrangler runs or deploys
+it (Node 22 or newer for wrangler):
+
+```bash
+node worker/build.mjs
+cd worker && npx wrangler dev        # http://127.0.0.1:8787/mcp
+cd worker && npx wrangler deploy
+```
+
+Workers forbid `eval` and `new Function`, and Emscripten's Embind glue uses
+them unless the module was linked with `-sDYNAMIC_EXECUTION=0`:
+`@qe-libs/libqe-wasm` 0.2.4 and `@qe-libs/rena-wasm` 0.1.17 are the first
+builds linked that way. To test a locally built module instead,
+`ENA_WORKER_LIBQE_DIR` and `ENA_WORKER_LIBENA_DIR` name directories holding
+`libqe.js`/`libqe.wasm` and `libena.js`/`libena.wasm`. Fits need the Workers Paid plan (the free plan's
+10 ms CPU limit is too tight; a fit on 3,800 rows with its PNG takes a few
+hundred milliseconds). The model cache lives in the isolate that served the
+request, so `model_id`s stay valid only while the same isolate keeps
+answering; a shared store (KV or a Durable Object) would make them durable.
 
 ## Prompts
 

package/assets.js

@@ -0,0 +1,54 @@
+/**
+ * assets.js — the files the server reads from its own package.
+ *
+ * Node reads them from disk next to this file. A Worker bundle (see
+ * worker/) has no disk: it calls setAssets() with the same contents embedded
+ * at build time, before server.js is imported. Every accessor is lazy so the
+ * Node reads only happen when they are actually used.
+ */
+
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+// The bundled plot font (Inter, OFL), as paths for the native resvg and as
+// bytes for the WASM one.
+const FONT_FILES = ['Inter-Regular.ttf', 'Inter-Bold.ttf'];
+
+const nodeAssets = {
+    pkgJson: () => JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8')),
+    renaVersion() {
+        try { return JSON.parse(readFileSync(createRequire(import.meta.url).resolve('@qe-libs/rena-wasm/package.json'), 'utf8')).version; }
+        catch { return 'unknown'; }
+    },
+    // The qeviz UMD bundle, inlined into interactive pages.
+    qevizJS: () => readFileSync(createRequire(import.meta.url).resolve('@qe-libs/qeviz'), 'utf8'),
+    skillMarkdown() {
+        try { return readFileSync(new URL('./skill/ena-analysis/SKILL.md', import.meta.url), 'utf8'); }
+        catch { return null; }
+    },
+    // What @resvg/resvg-wasm's initWasm() accepts: bytes here, a compiled
+    // WebAssembly.Module in a Worker.
+    resvgWasm: () => readFileSync(createRequire(import.meta.url).resolve('@resvg/resvg-wasm/index_bg.wasm')),
+    fontPaths:   () => FONT_FILES.map(f => fileURLToPath(new URL(`./fonts/${f}`, import.meta.url))),
+    fontBuffers: () => FONT_FILES.map(f => readFileSync(new URL(`./fonts/${f}`, import.meta.url))),
+};
+
+let impl = nodeAssets;
+
+/** Replace the asset source (a Worker bundle does this before importing server.js). */
+export function setAssets(assets) { impl = { ...nodeAssets, ...assets }; }
+
+export const pkgJson       = () => impl.pkgJson();
+export const renaVersion   = () => impl.renaVersion();
+export const skillMarkdown = () => impl.skillMarkdown();
+export const resvgWasm     = () => impl.resvgWasm();
+export const fontPaths     = () => impl.fontPaths();
+export const fontBuffers   = () => impl.fontBuffers();
+
+let _qevizJS = null;
+export function qevizJS() {
+    // Drop the source-map comment: the .map file is not next to the inlined copy.
+    if (!_qevizJS) _qevizJS = String(impl.qevizJS()).replace(/\n\/\/# sourceMappingURL=\S*\s*$/, '\n');
+    return _qevizJS;
+}

package/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": "0.2",
   "name": "qe-mcp-ena",
   "display_name": "ENA — Epistemic Network Analysis",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Epistemic Network Analysis on tabular coded data. Runs entirely on your machine — data never leaves your computer.",
   "long_description": "Run Epistemic Network Analysis (ENA), ordered network analysis (ONA) and transmodal analysis (TMA) on your coded data from a conversation with Claude. No R or Python to install.\n\n**Your data stays on your machine**\n\n- The analysis runs locally. Only results — networks, points, statistics and plots — go back to the conversation.\n- Give Claude a file path rather than pasting data; the server reads the file itself.\n- It makes no network connections, starts no other programs, and writes files only when you ask for an export.\n\n**About the install warning**\n\nClaude Desktop shows \"access to everything on your computer\" for every extension outside Anthropic's reviewed directory. It means you are trusting the source, as with any program you install. The source is published on npm as @qe-mcp/ena.\n\nDocumentation and example prompts: https://qe-libs.org/mcp/qe-mcp-ena/",
   "author": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qe-mcp/ena",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Epistemic Network Analysis for Claude and other assistants — runs on your machine",
   "repository": {
     "type": "git",
@@ -13,6 +13,7 @@
   },
   "files": [
     "server.js",
+    "assets.js",
     "webena.js",
     "xlsx.js",
     "lines.js",
@@ -27,7 +28,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.4.0",
     "@qe-libs/qeviz": "0.7.0",
-    "@qe-libs/rena-wasm": "^0.1.14",
+    "@qe-libs/rena-wasm": "^0.1.17",
     "@resvg/resvg-wasm": "^2.6.2"
   },
   "optionalDependencies": {
@@ -39,5 +40,8 @@
     "epistemic-network-analysis",
     "wasm"
   ],
-  "license": "GPL-3.0-only"
+  "license": "GPL-3.0-only",
+  "devDependencies": {
+    "wrangler": "^4.156.0"
+  }
 }

package/server.js

@@ -41,7 +41,8 @@ import { randomBytes } from 'crypto';
 // written to files, and the file-based tools are not offered.
 const ARGV   = process.argv.slice(2);
 const argOf  = (flag, dflt) => { const i = ARGV.indexOf(flag); return i >= 0 && ARGV[i + 1] != null ? ARGV[i + 1] : dflt; };
-const REMOTE = ARGV.includes('--http');
+// Embedded in a Worker (globalThis.ENA_MCP_EMBEDDED) is always the hosted mode.
+const REMOTE = ARGV.includes('--http') || !!globalThis.ENA_MCP_EMBEDDED;
 const HTTP_PORT = Number(argOf('--port', process.env.PORT ?? 8000));
 const HTTP_HOST = argOf('--host', process.env.HOST ?? '127.0.0.1');
 const HTTP_PATH = '/mcp';
@@ -53,8 +54,9 @@ if (ARGV.includes('--help') || ARGV.includes('-h')) {
         '',
         '  (no flags)   MCP over stdio — what Claude Desktop, Claude Code and other local clients run.',
         '  --http       MCP over streamable HTTP at /mcp, for hosting. Data must be passed inline',
-        '               (data_csv); nothing is written to disk; ena_profile, ena_tables, ena_lines and',
-        '               ena_export are not offered. Health check: GET /healthz.',
+        '               (data_csv) and is discarded after each call; only fitted models are kept, for',
+        '               $ENA_MCP_MODEL_TTL_MIN minutes (default 60); nothing is written to disk; ena_profile,',
+        '               ena_tables, ena_lines and ena_export are not offered. Health check: GET /healthz.',
         '  --port N     Port for --http (default: $PORT or 8000).',
         '  --host H     Interface for --http (default: $HOST or 127.0.0.1; use 0.0.0.0 in a container).',
         '  --max-body-mb N  Largest request body in MB (default: $ENA_MCP_MAX_BODY_MB or 25).',
@@ -73,17 +75,9 @@ import loadENA, { detectParams, isBinary } from '@qe-libs/rena-wasm';
 // qeviz: renderSVG() draws the static plot here, with no DOM; the UMD bundle
 // (self-contained, no external deps) is inlined into the interactive page.
 import { renderSVG as qevizRenderSVG } from '@qe-libs/qeviz';
-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, 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;
-}
+// Package files (qeviz bundle, fonts, skill text, versions): read from disk
+// in Node, embedded at build time in a Worker (see assets.js).
+import { qevizJS, pkgJson, renaVersion, skillMarkdown, resvgWasm, fontBuffers, fontPaths } from './assets.js';
 
 // ── CSV parser ────────────────────────────────────────────────────────────────
 
@@ -388,7 +382,7 @@ function buildGmrParams(rows, unitCols, unitLabels, p) {
 // 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);
+    const src = modelGet(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).`);
@@ -688,30 +682,41 @@ function vizSlug(result, args = {}) {
 // ── static SVG renderer ───────────────────────────────────────────────────────
 
 // 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).
+// @resvg/resvg-js, an OPTIONAL dependency: fastest. Where it is absent — the
+// cross-platform .mcpb bundle, or a platform without a prebuilt binary —
+// @resvg/resvg-wasm renders the same image. Both draw plot labels with the
+// bundled Inter (fonts/, OFL) and never scan system fonts: resvg's default
+// loadSystemFonts walks the whole system font set on EVERY render, which on
+// macOS costs ~1.5 s per PNG against ~25 ms with the two bundled files.
 // Loaded lazily; if neither loads, SVG and interactive HTML are still produced.
+//
+// The two builds take the fonts differently. The WASM build takes the bytes
+// (fontBuffers). The native build takes paths (fontFiles): given fontBuffers,
+// resvg-js 2.6 scans the system fonts anyway, loadSystemFonts: false or not,
+// and the 1.5 s is back.
+const FONT_FAMILY = { defaultFontFamily: 'Inter', sansSerifFamily: 'Inter', loadSystemFonts: false };
+// Wrap a Resvg class so every render uses the bundled fonts and asPng() yields
+// a Buffer (the WASM build returns a Uint8Array).
+function withBundledFonts(Resvg, fonts) {
+    let font;
+    return function FontedResvg(svg, opts = {}) {
+        font ??= { ...FONT_FAMILY, ...fonts() };
+        const r = new Resvg(svg, { ...opts, font: { ...font, ...opts.font } });
+        return { render: () => { const img = r.render(); return { asPng: () => Buffer.from(img.asPng()) }; } };
+    };
+}
 let _Resvg;   // undefined = not yet attempted; null = unavailable
 async function getResvg() {
     if (_Resvg !== undefined) return _Resvg;
     try {
-        ({ Resvg: _Resvg } = await import('@resvg/resvg-js'));
+        const { Resvg } = await import('@resvg/resvg-js');
+        _Resvg = withBundledFonts(Resvg, () => ({ fontFiles: fontPaths() }));
         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()) }; } };
-        };
+        await initWasm(await resvgWasm());
+        _Resvg = withBundledFonts(Resvg, () => ({ fontBuffers: fontBuffers() }));
     } catch (e) {
         _Resvg = null;
         process.stderr.write(
@@ -849,6 +854,15 @@ let   modelSeq   = 0;
 const MAX_ACCUM  = 8;
 const MAX_MODELS = 50;
 
+// Hosted, the process serves strangers, so it keeps no data: parsed rows and
+// accumulations are not cached (every call re-parses the CSV it was sent, tens
+// of ms), the CSV text is dropped from a model's stored parameters, and a
+// model — points, networks, unit and group labels — is forgotten MODEL_TTL_MS
+// after its last use instead of waiting to be displaced.
+const KEEP_ROWS = !REMOTE;
+let MODEL_TTL_MS = REMOTE ? Number(process.env.ENA_MCP_MODEL_TTL_MIN ?? 60) * 60_000 : 0;
+export function setModelTtl(minutes) { MODEL_TTL_MS = Number(minutes) * 60_000; }
+
 function cacheGet(map, key) {
     if (!map.has(key)) return undefined;
     const v = map.get(key);
@@ -861,6 +875,27 @@ function cacheSet(map, key, value, max) {
     while (map.size > max) map.delete(map.keys().next().value);
 }
 
+function expireModels(now = Date.now()) {
+    if (!MODEL_TTL_MS) return;
+    for (const [id, e] of modelCache)
+        if (now - e._used > MODEL_TTL_MS) modelCache.delete(id);
+}
+function modelGet(model_id) {
+    expireModels();
+    const e = cacheGet(modelCache, model_id);
+    if (e) e._used = Date.now();
+    return e;
+}
+function modelSet(model_id, entry) {
+    expireModels();
+    if (!KEEP_ROWS && entry.params) {
+        entry._data  = dataStamp(entry.params);   // to check resent data against
+        entry.params = { ...entry.params, data_csv: undefined };
+    }
+    entry._used = Date.now();
+    cacheSet(modelCache, model_id, entry, MAX_MODELS);
+}
+
 // 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) {
@@ -1027,13 +1062,13 @@ 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); }
+    else { rows = loadData(p.data_path, p.data_csv); if (KEEP_ROWS) 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);
+    if (KEEP_ROWS) cacheSet(rowsCache, vKey, view, MAX_ROWS);
     return view;
 }
 
@@ -1437,7 +1472,7 @@ async function toolTmaFit(ena, params) {
         result,
     };
     entry.view = defaultView(params, entry.web);
-    cacheSet(modelCache, model_id, entry, MAX_MODELS);
+    modelSet(model_id, entry);
 
     return { ...result, _plot: web.buildPlot(entry, entry.view) };
 }
@@ -1700,9 +1735,9 @@ async function toolFit(ena, params) {
     // 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);
+    const cached = cachedId && modelGet(cachedId);   // the model may have been evicted or expired
+    if (cached) {
+        const model_id = cachedId, entry = cached;
         return {
             model_id,
             ...entry.result,
@@ -1722,7 +1757,7 @@ async function toolFit(ena, params) {
             codes, units: unitCols, conversations: convoCols,
             window: windowValue(window_size), binary, ...accumOpts(params),
         });
-        cacheSet(accumCache, aKey, { rows, acc }, MAX_ACCUM);
+        if (KEEP_ROWS) cacheSet(accumCache, aKey, { rows, acc }, MAX_ACCUM);
     }
 
     const { unitLabels, nConnections, connectionNames, nUnits } = acc;
@@ -1822,7 +1857,7 @@ async function toolFit(ena, params) {
         result,
     };
     entry.view = defaultView(params, entry.web);
-    cacheSet(modelCache, model_id, entry, MAX_MODELS);
+    modelSet(model_id, entry);
     cacheSet(fitCache, fKey, model_id, MAX_MODELS);
 
     return { ...result, _plot: web.buildPlot(entry, entry.view) };
@@ -1943,9 +1978,9 @@ async function toolCompareGroups(ena, 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);
+    const cached = cachedId && modelGet(cachedId);   // the model may have been evicted or expired
+    if (cached) {
+        const model_id = cachedId, entry = cached;
         return {
             model_id,
             ...entry.result,
@@ -1969,7 +2004,7 @@ async function toolCompareGroups(ena, params) {
             codes, units: unitCols, conversations: convoCols,
             window: windowValue(window_size), binary, ...accumOpts(params),
         });
-        cacheSet(accumCache, aKey, { rows, acc }, MAX_ACCUM);
+        if (KEEP_ROWS) cacheSet(accumCache, aKey, { rows, acc }, MAX_ACCUM);
     }
 
     const { unitLabels, connectionNames, nUnits, nConnections } = acc;
@@ -2101,7 +2136,7 @@ async function toolCompareGroups(ena, params) {
         result,
     };
     entry.view = defaultView(params, entry.web);
-    cacheSet(modelCache, model_id, entry, MAX_MODELS);
+    modelSet(model_id, entry);
     cacheSet(fitCache, fKey, model_id, MAX_MODELS);
 
     return { ...result, _plot: web.buildPlot(entry, entry.view) };
@@ -2180,7 +2215,7 @@ async function toolPlot({ model_id, type = 'all', group_value, group1, group2, u
                           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);
+    const entry = modelGet(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).`);
@@ -2354,7 +2389,7 @@ function csvCell(v) {
 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);
+    const entry = modelGet(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;
@@ -2409,12 +2444,20 @@ async function toolTables(ena, { model_id, out_path }) {
 // 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);
+async function toolSimplify(ena, { model_id, threshold = 0.95, remove_num = 3, data_csv }) {
+    const entry = modelGet(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 ?? {};
+    let p = entry.params ?? {};
+    if (!KEEP_ROWS) {
+        // The hosted server kept nothing but the model: PRIA refits, so the
+        // same data must come again, and it must be the same data.
+        if (!data_csv) throw new Error('Hosted server: the data is not stored. Pass data_csv again (the CSV the model was fitted on).');
+        if (dataStamp({ data_csv }) !== entry._data)
+            throw new Error(`data_csv is not the data model ${model_id} was fitted on. Pass the same CSV, or fit a new model.`);
+        p = { ...p, data_csv };
+    }
     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).`);
@@ -2461,7 +2504,7 @@ async function toolSimplify(ena, { model_id, threshold = 0.95, remove_num = 3 })
 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);
+    const entry = modelGet(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;
@@ -2596,7 +2639,7 @@ async function toolLines(ena, { model_id, connection, units, group, columns, max
 }
 
 async function toolExport(ena, { model_id, set_name, out_path }) {
-    const entry = cacheGet(modelCache, model_id);
+    const entry = modelGet(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);
@@ -2793,8 +2836,8 @@ const ROTATION_PROPS = {
 
 const GUIDE = (() => {
     let md;
-    try { md = readFileSync(new URL('./skill/ena-analysis/SKILL.md', import.meta.url), 'utf8'); }
-    catch { return null; }
+    md = skillMarkdown();
+    if (md == null) return null;
     md = md.replace(/^---\n[\s\S]*?\n---\n+/, '');                 // frontmatter
     const sections = [];
     for (const part of md.split(/^(?=## )/m).slice(1)) {
@@ -3111,6 +3154,7 @@ const TOOLS = [
                 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).' },
+                data_csv:   { type: 'string', description: 'Hosted server only: the CSV the model was fitted on, again (the server does not store it). Locally, omit.', _hostedOnly: true },
             },
             required: ['model_id'],
         },
@@ -3181,7 +3225,7 @@ const TOOLS = [
 // from every schema, and the privacy wording changes from "keep it local" to
 // "send it de-identified".
 const REMOTE_HIDDEN_TOOLS = new Set(['ena_profile', 'ena_tables', 'ena_lines', 'ena_export']);
-const REMOTE_PRIVACY = 'PRIVACY (hosted server): the data is sent inline and processed in memory; it is not stored. ' +
+const REMOTE_PRIVACY = 'PRIVACY (hosted server): the data is sent inline and processed in memory; it is discarded when the call returns, and only the fitted model is kept, for a limited time. ' +
     'Before sending it, confirm with the user that it is de-identified. ';
 function remoteTools(tools) {
     return tools.filter(t => !REMOTE_HIDDEN_TOOLS.has(t.name)).map(t => {
@@ -3200,22 +3244,26 @@ function remoteTools(tools) {
         const required = (t.inputSchema.required ?? []).filter(r => r !== 'data_path');
         if (properties.data_csv && !description.includes(REMOTE_PRIVACY.trim()))
             description = `${description} ${REMOTE_PRIVACY.trim()}`;
-        if (properties.data_csv) properties.data_csv = {
+        if (properties.data_csv && !properties.data_csv._hostedOnly) properties.data_csv = {
             type: 'string',
             description: 'The data as CSV text. The server has no access to the user\'s files; it processes this in memory and does not store it. Send only de-identified data.',
         };
+        if (properties.data_csv?._hostedOnly) { const { _hostedOnly, ...d } = properties.data_csv; properties.data_csv = d; }
         return { ...t, description, inputSchema: { ...t.inputSchema, properties, ...(required.length ? { required } : {}) } };
     });
 }
-const OFFERED_TOOLS = REMOTE ? remoteTools(TOOLS) : TOOLS;
+function localTools(tools) {
+    return tools.map(t => {
+        const properties = Object.fromEntries(Object.entries(t.inputSchema.properties ?? {}).filter(([, v]) => !v._hostedOnly));
+        return { ...t, inputSchema: { ...t.inputSchema, properties } };
+    });
+}
+const OFFERED_TOOLS = REMOTE ? remoteTools(TOOLS) : localTools(TOOLS);
 
 // ── 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'; }
-})();
+const PKG = pkgJson();
+const RENA_VERSION = renaVersion();
 // 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})`;
@@ -3249,11 +3297,12 @@ function withholdDataValues(msg, args) {
 
 // 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 = REMOTE ? [
+const serverInstructions = () => REMOTE ? [
     'ENA / ONA / TMA analysis on a hosted server. The server does not run on the user\'s machine and cannot read their files.',
     '',
     'Data privacy — follow in every conversation:',
-    '- Data reaches these tools inline, as data_csv. It is processed in memory for the duration of the call and is not stored.',
+    '- Data reaches these tools inline, as data_csv. It is parsed in memory for the call and discarded when the call returns: the server keeps no rows and no CSV text, in memory or on disk.',
+    `- What a model_id refers to — the fitted model: points, networks, unit labels and group values, never the rows — stays in memory for ${Math.round(MODEL_TTL_MS / 60_000)} minutes after its last use, then is forgotten. ena_simplify refits, so it takes data_csv again.`,
     '- Before the first analysis, tell the user that the data leaves their machine and must be de-identified: no names, e-mail addresses or identifying free text. Ask them to confirm before sending it.',
     '- Results include unit labels (the values of the unit columns, often participant IDs) and group values. If those are identifying, tell the user before fitting so they can pseudonymize the data first.',
     '- The guide may mention data_path, ena_profile, ena_tables, ena_lines or ena_export; those are for the locally installed server and are not available here.',
@@ -3329,7 +3378,7 @@ const on = (schema, handler) => HANDLERS.push([schema, handler]);
 function buildServer() {
     const server = new Server(
         { name: 'ena', version: PKG.version },
-        { capabilities: { tools: {}, prompts: {} }, instructions: SERVER_INSTRUCTIONS }
+        { capabilities: { tools: {}, prompts: {} }, instructions: serverInstructions() }
     );
     for (const [schema, handler] of HANDLERS) server.setRequestHandler(schema, handler);
     return server;
@@ -3543,6 +3592,7 @@ on(CallToolRequestSchema, async (request) => {
 
         return { content };
     } catch (err) {
+        if (process.env.ENA_MCP_DEBUG) process.stderr.write((err.stack ?? '') + '\n');
         return {
             content: [{ type: 'text', text: `Error: ${withholdDataValues(err.message, args)}\n\n${NO_SUBSTITUTE}` }],
             isError: true,
@@ -3550,10 +3600,43 @@ on(CallToolRequestSchema, async (request) => {
     }
 });
 
-// ── Start ─────────────────────────────────────────────────────────────────────
+// ── Web-standard entry (Workers and other fetch runtimes) ─────────────────────
+// Same stateless scheme as --http below, over Request/Response. A Worker
+// bundle imports this and never reaches the start block.
+
+export { buildServer };
+
+export async function handleWebRequest(request, { maxBody = HTTP_MAX_BODY } = {}) {
+    const url = new URL(request.url);
+    const json = (status, body) => Response.json(body, { status });
+    if (url.pathname === '/healthz') return json(200, { ok: true, server: PKG.name, version: PKG.version });
+    if (url.pathname !== HTTP_PATH) return json(404, { error: `MCP endpoint is ${HTTP_PATH}` });
+    let parsedBody;
+    if (request.method === 'POST') {
+        const tooLarge = () => json(413, { error: `request body too large (limit ${Math.round(maxBody / 1048576)} MB)` });
+        if (Number(request.headers.get('content-length')) > maxBody) return tooLarge();
+        const raw = await request.text();
+        if (raw.length > maxBody) return tooLarge();
+        try { parsedBody = JSON.parse(raw); }
+        catch { return json(400, { jsonrpc: '2.0', error: { code: -32700, message: 'Parse error' }, id: null }); }
+    }
+    const { WebStandardStreamableHTTPServerTransport } = await import('@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js');
+    const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+    await buildServer().connect(transport);
+    return transport.handleRequest(request, { parsedBody });
+}
 
-if (!REMOTE) {
-    await buildServer().connect(new StdioServerTransport());
+// ── Start ─────────────────────────────────────────────────────────────────────
+// Skipped when embedded (a Worker sets globalThis.ENA_MCP_EMBEDDED before
+// importing this module and calls handleWebRequest itself).
+
+if (globalThis.ENA_MCP_EMBEDDED) {
+    // nothing to start
+} else if (!REMOTE) {
+    buildServer().connect(new StdioServerTransport()).catch((e) => {
+        process.stderr.write(`[ena-mcp] stdio: ${e.message}\n`);
+        process.exit(1);
+    });
 } else {
     // Streamable HTTP, stateless: every POST gets a fresh Server + transport
     // and is answered in full, so no session state lives in the process and
@@ -3602,4 +3685,5 @@ if (!REMOTE) {
     http.listen(HTTP_PORT, HTTP_HOST, () => {
         process.stderr.write(`[ena-mcp] ${PKG.name} ${PKG.version} serving MCP over HTTP at http://${HTTP_HOST}:${HTTP_PORT}${HTTP_PATH} (health: /healthz)\n`);
     });
+    setInterval(expireModels, 60_000).unref();   // idle models leave on time, not at the next request
 }