@barivia/barmesh-mcp 0.6.1 → 0.6.3

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.6.1";
+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/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/tools/training_monitor.js

@@ -3,6 +3,7 @@ import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import { runMcpToolAudit } from "../audit.js";
 import { apiCall, getClientSupportsMcpApps, getVizPort, structuredTextResult, } from "../shared.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) {
@@ -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

package/dist/training_monitor_curve.js

@@ -9,13 +9,21 @@ 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";
+}
+export function teCurveLabel(base, _kernelComplete = false) {
+    return `${base} (panel)`;
+}
 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,9 +32,27 @@ export function formatCurveSourceNote(data) {
     if (convTotal != null && convTotal > convShown) {
         parts.push(`${convShown} of ${convTotal.toLocaleString()} convergence batch samples`);
     }
+    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}`);
+    }
+    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;
-    return `Displaying uniformly subsampled QE+TE curves (≤1000 points/phase, joint indices): ${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) {
@@ -42,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;