@barivia/barmesh-mcp 0.6.0 → 0.6.1

package/dist/job_monitor.js

@@ -92,7 +92,7 @@ export function formatSnapshotLine(s) {
     if (s.qe != null)
         parts.push(`QE ${s.qe.toFixed(4)}`);
     if (s.te != null)
-        parts.push(`TE ${s.te.toFixed(4)}`);
+        parts.push(`Epoch TE ${s.te.toFixed(4)}`);
     if (s.eta_sec != null)
         parts.push(`ETA ~${s.eta_sec}s`);
     if (s.ordering_errors_tail?.length) {

package/dist/shared.js

@@ -22,7 +22,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.5.4";
+export const CLIENT_VERSION = "0.6.1";
 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;

package/dist/tools/barmesh_results_explorer.js

@@ -163,7 +163,10 @@ async function handleResultsExplorer(job_id) {
                 `This localhost port is assigned per MCP session and changes if the proxy restarts — re-run barmesh_results_explorer for a fresh URL, or set BARIVIA_VIZ_PORT for a persistent port.`,
         });
     }
-    return structuredTextResult(payload, undefined, content);
+    return {
+        ...structuredTextResult(payload, undefined, content),
+        _meta: { ui: { resourceUri: RESULTS_EXPLORER_URI } },
+    };
 }
 export function registerResultsExplorerTool(server) {
     const toolConfig = {

package/dist/tools/cfd.js

@@ -25,6 +25,7 @@ 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)"),
         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."),

package/dist/tools/training_monitor.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import { runMcpToolAudit } from "../audit.js";
 import { apiCall, getClientSupportsMcpApps, getVizPort, structuredTextResult, } from "../shared.js";
-import { enrichWithTrainingLog, hasCurveArrays } from "../training_review.js";
+import { enrichWithTrainingLog, needsTrainingLogEnrichment } from "../training_review.js";
 export const TRAINING_MONITOR_URI = "ui://barmesh/training-monitor";
 export const TRAINING_MONITOR_REFRESH_MS = 5000;
 function buildStructuredContent(job_id, data) {
@@ -33,7 +33,7 @@ export function registerTrainingMonitorTool(server) {
         let data = (await apiCall("GET", `/v1/jobs/${job_id}`));
         const jobStatus = String(data.status ?? "");
         const terminal = jobStatus === "completed" || jobStatus === "failed";
-        if (fetch_training_log || (terminal && !hasCurveArrays(data))) {
+        if (fetch_training_log || needsTrainingLogEnrichment(data)) {
             data = await enrichWithTrainingLog(job_id, data);
         }
         const structuredContent = buildStructuredContent(job_id, data);
@@ -71,6 +71,9 @@ export function registerTrainingMonitorTool(server) {
                 text: `Interactive training monitor: [Open training monitor](${standaloneUrl})`,
             });
         }
-        return structuredTextResult(structuredContent, text, content);
+        return {
+            ...structuredTextResult(structuredContent, text, content),
+            _meta: { ui: { resourceUri: TRAINING_MONITOR_URI } },
+        };
     }));
 }

package/dist/training_monitor_curve.js

@@ -26,5 +26,35 @@ export function formatCurveSourceNote(data) {
     }
     if (parts.length === 0)
         return null;
