@barivia/barmesh-mcp 0.6.2 → 0.7.0

package/README.md

@@ -79,12 +79,13 @@ API key; otherwise the analysis calls return HTTP 403. Contact Barivia to enable
 - **Uploads:** large CSVs use presigned PUT with explicit `Content-Length`; `.csv.gz` /
   `.tsv.gz` accepted. Pin `@barivia/barmesh-mcp@0.5.2` (clear `~/.npm/_npx` if stale).
 - **Live progress:** `barmesh_training_monitor(job_id)` or `barmesh_jobs(action=monitor)` block
-  server-side with compact snapshots (phase, epoch, QE/TE, ETA, ordering_errors tail) until
+  server-side with compact snapshots (phase, epoch, QE, **panel/map TE**, ETA, ordering_errors tail) until
   terminal or `block_until_sec` (default 900). Waits for `cfd_finalize` by default. One-shot:
   `barmesh_jobs(action=status)`.
 
 ### Migration notes
 
+- **Fixed-panel live TE (0.6.3 / barsom 0.20.4):** mid-training TE uses a fixed evaluation panel (`te_panel_size`; `te_inner_samples` alias). Curves stay on panel TE; monitors show **Panel TE** and **Map TE** separately — no snap-to-map on the curve tail.
 - **`barmesh_training_monitor` (0.5.3):** server-side blocking monitor with throttled snapshots — preferred after job submit instead of manual `barmesh_jobs(status)` loops. Equivalent to `barmesh_jobs(action=monitor)`.
 - **`send_feedback` → `barmesh_send_feedback` (0.3.0):** the feedback tool was renamed so it no longer collides with the `@barivia/barsom-mcp` tool of the same name when both servers are enabled in one client. Update any direct call sites; the behavior is unchanged.
 

package/dist/audit.js

@@ -2,6 +2,7 @@
  * MCP tool audit wrapper — tool name, action, latency, outcome; no secrets.
  */
 import { logAudit } from "./logger.js";
