@barivia/barmesh-mcp 0.6.1 → 0.6.2

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/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,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,9 +49,24 @@ 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 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) {

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 } from "./training_monitor_curve.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";
@@ -60,13 +60,13 @@ export async function enrichWithTrainingLog(job_id, data) {
         if (isTerminalStatus(status)) {
             merged.topographic_error = mapTe;
         }
-        return merged;
+        return snapTeCurvesToMapTe(merged);
     }
     catch {
         if (epochTe != null) {
-            return { ...data, epoch_topographic_error: epochTe };
+            return snapTeCurvesToMapTe({ ...data, epoch_topographic_error: epochTe });
         }
-        return data;
+        return data.kernel_complete === true ? snapTeCurvesToMapTe(data) : data;
     }
 }
 /** Evenly sample indices for a compact epoch/QE timeline in review mode. */