-    return `Displaying uniformly subsampled curves (≤1000 points/phase): ${parts.join("; ")}.`;
+    return `Displaying uniformly subsampled QE+TE curves (≤1000 points/phase, joint indices): ${parts.join("; ")}.`;
+}
+/** Map TE onto QE batch axis; when batch-aligned (same length), use values directly. */
+export function alignTeToQeAxis(te, qeLen) {
+    if (qeLen <= 0)
+        return [];
+    if (te.length === qeLen)
+        return te;
+    if (te.length === 0)
+        return Array(qeLen).fill(null);
+    if (te.length >= qeLen)
+        return te.slice(0, qeLen);
+    const pad = qeLen - te.length;
+    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.
+ */
+export function lastEpochTeFromCurves(data) {
+    const conv = data.convergence_topographic_errors;
+    if (Array.isArray(conv) && conv.length > 0) {
+        const v = Number(conv[conv.length - 1]);
+        return Number.isFinite(v) ? v : null;
+    }
+    const ord = data.ordering_topographic_errors;
+    if (Array.isArray(ord) && ord.length > 0) {
+        const v = Number(ord[ord.length - 1]);
+        return Number.isFinite(v) ? v : null;
+    }
+    return null;
 }

package/dist/training_review.js

@@ -5,35 +5,67 @@
 import { apiCall } from "./shared.js";
 import { formatSnapshotLine, snapshotFromJob, } from "./job_monitor.js";
 import { formatJobStatusText } from "./job_status_format.js";
+import { lastEpochTeFromCurves } from "./training_monitor_curve.js";
 export const REVIEW_MAX_SNAPSHOTS = 16;
 function isTerminalStatus(status) {
     return status === "completed" || status === "failed" || status === "cancelled";
 }
+export function hasTeCurveArrays(data) {
+    const ord = data.ordering_topographic_errors;
+    const conv = data.convergence_topographic_errors;
+    return ((Array.isArray(ord) && ord.length > 0) || (Array.isArray(conv) && conv.length > 0));
+}
 function hasCurveArrays(data) {
     const ord = data.ordering_errors;
     const conv = data.convergence_errors;
-    return ((Array.isArray(ord) && ord.length > 0) || (Array.isArray(conv) && conv.length > 0));
+    return ((Array.isArray(ord) && ord.length > 0) ||
+        (Array.isArray(conv) && conv.length > 0) ||
+        hasTeCurveArrays(data));
+}
+/** True when a terminal job still needs training-log curves or the final map TE. */
+export function needsTrainingLogEnrichment(data) {
+    const status = String(data.status ?? "");
+    if (!isTerminalStatus(status))
+        return false;
+    if (!hasCurveArrays(data))
+        return true;
+    if (!hasTeCurveArrays(data))
+        return true;
+    if (data.map_topographic_error == null && data.topographic_error == null)
+        return true;
+    return false;
 }
 export async function enrichWithTrainingLog(job_id, data) {
-    if (hasCurveArrays(data))
-        return data;
+    const status = String(data.status ?? "");
+    const epochTe = data.epoch_topographic_error ??
+        data.topographic_error ??
+        lastEpochTeFromCurves(data);
     try {
         const log = (await apiCall("GET", `/v1/results/${job_id}/training-log`));
-        return {
+        const merged = {
             ...data,
             ordering_errors: log.ordering_errors ?? data.ordering_errors,
             convergence_errors: log.convergence_errors ?? data.convergence_errors,
             ordering_topographic_errors: log.ordering_topographic_errors ?? data.ordering_topographic_errors,
             convergence_topographic_errors: log.convergence_topographic_errors ?? data.convergence_topographic_errors,
             quantization_error: log.quantization_error ?? data.quantization_error,
-            topographic_error: log.topographic_error ?? data.topographic_error,
             grid: log.grid ?? data.grid,
             epochs: log.epochs ?? data.epochs,
             training_duration_seconds: log.training_duration_seconds ?? data.training_duration_seconds,
             training_curve_source_batches: log.training_curve_source_batches ?? data.training_curve_source_batches,
         };
+        const mapTe = log.topographic_error ?? data.map_topographic_error ?? data.topographic_error;
+        merged.epoch_topographic_error = epochTe ?? lastEpochTeFromCurves(merged);
+        merged.map_topographic_error = mapTe;
+        if (isTerminalStatus(status)) {
+            merged.topographic_error = mapTe;
+        }
+        return merged;
     }
     catch {
+        if (epochTe != null) {
+            return { ...data, epoch_topographic_error: epochTe };
+        }
         return data;
     }
 }
@@ -134,11 +166,19 @@ export function formatReviewMonitorText(result, review) {
     if (review.timing)
         lines.push(`Timing: ${review.timing}`);
     const qe = result.data.quantization_error;
-    const te = result.data.topographic_error;
-    if (qe != null || te != null) {
+    const mapTe = result.data.map_topographic_error ?? result.data.topographic_error;
+    const epochTe = result.data.epoch_topographic_error;
+    if (qe != null || mapTe != null || epochTe != null) {
         const qeS = qe != null ? `QE ${Number(qe).toFixed(4)}` : "";
-        const teS = te != null ? `TE ${Number(te).toFixed(4)}` : "";
-        lines.push(`Final: ${[qeS, teS].filter(Boolean).join(", ")}`);
+        const mapS = mapTe != null ? `Map TE ${Number(mapTe).toFixed(4)}` : "";
+        const epochS = epochTe != null &&
+            mapTe != null &&
+            Math.abs(Number(epochTe) - Number(mapTe)) > 0.0005
+            ? `Last epoch TE ${Number(epochTe).toFixed(4)}`
+            : epochTe != null && mapTe == null
+                ? `Epoch TE ${Number(epochTe).toFixed(4)}`
+                : "";
+        lines.push(`Final: ${[qeS, mapS, epochS].filter(Boolean).join(", ")}`);
     }
     lines.push("");
     lines.push("Training curve (sampled from ordering_errors / convergence_errors):");