+import { runWithTrace } from "./shared.js";
 const AUDIT_PARAM_KEYS = new Set([
     "action",
     "preset",
@@ -87,6 +88,7 @@ export function registerAuditedTool(server, name, description, schema, handler)
     server.tool(name, description, schema, (async (args) => {
         const rec = args;
         const action = typeof rec.action === "string" && rec.action.length > 0 ? rec.action : "default";
-        return runMcpToolAudit(name, action, rec, () => handler(args));
+        // One trace per tool invocation (every apiCall inside shares one trace_id).
+        return runWithTrace(() => runMcpToolAudit(name, action, rec, () => handler(args)));
     }));
 }

package/dist/shared.js

@@ -7,6 +7,7 @@ import fs from "node:fs/promises";
 import { createReadStream, createWriteStream } from "node:fs";
 import { createGzip } from "node:zlib";
 import { createHash, randomUUID } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import os from "node:os";
@@ -22,7 +23,7 @@ export const FETCH_TIMEOUT_MS = parseInt(process.env.BARIVIA_FETCH_TIMEOUT_MS ??
 export const MAX_RETRIES = 2;
 export const RETRYABLE_STATUS = new Set([502, 503, 504]);
 /** Single source of truth for the proxy version. Keep in sync with package.json on bump. */
-export const CLIENT_VERSION = "0.6.2";
+export const CLIENT_VERSION = "0.7.0";
 export const PUBLIC_SITE_ORIGIN = "https://barivia.se";
 /** Large per-cell CSV uploads may exceed the default fetch timeout. */
 export const UPLOAD_DATASET_TIMEOUT_MS = 180_000;
@@ -260,6 +261,24 @@ function throwApiError(status, bodyText, requestId) {
     err.httpStatus = status;
     throw err;
 }
+// ---- Distributed-trace context (W3C traceparent) ----
+// One trace per logical tool action (scoped via AsyncLocalStorage in registerAuditedTool),
+// so the API + job chain reconstruct end-to-end. Fresh span per API call; falls back to a
+// per-call trace if no scope is set. Mirrors the barsom proxy.
+const _traceStore = new AsyncLocalStorage();
+function _newTraceId() {
+    return randomUUID().replace(/-/g, "");
+}
+function _newSpanId() {
+    return randomUUID().replace(/-/g, "").slice(0, 16);
+}
+/** Run `fn` within a fresh trace scope so all apiCall()s inside share one trace_id. */
+export function runWithTrace(fn) {
+    return _traceStore.run(_newTraceId(), fn);
+}
+function _traceparentHeader() {
+    return `00-${_traceStore.getStore() ?? _newTraceId()}-${_newSpanId()}-01`;
+}
 export async function apiCall(method, pathPart, body, extraHeaders, requestTimeoutMs) {
     const url = `${API_URL}${pathPart}`;
     const contentType = extraHeaders?.["Content-Type"] ?? "application/json";
@@ -268,6 +287,7 @@ export async function apiCall(method, pathPart, body, extraHeaders, requestTimeo
         Authorization: `Bearer ${API_KEY}`,
         "Content-Type": contentType,
         "X-Request-ID": requestId,
+        traceparent: _traceparentHeader(),
         "X-Barmesh-Client-Version": CLIENT_VERSION,
         ...extraHeaders,
     };
@@ -321,7 +341,7 @@ export async function apiRawCall(pathPart, requestTimeoutMs) {
     let lastError;
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
         try {
-            const resp = await fetchWithTimeout(url, { method: "GET", headers: { Authorization: `Bearer ${API_KEY}`, "X-Request-ID": requestId } }, effectiveTimeout);
+            const resp = await fetchWithTimeout(url, { method: "GET", headers: { Authorization: `Bearer ${API_KEY}`, "X-Request-ID": requestId, traceparent: _traceparentHeader() } }, effectiveTimeout);
             if (!resp.ok) {
                 if (attempt < MAX_RETRIES && isTransientError(null, resp.status)) {
                     await new Promise((r) => setTimeout(r, 1000 * 2 ** attempt));

package/dist/tools/cfd.js

@@ -25,7 +25,8 @@ COMMON MISTAKES: omitting feature_columns (required); choosing a reference_mesh
         backend: z.enum(["auto", "cpu", "gpu", "gpu_graphs"]).optional().describe("Compute backend (default auto / preset)"),
         stratify_scale: z.number().optional().describe("[0,1] per-mesh training-row cap; 1 uses all cells (default 1)"),
         emd_method: z.enum(["exact", "sinkhorn"]).optional().describe("EMD solver: exact LP (default) or sinkhorn (fast approximation for large grids)"),
-        te_inner_samples: z.number().int().optional().describe("Inner statistical sample count for per-batch topographic error estimates during SOM training (default clamp(grid_nodes*6, 500, 10000); display cap remains ≤1000 batch points/phase)"),
+        te_panel_size: z.number().int().optional().describe("Fixed evaluation-panel size for live topographic error during training (default clamp(grid_nodes*6, 500, 10000); curve stays on this panel end-to-end)"),
+        te_inner_samples: z.number().int().optional().describe("Deprecated alias for te_panel_size"),
         component_planes_physical: z.boolean().optional().describe("Physical-scale component-plane colorbars (default true)"),
         figures: z.boolean().optional().describe("Generate publication figures (default true)"),
         transforms: z.record(z.enum(["log", "log1p", "log10", "sqrt", "square", "abs", "invert", "none"])).optional().describe("Per-feature transform applied before normalization (e.g. log1p to compress k/epsilon/omega). Same preprocessing engine as barsom training."),
@@ -40,6 +41,9 @@ COMMON MISTAKES: omitting feature_columns (required); choosing a reference_mesh
             if (v !== undefined && v !== null)
                 params[k] = v;
         }
+        if (params.te_panel_size == null && params.te_inner_samples != null) {
+            params.te_panel_size = params.te_inner_samples;
+        }
         const body = { dataset_id, params };
         if (typeof label === "string" && label.length > 0)
             body.label = label;

package/dist/training_monitor_curve.js

@@ -16,25 +16,8 @@ export function isKernelTrainingComplete(data, status) {
         return true;
     return status === "completed";
 }
-/** Snap the last TE curve point to authoritative full-map TE when kernel training is done. */
-export function snapTeCurvesToMapTe(data) {
-    const mapTe = data.map_topographic_error ??
-        (data.kernel_complete === true ? data.topographic_error : null);
-    if (mapTe == null || !Number.isFinite(Number(mapTe)))
-        return data;
-    const out = { ...data };
-    for (const key of ["ordering_topographic_errors", "convergence_topographic_errors"]) {
-        const arr = out[key];
-        if (Array.isArray(arr) && arr.length > 0) {
-            const copy = arr.slice();
-            copy[copy.length - 1] = Number(mapTe);
-            out[key] = copy;
-        }
-    }
-    return out;
-}
-export function teCurveLabel(base, kernelComplete) {
-    return kernelComplete ? `${base} (→ map TE)` : `${base} (sampled)`;
+export function teCurveLabel(base, _kernelComplete = false) {
+    return `${base} (panel)`;
 }
 export function formatCurveSourceNote(data) {
     const src = data.training_curve_source_batches;
@@ -49,17 +32,20 @@ export function formatCurveSourceNote(data) {
     if (convTotal != null && convTotal > convShown) {
         parts.push(`${convShown} of ${convTotal.toLocaleString()} convergence batch samples`);
     }
-    const mapTe = data.map_topographic_error;
-    const epochTe = data.epoch_topographic_error;
-    if (mapTe != null &&
-        epochTe != null &&
-        Number.isFinite(Number(mapTe)) &&
-        Number.isFinite(Number(epochTe)) &&
-        Math.abs(Number(epochTe) - Number(mapTe)) > 0.0005) {
-        parts.push(`Live TE is a subsampled batch estimate during training; final point snaps to map TE ${Number(mapTe).toFixed(4)} (last sampled ${Number(epochTe).toFixed(4)})`);
+    const teEval = data.te_evaluation;
+    const panelM = teEval?.te_panel_size;
+    const panelN = teEval?.te_panel_n_train;
+    if (typeof panelM === "number" && typeof panelN === "number" && panelN > 0) {
+        const strat = teEval?.te_panel_stratified === true ? ", stratified by mesh" : "";
+        parts.push(`TE curve uses a fixed panel of ${panelM.toLocaleString()} of ${panelN.toLocaleString()} training rows${strat}`);
     }
-    else if (mapTe != null && Number.isFinite(Number(mapTe))) {
-        parts.push(`TE curve final point is full-map topographic error (${Number(mapTe).toFixed(4)}).`);
+    const panelTe = data.panel_topographic_error;
+    const mapTe = data.map_topographic_error;
+    if (panelTe != null &&
+        mapTe != null &&
+        Number.isFinite(Number(panelTe)) &&
+        Number.isFinite(Number(mapTe))) {
+        parts.push(`Panel TE ${Number(panelTe).toFixed(4)} · Map TE ${Number(mapTe).toFixed(4)} (full training set)`);
     }
     if (parts.length === 0)
         return null;
@@ -82,8 +68,7 @@ export function alignTeToQeAxis(te, qeLen) {
     return [...Array(pad).fill(null), ...te];
 }
 /**
- * Last sampled TE point from the (batch-aligned) live TE curve. This is the most
- * recent per-epoch TE estimate, distinct from the final trained-map TE in the summary.
+ * Last panel TE point from the (batch-aligned) live TE curve.
  */
 export function lastEpochTeFromCurves(data) {
     const conv = data.convergence_topographic_errors;

package/dist/training_review.js

@@ -5,7 +5,7 @@
 import { apiCall } from "./shared.js";
 import { formatSnapshotLine, snapshotFromJob, } from "./job_monitor.js";
 import { formatJobStatusText } from "./job_status_format.js";
-import { lastEpochTeFromCurves, snapTeCurvesToMapTe } from "./training_monitor_curve.js";
+import { lastEpochTeFromCurves } from "./training_monitor_curve.js";
 export const REVIEW_MAX_SNAPSHOTS = 16;
 function isTerminalStatus(status) {
     return status === "completed" || status === "failed" || status === "cancelled";
@@ -60,13 +60,13 @@ export async function enrichWithTrainingLog(job_id, data) {
         if (isTerminalStatus(status)) {
             merged.topographic_error = mapTe;
         }
-        return snapTeCurvesToMapTe(merged);
+        return merged;
     }
     catch {
         if (epochTe != null) {
-            return snapTeCurvesToMapTe({ ...data, epoch_topographic_error: epochTe });
+            return { ...data, epoch_topographic_error: epochTe };
         }
-        return data.kernel_complete === true ? snapTeCurvesToMapTe(data) : data;
+        return data;
     }
 }
 /** Evenly sample indices for a compact epoch/QE timeline in review mode. */