@barivia/barmesh-mcp 0.6.0 → 0.6.2

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/job_status_format.js

@@ -3,7 +3,7 @@
  * Surfaces phase, elapsed, ETA, and epoch N/M during the SOM training of a
  * cfd_mesh_convergence job, plus CFD finalize (figure render) sub-status.
  */
-import { apiCall } from "./shared.js";
+import { formatRunConfigTable, finalizeSubStatusLine } from "./run_config.js";
 function formatElapsedPart(data, status) {
     const wall = data.wall_elapsed_sec != null && !Number.isNaN(Number(data.wall_elapsed_sec))
         ? Number(data.wall_elapsed_sec)
@@ -33,32 +33,16 @@ function formatElapsedPart(data, status) {
     }
     return null;
 }
-async function finalizeStatusLine(finalizeId) {
-    try {
-        const fin = (await apiCall("GET", `/v1/jobs/${finalizeId}`));
-        const st = String(fin.status ?? "unknown");
-        const prog = fin.progress != null ? `${(Number(fin.progress) * 100).toFixed(0)}%` : null;
-        const phase = fin.progress_phase != null ? String(fin.progress_phase) : null;
-        const elapsed = formatElapsedPart(fin, st);
-        const bits = [`cfd_finalize ${finalizeId}: ${st}`];
-        if (prog)
-            bits.push(prog);
-        if (phase)
-            bits.push(`phase ${phase}`);
-        if (elapsed)
-            bits.push(elapsed);
-        return bits.join(", ");
-    }
-    catch {
-        return `cfd_finalize ${finalizeId} still running (poll barmesh_jobs(action=status, job_id="${finalizeId}"))`;
-    }
-}
 export async function formatJobStatusText(job_id, data) {
     const status = String(data.status ?? "unknown");
     const progress = (data.progress ?? 0) * 100;
     const label = data.label != null && data.label !== "" ? String(data.label) : null;
     const jobDesc = label ? `Job ${label} (id: ${job_id})` : `Job ${job_id}`;
-    const parts = [`${jobDesc}: ${status} (${progress.toFixed(1)}%)`];
+    const parts = [];
+    const runConfig = formatRunConfigTable(data);
+    if (runConfig)
+        parts.push(runConfig);
+    parts.push(`${jobDesc}: ${status} (${progress.toFixed(1)}%)`);
     const attempt = data.attempt != null ? Number(data.attempt) : null;
     if (attempt != null && attempt > 1) {
         parts.push(`attempt ${attempt} (job was requeued after worker timeout — not stuck from scratch)`);
@@ -86,14 +70,19 @@ export async function formatJobStatusText(job_id, data) {
         const qe = data.quantization_error != null ? Number(data.quantization_error) : null;
         if (qe != null && !Number.isNaN(qe))
             parts.push(`QE ${qe.toFixed(4)}`);
+        const mapTe = data.map_topographic_error != null ? Number(data.map_topographic_error) : null;
+        const liveTe = data.topographic_error != null ? Number(data.topographic_error) : null;
+        const te = mapTe != null && !Number.isNaN(mapTe) ? mapTe : liveTe;
+        if (te != null && !Number.isNaN(te))
+            parts.push(`TE ${te.toFixed(4)}`);
     }
     if (status === "running" && progress < 5 && !phase) {
         parts.push("Advisory: still in early preprocessing — epoch counter starts after ingest completes.");
     }
     if (status === "completed") {
-        const finalizeId = data.finalize_job_id != null && String(data.finalize_job_id) !== "" ? String(data.finalize_job_id) : null;
-        if (finalizeId) {
-            parts.push(await finalizeStatusLine(finalizeId));
+        const finalizeLine = finalizeSubStatusLine(data);
+        if (finalizeLine) {
+            parts.push(finalizeLine);
             parts.push(`Compute done; figures may still be uploading. Poll barmesh_jobs(status) until finalize completes before barmesh_results(get).`);
         }
         else {

package/dist/run_config.js

@@ -0,0 +1,136 @@
+/** Run configuration summary for training monitor (mesh_convergence + training jobs). */
+function formatGrid(grid) {
+    if (!Array.isArray(grid) || grid.length < 2)
+        return null;
+    return `${grid[0]}×${grid[1]}`;
+}
+function formatEpochs(epochs) {
+    if (!Array.isArray(epochs) || epochs.length === 0)
+        return null;
+    if (epochs.length >= 2)
+        return `${epochs[0]}+${epochs[1]}`;
+    return String(epochs[0]);
+}
+function formatMeshOrder(mo) {
+    if (!Array.isArray(mo) || mo.length === 0)
+        return null;
+    return mo.map(String).join("→");
+}
+function formatFeatures(feats) {
+    if (!Array.isArray(feats) || feats.length === 0)
+        return null;
+    const names = feats.map(String);
+    if (names.length <= 6)
+        return names.join(", ");
+    return `${names.length} cols: ${names.slice(0, 5).join(", ")}, …`;
+}
+/** Merge nested run_config from GET /v1/jobs/:id with top-level monitor fields. */
+export function runConfigSource(data) {
+    const rc = data.run_config;
+    if (rc && typeof rc === "object") {
+        return { ...data, ...rc };
+    }
+    return data;
+}
+export function buildRunConfigRows(data) {
+    const src = runConfigSource(data);
+    const rows = [];
+    if (src.label)
+        rows.push(["Label", String(src.label)]);
+    const dsName = src.dataset_name ?? data.dataset_name;
+    const dsId = src.dataset_id ?? data.dataset_id;
+    if (dsName) {
+        const idHint = dsId ? ` (${String(dsId).slice(0, 8)}…)` : "";
+        rows.push(["Dataset", `${String(dsName)}${idHint}`]);
+    }
+    else if (dsId) {
+        rows.push(["Dataset id", String(dsId)]);
+    }
+    const featStr = formatFeatures(src.feature_columns ?? src.columns);
+    if (featStr)
+        rows.push(["Features", featStr]);
+    if (src.batch_size != null)
+        rows.push(["Batch", String(src.batch_size)]);
+    if (src.preset)
+        rows.push(["Preset", String(src.preset)]);
+    const gridStr = formatGrid(src.grid);
+    if (gridStr)
+        rows.push(["Grid", gridStr]);
+    const epStr = formatEpochs(src.epochs);
+    if (epStr)
+        rows.push(["Epochs", epStr]);
+    if (src.reference_mesh)
+        rows.push(["Reference", String(src.reference_mesh)]);
+    const moStr = formatMeshOrder(src.mesh_order);
+    if (moStr)
+        rows.push(["Mesh order", moStr]);
+    if (src.stratify_scale != null)
+        rows.push(["Stratify", String(src.stratify_scale)]);
+    if (src.emd_method)
+        rows.push(["EMD", String(src.emd_method)]);
+    if (src.backend)
+        rows.push(["Backend", String(src.backend)]);
+    if (data.dataset_rows != null) {
+        rows.push(["Rows", Number(data.dataset_rows).toLocaleString()]);
+    }
+    if (data.attempt != null && Number(data.attempt) > 1) {
+        rows.push(["Attempt", String(data.attempt)]);
+    }
+    return rows;
+}
+export function formatRunConfigTable(data) {
+    const rows = buildRunConfigRows(data);
+    if (rows.length === 0)
+        return "";
+    return `Run config — ${rows.map(([l, v]) => `${l}: ${v}`).join(" | ")}`;
+}
+export function finalizeSubStatusLine(data) {
+    const finalizeId = data.finalize_job_id != null && String(data.finalize_job_id) !== ""
+        ? String(data.finalize_job_id)
+        : null;
+    if (!finalizeId)
+        return null;
+    const st = String(data.finalize_status ?? "unknown");
+    const prog = data.finalize_progress != null ? `${(Number(data.finalize_progress) * 100).toFixed(0)}%` : null;
+    const phase = data.finalize_phase != null && String(data.finalize_phase) !== ""
+        ? String(data.finalize_phase)
+        : null;
+    const bits = [`cfd_finalize ${finalizeId}: ${st}`];
+    if (prog)
+        bits.push(prog);
+    if (phase)
+        bits.push(`phase ${phase}`);
+    return bits.join(", ");
+}
+export function isTerminalJobStatus(status) {
+    return status === "completed" || status === "failed" || status === "cancelled";
+}
+/** Keep polling while finalize is still running after parent compute completed. */
+export function shouldKeepPollingJob(data) {
+    const status = String(data.status ?? "");
+    if (!isTerminalJobStatus(status))
+        return true;
+    if (status !== "completed")
+        return false;
+    if (data.finalize_failed === true)
+        return false;
+    const finalizeId = data.finalize_job_id != null && String(data.finalize_job_id) !== ""
+        ? String(data.finalize_job_id)
+        : null;
+    const finalizeStatus = data.finalize_status != null && String(data.finalize_status) !== ""
+        ? String(data.finalize_status)
+        : null;
+    return finalizeId != null && finalizeStatus !== "completed";
+}
+/** True when compute + finalize (if any) are done — safe to show results_explorer hint. */
+export function isFullyComplete(data) {
+    const status = String(data.status ?? "");
+    if (status !== "completed")
+        return isTerminalJobStatus(status);
+    const finalizeId = data.finalize_job_id != null && String(data.finalize_job_id) !== ""
+        ? String(data.finalize_job_id)
+        : null;
+    if (!finalizeId)
+        return true;
+    return String(data.finalize_status ?? "") === "completed";
+}

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.2";
 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,8 @@ 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";
+import { formatRunConfigTable } from "../run_config.js";
 export const TRAINING_MONITOR_URI = "ui://barmesh/training-monitor";
 export const TRAINING_MONITOR_REFRESH_MS = 5000;
 function buildStructuredContent(job_id, data) {
@@ -33,7 +34,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);
@@ -51,7 +52,9 @@ export function registerTrainingMonitorTool(server) {
             timingParts.push(`epoch ${epoch}/${totalEpochs}`);
         const timingNote = timingParts.length > 0 ? ` ${timingParts.join(", ")}.` : "";
         const modeNote = terminal ? " (post-hoc review — training-log curves)" : "";
-        const text = `Training monitor (visual MCP App, refreshes every ${TRAINING_MONITOR_REFRESH_MS / 1000}s): job ${job_id} — ${jobStatus} (${progress.toFixed(1)}%).${modeNote}${timingNote}`;
+        const runConfigNote = formatRunConfigTable(data);
+        const text = (runConfigNote ? `${runConfigNote}\n` : "") +
+            `Training monitor (visual MCP App, refreshes every ${TRAINING_MONITOR_REFRESH_MS / 1000}s): job ${job_id} — ${jobStatus} (${progress.toFixed(1)}%).${modeNote}${timingNote}`;
         const content = [{ type: "text", text }];
         const port = getVizPort();
         const standaloneUrl = port
@@ -71,6 +74,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

@@ -9,13 +9,38 @@ export function combinedBatchAxis(nOrd, nConv) {
         return [];
     return [...batchSampleAxis(nOrd, 0), ...batchSampleAxis(nConv, nOrd)];
 }
+export function isKernelTrainingComplete(data, status) {
+    if (status === "failed" || status === "cancelled")
+        return true;
+    if (data.kernel_complete === true)
+        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 formatCurveSourceNote(data) {
     const src = data.training_curve_source_batches;
-    if (!src)
-        return null;
     const parts = [];
-    const ordTotal = typeof src.ordering === "number" ? src.ordering : null;
-    const convTotal = typeof src.convergence === "number" ? src.convergence : null;
+    const ordTotal = src && typeof src.ordering === "number" ? src.ordering : null;
+    const convTotal = src && typeof src.convergence === "number" ? src.convergence : null;
     const ordShown = Array.isArray(data.ordering_errors) ? data.ordering_errors.length : 0;
     const convShown = Array.isArray(data.convergence_errors) ? data.convergence_errors.length : 0;
     if (ordTotal != null && ordTotal > ordShown) {
@@ -24,7 +49,52 @@ 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)})`);
+    }
+    else if (mapTe != null && Number.isFinite(Number(mapTe))) {
+        parts.push(`TE curve final point is full-map topographic error (${Number(mapTe).toFixed(4)}).`);
+    }
     if (parts.length === 0)
         return null;
-    return `Displaying uniformly subsampled curves (≤1000 points/phase): ${parts.join("; ")}.`;
+    const subsample = ordTotal != null || convTotal != null
+        ? "Displaying uniformly subsampled QE+TE curves (≤1000 points/phase, joint indices): "
+        : "";
+    return `${subsample}${parts.join("; ")}.`.replace(/: ;/, ":");
+}
+/** 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,36 +5,68 @@
 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";
 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 snapTeCurvesToMapTe(merged);
     }
     catch {
-        return data;
+        if (epochTe != null) {
+            return snapTeCurvesToMapTe({ ...data, epoch_topographic_error: epochTe });
+        }
+        return data.kernel_complete === true ? snapTeCurvesToMapTe(data) : data;
     }
 }
 /** Evenly sample indices for a compact epoch/QE timeline in review mode. */
@@ -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):");