@barivia/barsom-mcp 0.15.3 → 0.17.0

package/dist/tools/training_core.js

@@ -10,6 +10,16 @@ export async function fetchTrainingPresets() {
     const configData = (await apiCall("GET", "/v1/training/config"));
     return configData?.presets || {};
 }
+/**
+ * Fetch presets + the plan-scoped allowed_job_types in one /v1/training/config call.
+ * Used by training_prep to filter the train-action selector to entitled modes.
+ */
+export async function fetchTrainingConfig() {
+    const configData = (await apiCall("GET", "/v1/training/config"));
+    const presets = configData?.presets || {};
+    const allowedJobTypes = configData?.guidance_scope?.allowed_job_types || [];
+    return { presets, allowedJobTypes };
+}
 /**
  * Zod raw shape for all training parameters (core SOM + impute + SIOM + FLooP).
  * Spread into the `train` tool input schema and the deprecated `jobs` wrapper
@@ -48,7 +58,8 @@ export const TRAINING_INPUT_SCHEMA = {
         separator: z.string().optional(),
     })).optional(),
     feature_weights: z.record(z.number()).optional(),
-    transforms: z.record(z.enum(["log", "log1p", "log10", "sqrt", "square", "abs", "invert", "rank", "none"])).optional(),
+    transforms: z.record(z.enum(["log", "log1p", "log10", "sqrt", "square", "abs", "invert", "rank", "none"])).optional()
+        .describe("Per-column transform before normalization. rank is train-only (no batch predict/project_columns). Not for train(impute)."),
     auto_log_transforms: z.boolean().optional().default(false),
     time_delay_embeddings: z.array(z.object({
         feature: z.string(),
@@ -59,7 +70,9 @@ export const TRAINING_INPUT_SCHEMA = {
         categories: z.array(z.string()),
         weight: z.number().positive()
     })).optional(),
-    normalize: z.union([z.enum(["all", "auto", "mad", "sigmoidal"]), z.array(z.string())]).optional().default("auto"),
+    normalize: z.union([z.enum(["all", "auto", "mad", "sigmoidal", "sepd"]), z.array(z.string())]).optional().default("auto"),
+    normalization_methods: z.record(z.enum(["zscore", "mad", "sigmoidal", "sepd", "none"])).optional()
+        .describe("Per-feature normalization override. Use MAD for heavy tails; SEPD for skewed financial/policy columns (see training_guidance). Default auto=zscore on non-cyclics. train(impute) rejects sepd."),
     sigma_f: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
     learning_rate: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.union([z.number(), z.object({
             ordering: z.tuple([z.number(), z.number()]),
@@ -80,12 +93,18 @@ export const TRAINING_INPUT_SCHEMA = {
         .describe("With viz_mode=summary_plus_top: upload top-N component maps by variance (default 8)"),
     emit_cell_uncertainty: z.boolean().optional()
         .describe("impute: write imputation_uncertainty.csv (pool_std per imputed cell)"),
-    gamma: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
-    gamma_f: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
-    siom_decay: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
-    siom_penalty: z.enum(["linear", "log", "exp"]).optional(),
-    penalty_alpha: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
-    reset_per_epoch: z.boolean().optional(),
+    gamma: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional())
+        .describe("siom_map / impute (SIOM or auto on som_siom+): self-interaction strength γ (default 0.5 on worker)"),
+    gamma_f: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional())
+        .describe("siom_map / impute SIOM: final γ for exponential decay schedule (0 = constant γ)"),
+    siom_decay: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional())
+        .describe("siom_map / impute SIOM: occupation EMA decay λ (default 0.01; 0 = cumulative counting)"),
+    siom_penalty: z.enum(["linear", "log", "exp"]).optional()
+        .describe("siom_map / impute SIOM: occupation penalty shape"),
+    penalty_alpha: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional())
+        .describe("siom_map / impute SIOM: scaling α inside log/exp penalty"),
+    reset_per_epoch: z.boolean().optional()
+        .describe("siom_map / impute SIOM: reset occupation μ at each epoch"),
     siom_feature_geometry: z.enum(["l2", "mixed", "auto"]).optional().describe("siom_map: l2 (default) = legacy L2 on cos/sin columns; mixed = cyclic torus distance when cyclic pairs exist; auto = mixed only when cyclic encodings are present"),
     siom_qe_backend: z.enum(["cpu", "cuda", "auto"]).optional().describe("siom_map: backend for metric-aligned siom_qe when using mixed geometry; auto uses GPU when available"),
     siom_qe_batch_size: z.number().int().min(1).max(1_000_000).optional().describe("siom_map: batch size for GPU SIOM QE (default 256 on worker)"),
@@ -109,14 +128,112 @@ export const TRAINING_INPUT_SCHEMA = {
     elastic_anchor: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
     anchor_percentile: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
 };
+/**
+ * Build the FLooP-SIOM job params + summary from raw args. Shared single source for
+ * the `train` tool and `training_prep` so the growing-manifold knobs never drift.
+ * (FLooP has no fixed grid/epochs; it uses topology/max_nodes/effort + growth knobs.)
+ */
+export function buildFloopParams(args) {
+    const { columns, cyclic_features, temporal_features, feature_weights, transforms, auto_log_transforms, normalize, row_range, output_format, output_dpi, colormap, topology, max_nodes, effort, n_initial, n_passes, growth_interval, neighborhood_size, edge_max_age, max_degree, gamma, siom_decay, siom_penalty, penalty_alpha, error_threshold, error_decay, ring_close_threshold, sigma_0, sigma_f, eta_0, eta_f, elastic_lambda, elastic_mu, elastic_anchor, anchor_percentile, } = args;
+    const params = {
+        _job_type: "train_floop_siom",
+        topology: topology ?? "free",
+        effort: effort ?? "standard",
+        normalize: normalize ?? "auto",
+        output_format: output_format ?? "png",
+    };
+    if (max_nodes !== undefined)
+        params.max_nodes = max_nodes;
+    if (columns?.length)
+        params.columns = columns;
+    if (cyclic_features?.length)
+        params.cyclic_features = cyclic_features;
+    if (temporal_features?.length)
+        params.temporal_features = temporal_features;
+    if (feature_weights && Object.keys(feature_weights).length > 0)
+        params.feature_weights = feature_weights;
+    if (transforms && Object.keys(transforms).length > 0)
+        params.transforms = transforms;
+    if (auto_log_transforms)
+        params.auto_log_transforms = auto_log_transforms;
+    if (row_range && row_range.length >= 2 && row_range[0] <= row_range[1])
+        params.row_range = row_range;
+    const dpiMap = { standard: 1, retina: 2, print: 4 };
+    if (output_dpi && output_dpi !== "retina")
+        params.output_dpi = dpiMap[output_dpi] ?? 2;
+    if (colormap)
+        params.colormap = colormap;
+    if (n_initial !== undefined)
+        params.n_initial = n_initial;
+    if (n_passes !== undefined)
+        params.n_passes = n_passes;
+    if (growth_interval !== undefined)
+        params.growth_interval = growth_interval;
+    if (neighborhood_size !== undefined)
+        params.neighborhood_size = neighborhood_size;
+    if (edge_max_age !== undefined)
+        params.edge_max_age = edge_max_age;
+    if (max_degree !== undefined)
+        params.max_degree = max_degree;
+    if (gamma !== undefined)
+        params.gamma = gamma;
+    if (siom_decay !== undefined)
+        params.siom_decay = siom_decay;
+    if (siom_penalty !== undefined)
+        params.siom_penalty = siom_penalty;
+    if (penalty_alpha !== undefined)
+        params.penalty_alpha = penalty_alpha;
+    if (error_threshold !== undefined)
+        params.error_threshold = error_threshold;
+    if (error_decay !== undefined)
+        params.error_decay = error_decay;
+    if (ring_close_threshold !== undefined)
+        params.ring_close_threshold = ring_close_threshold;
+    if (sigma_0 !== undefined)
+        params.sigma_0 = sigma_0;
+    if (sigma_f !== undefined)
+        params.sigma_f = sigma_f;
+    if (eta_0 !== undefined)
+        params.eta_0 = eta_0;
+    if (eta_f !== undefined)
+        params.eta_f = eta_f;
+    if (elastic_lambda !== undefined)
+        params.elastic_lambda = elastic_lambda;
+    if (elastic_mu !== undefined)
+        params.elastic_mu = elastic_mu;
+    if (elastic_anchor !== undefined)
+        params.elastic_anchor = elastic_anchor;
+    if (anchor_percentile !== undefined)
+        params.anchor_percentile = anchor_percentile;
+    const maxNodeSummary = max_nodes === undefined ? "max_nodes=auto(~2*sqrt(n_samples))" : `max_nodes=${max_nodes}`;
+    const paramSummary = [
+        "variant=floop",
+        `topology=${topology ?? "free"}`,
+        maxNodeSummary,
+        `effort=${effort ?? "standard"}`,
+        n_initial !== undefined ? `n_initial=${n_initial}` : "",
+        growth_interval !== undefined ? `growth_interval=${growth_interval}` : "",
+        n_passes !== undefined ? `n_passes=${n_passes}` : "",
+        gamma !== undefined ? `gamma=${gamma}` : "",
+        siom_decay !== undefined ? `siom_decay=${siom_decay}` : "",
+        siom_penalty !== undefined ? `siom_penalty=${siom_penalty}` : "",
+        elastic_lambda !== undefined ? `elastic_lambda=${elastic_lambda}` : "",
+        elastic_mu !== undefined ? `elastic_mu=${elastic_mu}` : "",
+        elastic_anchor !== undefined ? `elastic_anchor=${elastic_anchor}` : "",
+    ].filter(Boolean).join(", ");
+    return { params, paramSummary };
+}
 export function buildTrainMapParams(args, presets) {
-    const { preset, grid_x, grid_y, epochs, model, periodic, columns, cyclic_features, temporal_features, feature_weights, transforms, auto_log_transforms, time_delay_embeddings, categorical_features, normalize, sigma_f, learning_rate, batch_size, quality_metrics, backend, output_format, output_dpi, colormap, row_range, siom_feature_geometry, siom_qe_backend, siom_qe_batch_size, } = args;
+    const { preset, grid_x, grid_y, epochs, model, periodic, columns, cyclic_features, temporal_features, feature_weights, transforms, auto_log_transforms, time_delay_embeddings, categorical_features, normalize, normalization_methods, sigma_f, learning_rate, batch_size, quality_metrics, backend, output_format, output_dpi, colormap, row_range, siom_feature_geometry, siom_qe_backend, siom_qe_batch_size, } = args;
     const p = preset ? presets[preset] : undefined;
     const params = {
         model: model ?? "SOM",
         periodic: periodic ?? true,
         normalize: normalize ?? "auto",
     };
+    if (normalization_methods && Object.keys(normalization_methods).length > 0) {
+        params.normalization_methods = normalization_methods;
+    }
     if (grid_x !== undefined && grid_y !== undefined)
         params.grid = [grid_x, grid_y];
     else if (p)

package/dist/tools/training_guidance.js

@@ -1,7 +1,7 @@
 import { registerAuditedTool } from "../audit.js";
 import { fetchTrainingGuidanceFromApi } from "../shared.js";
 export function registerTrainingGuidanceTool(server) {
-    registerAuditedTool(server, "training_guidance", "Structured parameter guidance for training (presets, grid/epochs/batch, model, periodic, SIOM/FLooP fields where your plan allows, categorical baselines). Served from the API and filtered to allowed_job_types. Prep ladder: prepare_training prompt = narrative checklist; this tool = JSON/hints; training_prep = interactive UI + submit_prepared_training. For full orientation and SOP, call guide_barsom_workflow first. Optional UIs: training_prep, results_explorer—not required; jobs + results suffice.", {}, async () => {
+    registerAuditedTool(server, "training_guidance", "Structured parameter guidance for training (presets, grid/epochs/batch, model, periodic, SIOM/FLooP fields where your plan allows, categorical baselines, normalization MAD vs SEPD guide). Served from the API and filtered to allowed_job_types. Prep ladder: prepare_training prompt = narrative checklist; this tool = JSON/hints + normalization decision ladder; training_prep = interactive UI + submit_prepared_training. For full orientation and SOP, call guide_barsom_workflow first. Optional UIs: training_prep, results_explorer—not required; jobs + results suffice.", {}, async () => {
         const text = await fetchTrainingGuidanceFromApi();
         return { content: [{ type: "text", text }] };
     });

package/dist/tools/training_monitor.js

@@ -3,6 +3,16 @@ import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import { runMcpToolAudit } from "../audit.js";
 import { apiCall, getClientSupportsMcpApps, getVizPort, structuredTextResult, } from "../shared.js";
 export const TRAINING_MONITOR_URI = "ui://barsom/training-monitor";
+export const TRAINING_MONITOR_REFRESH_MS = 5000;
+function hasCurveArrays(data) {
+    const keys = [
+        "ordering_errors",
+        "convergence_errors",
+        "ordering_topographic_errors",
+        "convergence_topographic_errors",
+    ];
+    return keys.some((k) => Array.isArray(data[k]) && data[k].length > 0);
+}
 function buildStructuredContent(job_id, data) {
     const id = String(data.id ?? job_id);
     return {
@@ -11,24 +21,73 @@ function buildStructuredContent(job_id, data) {
         jobId: id,
         id,
         job_id: id,
+        refresh_interval_ms: TRAINING_MONITOR_REFRESH_MS,
     };
 }
+async function enrichWithTrainingLog(job_id, data) {
+    const status = String(data.status ?? "");
+    if (status !== "completed" && status !== "failed")
+        return data;
+    if (hasCurveArrays(data))
+        return data;
+    try {
+        const log = (await apiCall("GET", `/v1/results/${job_id}/training-log`));
+        return {
+            ...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,
+            model: log.model ?? data.model,
+            epochs: log.epochs ?? data.epochs,
+            n_samples: log.n_samples ?? data.n_samples,
+            n_features: log.n_features ?? data.n_features,
+        };
+    }
+    catch {
+        return data;
+    }
+}
 export function registerTrainingMonitorTool(server) {
     registerAppTool(server, "training_monitor", {
         title: "Training Monitor",
-        description: "Optional embedded or standalone view of training progress for a job_id. Same information is available via jobs(action=status, job_id=...)—use this when the user wants charts or a live panel; not required to complete training or read results.",
+        description: "Optional embedded or standalone view of training progress for a job_id. When embedded in a client that supports MCP Apps, the panel auto-refreshes every 5s until the job completes: live QE/TE learning curves plus a per-epoch hit-distribution heatmap (sampled BMU counts across the map, showing where observations are landing as training proceeds). A standalone browser URL is also available. The same scalar fields are available via jobs(action=status)—not required to complete training or read results.",
         inputSchema: {
             job_id: z.string().describe("Training job ID to monitor"),
+            fetch_training_log: z
+                .boolean()
+                .optional()
+                .describe("Internal: merge completed-job training-log arrays when live progress is empty"),
         },
         _meta: { ui: { resourceUri: TRAINING_MONITOR_URI } },
     }, async (args) => runMcpToolAudit("training_monitor", "default", args, async () => {
-        const job_id = String(args.job_id);
-        const data = (await apiCall("GET", `/v1/jobs/${job_id}`));
+        const { job_id, fetch_training_log } = args;
+        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))) {
+            data = await enrichWithTrainingLog(job_id, data);
+        }
         const structuredContent = buildStructuredContent(job_id, data);
-        const status = String(data.status ?? "unknown");
+        const status = jobStatus;
         const progress = (data.progress ?? 0) * 100;
-        const text = `Training monitor snapshot: job ${job_id} — ${status} (${progress.toFixed(1)}%). ` +
-            `Optional UI; polling jobs(action=status) is enough to finish the workflow.`;
+        const etaSec = data.training_eta_sec != null ? Number(data.training_eta_sec) : null;
+        const elapsedSec = data.training_elapsed_sec != null ? Number(data.training_elapsed_sec) : null;
+        const epoch = data.epoch != null ? Number(data.epoch) : null;
+        const totalEpochs = data.total_epochs != null ? Number(data.total_epochs) : null;
+        const timingParts = [];
+        if (elapsedSec != null && elapsedSec >= 0)
+            timingParts.push(`elapsed ${Math.round(elapsedSec)}s`);
+        if (etaSec != null && etaSec > 0)
+            timingParts.push(`ETA ~${Math.round(etaSec)}s`);
+        if (epoch != null && totalEpochs != null)
+            timingParts.push(`epoch ${epoch}/${totalEpochs}`);
+        const timingNote = timingParts.length > 0 ? ` ${timingParts.join(", ")}.` : "";
+        const text = `Training monitor (live when embedded, refreshes every ${TRAINING_MONITOR_REFRESH_MS / 1000}s): job ${job_id} — ${status} (${progress.toFixed(1)}%).${timingNote} ` +
+            `Optional UI; jobs(action=status) is enough to finish the workflow.`;
         const content = [{ type: "text", text }];
         const port = getVizPort();
         const standaloneUrl = port

package/dist/tools/training_prep.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import { registerAuditedTool, runMcpToolAudit } from "../audit.js";
 import { apiCall, fetchTrainingGuidanceFromApi, getClientSupportsMcpApps, getVizPort, pollUntilComplete, POLL_DERIVE_MAX_MS, structuredTextResult, } from "../shared.js";
-import { buildTrainMapParams, fetchTrainingPresets, } from "./training_core.js";
+import { buildTrainMapParams, buildFloopParams, fetchTrainingConfig, } from "./training_core.js";
 import { attachTrainingReviewPayload, consumeTrainingReview, getTrainingReview, storeTrainingReview, } from "./training_review_store.js";
 export const TRAINING_PREP_URI = "ui://barsom/training-prep";
 /**
@@ -162,20 +162,131 @@ function buildGuidanceLines(guidanceText) {
     }
     return [...new Set(lines)];
 }
-async function buildTrainingPrepPayload(datasetId, input) {
-    const [preview, analyze, presets, guidanceText, preparePrompt] = await Promise.all([
+function buildSuggestedNormalizationMethods(analyze) {
+    const hints = analyze.normalization_hints;
+    if (!hints || typeof hints !== "object")
+        return undefined;
+    const out = {};
+    for (const [col, hint] of Object.entries(hints)) {
+        if (hint === "mad" || hint === "sepd") {
+            out[col] = hint;
+        }
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+function buildSuggestedTransforms(analyze) {
+    const hints = analyze.normalization_hints;
+    if (!hints || typeof hints !== "object")
+        return undefined;
+    const out = {};
+    for (const [col, hint] of Object.entries(hints)) {
+        if (hint === "log_then_zscore") {
+            out[col] = "log";
+        }
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+/** Prep action -> (entitlement job type, review store action, display label). */
+const PREP_ACTION_META = {
+    map: { jobType: "train_som", storeAction: "train_map", label: "Map (standard SOM)" },
+    siom_map: { jobType: "train_siom", storeAction: "train_siom", label: "SIOM map" },
+    impute: { jobType: "train_impute", storeAction: "train_impute", label: "Impute (sparse → map + imputed.csv)" },
+    floop_siom: { jobType: "train_floop_siom", storeAction: "train_floop_siom", label: "FLooP-SIOM (growing manifold)" },
+};
+function buildTrainActionOptions(allowedJobTypes) {
+    const allowed = new Set(allowedJobTypes);
+    // map is always available (train_som is the baseline entitlement); gate siom/impute.
+    return Object.keys(PREP_ACTION_META)
+        .filter((action) => action === "map" || allowed.size === 0 || allowed.has(PREP_ACTION_META[action].jobType))
+        .map((action) => ({ value: action, label: PREP_ACTION_META[action].label }));
+}
+/**
+ * Apply the action-specific job-type + knobs onto the params built by
+ * buildTrainMapParams (mirrors the train tool's runTrain for map/siom/impute).
+ */
+function applyPrepActionParams(action, params, input) {
+    if (action === "siom_map") {
+        params._job_type = "train_siom";
+    }
+    else if (action === "impute") {
+        params._job_type = "train_impute";
+        params.model = input.model ?? "auto";
+        params.cv_folds = 5;
+        // impute does not accept these (mirror train.ts) and rejects sepd (warned separately).
+        delete params.categorical_features;
+        delete params.auto_log_transforms;
+        delete params.time_delay_embeddings;
+    }
+}
+/** Effective per-column normalization method, mirroring the worker/auto policy. */
+function resolveColumnNormalization(column, normalize, methods, isCyclic) {
+    if (isCyclic)
+        return "cyclic_encoding";
+    if (methods && methods[column])
+        return methods[column];
+    if (typeof normalize === "string") {
+        if (normalize === "mad" || normalize === "sigmoidal" || normalize === "sepd")
+            return normalize;
+        return "zscore"; // auto / all -> z-score on non-cyclic numerics
+    }
+    return "zscore";
+}
+function normalizationDetail(method, stat, staging) {
+    const fmt = (v) => (v === null || v === undefined ? "?" : Number(v).toFixed(3));
+    const nulls = staging?.null_count ?? stat?.null_count;
+    const nullBit = nulls !== undefined && nulls !== null ? ` [nulls=${nulls}]` : "";
+    switch (method) {
+        case "zscore":
+            return `z-score · mean=${fmt(stat?.mean)}, std=${fmt(stat?.std)}${nullBit}`;
+        case "mad":
+            return `MAD (robust to heavy tails) · min=${fmt(stat?.min)}, max=${fmt(stat?.max)}${nullBit}`;
+        case "sigmoidal":
+            return `sigmoidal (logistic squashing of mean=${fmt(stat?.mean)}, std=${fmt(stat?.std)})${nullBit}`;
+        case "sepd":
+            return `SEPD (skewed exponential power; for skewed financial/policy columns)${nullBit}`;
+        case "none":
+            return `none (raw values)${nullBit}`;
+        case "cyclic_encoding":
+            return `cyclic (encoded as cos/sin, not separately normalized)`;
+        default:
+            return `${method}${nullBit}`;
+    }
+}
+function buildNormalizationPlan(selectedColumns, params, preview, analyze) {
+    const statByColumn = new Map((preview.column_stats ?? []).map((s) => [String(s.column ?? ""), s]));
+    const stagingStats = analyze.column_staging_stats ?? {};
+    const methods = params.normalization_methods;
+    const cyclicNames = new Set((params.cyclic_features ?? []).map((c) => c.feature));
+    return selectedColumns.map((column) => {
+        const method = resolveColumnNormalization(column, params.normalize, methods, cyclicNames.has(column));
+        return {
+            column,
+            method,
+            detail: normalizationDetail(method, statByColumn.get(column), stagingStats[column]),
+        };
+    });
+}
+async function buildTrainingPrepPayload(datasetId, input, trainAction) {
+    const [preview, analyze, config, guidanceText, preparePrompt] = await Promise.all([
         apiCall("GET", `/v1/datasets/${datasetId}/preview?n_rows=5`),
         fetchAnalyzeData(datasetId),
-        fetchTrainingPresets().catch(() => ({})),
+        fetchTrainingConfig().catch(() => ({ presets: {}, allowedJobTypes: [] })),
         fetchTrainingGuidanceFromApi().catch(() => "No training guidance available."),
         fetchPreparePrompt(datasetId),
     ]);
+    const presets = config.presets;
     const selectedColumns = input.columns?.length
         ? input.columns
         : getRecommendedTrainColumns(preview, analyze);
     const resolvedInput = { ...input, columns: selectedColumns };
-    const { params } = buildTrainMapParams(resolvedInput, presets);
-    const review = storeTrainingReview(datasetId, params, "train_map");
+    const isFloop = trainAction === "floop_siom";
+    const params = isFloop
+        ? buildFloopParams(resolvedInput).params
+        : buildTrainMapParams(resolvedInput, presets).params;
+    if (!isFloop)
+        applyPrepActionParams(trainAction, params, resolvedInput);
+    const normalizationPlan = buildNormalizationPlan(selectedColumns, params, preview, analyze);
+    const review = storeTrainingReview(datasetId, params, PREP_ACTION_META[trainAction].storeAction);
     const recommendations = analyze.recommendations ?? {};
     const projectLater = recommendations.project_later ?? [];
     const transforms = Object.entries(params.transforms ?? {})
@@ -194,7 +305,25 @@ async function buildTrainingPrepPayload(datasetId, input) {
     const epochs = getEpochFields(params);
     const grid = params.grid ?? [];
     const warnings = buildWarnings(preview, selectedColumns, params, analyze);
+    if (trainAction === "impute") {
+        const sepdCols = normalizationPlan.filter((n) => n.method === "sepd").map((n) => n.column);
+        if (params.normalize === "sepd" || sepdCols.length > 0) {
+            warnings.push(`SEPD normalization is not allowed for impute (train(impute) rejects sepd)${sepdCols.length ? `: ${sepdCols.join(", ")}` : ""}. Switch these columns to mad/zscore before submit.`);
+        }
+    }
+    const suggestedNormalizationMethods = buildSuggestedNormalizationMethods(analyze);
+    const suggestedTransforms = buildSuggestedTransforms(analyze);
     const recommendationLines = buildDataRecommendations(analyze);
+    if (suggestedNormalizationMethods) {
+        recommendationLines.push("Suggested normalization_methods (confirm before submit): " +
+            JSON.stringify(suggestedNormalizationMethods) +
+            " — see training_guidance for MAD vs SEPD ladder. train(impute) rejects sepd.");
+    }
+    if (suggestedTransforms) {
+        recommendationLines.push("Suggested transforms before normalization (confirm before submit): " +
+            JSON.stringify(suggestedTransforms) +
+            " — rank is train-only (no inference); not for train(impute).");
+    }
     const guidanceLines = buildGuidanceLines(guidanceText);
     const datasetName = String(preview.name ?? datasetId);
     const sections = [
@@ -208,6 +337,15 @@ async function buildTrainingPrepPayload(datasetId, input) {
                 ? [...projectLater, "(These columns are good candidates for post-training projection onto the map.)"]
                 : ["None"],
         },
+        {
+            label: "Preprocessing / Normalization (per column)",
+            items: normalizationPlan.length > 0
+                ? [
+                    ...normalizationPlan.map((n) => `${n.column}: ${n.method} — ${n.detail}`),
+                    "Tweak via normalization_methods (per column) or a global normalize; changing these reruns preprocessing (new recipe) on the next submit.",
+                ]
+                : ["No training columns resolved yet."],
+        },
         {
             label: "Transformations",
             items: transforms.length > 0 ? transforms : ["None"],
@@ -218,14 +356,25 @@ async function buildTrainingPrepPayload(datasetId, input) {
         },
         {
             label: "Hyperparameters",
-            items: [
-                `Model: ${String(params.model ?? "SOM")}`,
-                `Grid: ${grid.length >= 2 ? `${grid[0]}×${grid[1]}` : "auto"}`,
-                `Epochs: ${epochs.ordering || "auto"}${epochs.convergence ? ` + ${epochs.convergence}` : ""}`,
-                `Backend: ${String(params.backend ?? "auto")}`,
-                `Normalize: ${Array.isArray(params.normalize) ? params.normalize.join(", ") : String(params.normalize ?? "auto")}`,
-                `Output: ${String(params.output_format ?? "png")}`,
-            ],
+            items: isFloop
+                ? [
+                    `Variant: FLooP-SIOM (growing manifold — no fixed grid/epochs)`,
+                    `Topology: ${String(params.topology ?? "free")}`,
+                    `Max nodes: ${params.max_nodes !== undefined ? String(params.max_nodes) : "auto (~2·√n_samples)"}`,
+                    `Effort: ${String(params.effort ?? "standard")}`,
+                    params.gamma !== undefined ? `Gamma: ${String(params.gamma)}` : "",
+                    params.siom_decay !== undefined ? `SIOM decay: ${String(params.siom_decay)}` : "",
+                    `Normalize: ${Array.isArray(params.normalize) ? params.normalize.join(", ") : String(params.normalize ?? "auto")}`,
+                    `Output: ${String(params.output_format ?? "png")}`,
+                ].filter(Boolean)
+                : [
+                    `Model: ${String(params.model ?? "SOM")}`,
+                    `Grid: ${grid.length >= 2 ? `${grid[0]}×${grid[1]}` : "auto"}`,
+                    `Epochs: ${epochs.ordering || "auto"}${epochs.convergence ? ` + ${epochs.convergence}` : ""}`,
+                    `Backend: ${String(params.backend ?? "auto")}`,
+                    `Normalize: ${Array.isArray(params.normalize) ? params.normalize.join(", ") : String(params.normalize ?? "auto")}`,
+                    `Output: ${String(params.output_format ?? "png")}`,
+                ],
         },
     ];
     const port = getVizPort();
@@ -237,8 +386,11 @@ async function buildTrainingPrepPayload(datasetId, input) {
         reviewId: review.reviewId,
         reviewToken: review.reviewToken,
         reviewExpiresAt: new Date(review.expiresAt).toISOString(),
+        trainAction,
         selectedColumns,
         suggestedProjectionColumns: projectLater,
+        normalizationPlan,
+        suggestedNormalizationMethods,
         warnings,
         recommendations: recommendationLines,
         guidance: guidanceLines,
@@ -253,6 +405,12 @@ async function buildTrainingPrepPayload(datasetId, input) {
                 gridY: grid.length >= 2 ? String(grid[1]) : "",
                 epochsOrdering: epochs.ordering,
                 epochsConvergence: epochs.convergence,
+                trainAction,
+                columns: selectedColumns.join(", "),
+                normalizationMethodsJson: params.normalization_methods
+                    ? JSON.stringify(params.normalization_methods)
+                    : "",
+                transformsJson: params.transforms ? JSON.stringify(params.transforms) : "",
             },
             options: {
                 presetOptions: Object.keys(presets).map((value) => ({ value, label: value.replace("_", " ") })),
@@ -273,6 +431,7 @@ async function buildTrainingPrepPayload(datasetId, input) {
                     { value: "SOM-SOFT", label: "SOM-SOFT" },
                     { value: "RSOM-SOFT", label: "RSOM-SOFT" },
                 ],
+                trainActionOptions: buildTrainActionOptions(config.allowedJobTypes),
             },
         },
         draftArgs: {
@@ -284,9 +443,12 @@ async function buildTrainingPrepPayload(datasetId, input) {
         },
         summaryLines: [
             `Dataset: ${datasetName}`,
+            `Action: ${PREP_ACTION_META[trainAction].label}`,
             `Variables: ${selectedColumns.length > 0 ? selectedColumns.join(", ") : "Not selected"}`,
-            `Grid: ${grid.length >= 2 ? `${grid[0]}×${grid[1]}` : "auto"}`,
-            `Model: ${String(params.model ?? "SOM")} | Backend: ${String(params.backend ?? "auto")} | Output: ${String(params.output_format ?? "png")}`,
+            isFloop
+                ? `Topology: ${String(params.topology ?? "free")} | Max nodes: ${params.max_nodes !== undefined ? String(params.max_nodes) : "auto"} | Effort: ${String(params.effort ?? "standard")}`
+                : `Grid: ${grid.length >= 2 ? `${grid[0]}×${grid[1]}` : "auto"} | Model: ${String(params.model ?? "SOM")} | Backend: ${String(params.backend ?? "auto")} | Output: ${String(params.output_format ?? "png")}`,
+            `Normalization: ${normalizationPlan.length > 0 ? normalizationPlan.map((n) => `${n.column}→${n.method}`).join(", ") : "auto"}`,
         ],
         standaloneUrl,
     };
@@ -294,14 +456,25 @@ async function buildTrainingPrepPayload(datasetId, input) {
     return payload;
 }
 function buildTrainingPrepContent(payload) {
+    const normalizationBlock = payload.normalizationPlan.length > 0
+        ? [
+            "",
+            "Preprocessing / normalization plan (per column — review before submit):",
+            ...payload.normalizationPlan.map((n) => `  • ${n.column}: ${n.method} — ${n.detail}`),
+            "To change: re-call training_prep with normalization_methods (per column) and/or normalize/transforms; that reruns preprocessing on submit. Show this to the user and confirm before submit_prepared_training.",
+        ]
+        : [];
     const content = [
         {
             type: "text",
             text: [
                 `Training prep ready for ${payload.datasetName} (${payload.datasetId}).`,
-                `Review ID: ${payload.reviewId}`,
+                `Review ID: ${payload.reviewId} | Review token: ${payload.reviewToken ?? "(none)"}`,
                 ...payload.summaryLines,
                 payload.warnings.length > 0 ? `Warnings: ${payload.warnings.join(" | ")}` : "",
+                ...normalizationBlock,
+                "",
+                `When the user has confirmed, submit with submit_prepared_training(review_token="${payload.reviewToken ?? ""}", explicit_confirm=true).`,
             ].filter(Boolean).join("\n"),
         },
     ];
@@ -316,6 +489,8 @@ function buildTrainingPrepContent(payload) {
 export function registerTrainingPrepTools(server) {
     const trainPrepSchema = {
         dataset_id: z.string().describe("Dataset ID to prepare for training"),
+        train_action: z.enum(["map", "siom_map", "impute", "floop_siom"]).optional().default("map")
+            .describe("Which training mode to prepare: map (standard SOM), siom_map (self-interacting), impute (sparse → map + imputed.csv), or floop_siom (growing node-budget manifold). Filtered to your plan's allowed_job_types."),
         preset: z.enum(["quick", "standard", "refined", "high_res"]).optional(),
         grid_x: z.number().int().optional(),
         grid_y: z.number().int().optional(),
@@ -337,7 +512,8 @@ export function registerTrainingPrepTools(server) {
         feature_weights: z.record(z.number()).optional(),
         transforms: z.record(z.enum(["log", "log1p", "log10", "sqrt", "square", "abs", "invert", "rank", "none"])).optional(),
         auto_log_transforms: z.boolean().optional().default(false),
-        normalize: z.union([z.enum(["all", "auto", "mad", "sigmoidal"]), z.array(z.string())]).optional().default("auto"),
+        normalize: z.union([z.enum(["all", "auto", "mad", "sigmoidal", "sepd"]), z.array(z.string())]).optional().default("auto"),
+        normalization_methods: z.record(z.enum(["zscore", "mad", "sigmoidal", "sepd", "none"])).optional(),
         batch_size: z.number().int().optional(),
         backend: z.enum(["auto", "cpu", "gpu", "gpu_graphs"]).optional().default("auto"),
         output_format: z.enum(["png", "pdf", "svg"]).optional().default("png"),
@@ -345,14 +521,28 @@ export function registerTrainingPrepTools(server) {
         siom_feature_geometry: z.enum(["l2", "mixed", "auto"]).optional(),
         siom_qe_backend: z.enum(["cpu", "cuda", "auto"]).optional(),
         siom_qe_batch_size: z.number().int().min(1).max(1_000_000).optional(),
+        // FLooP-SIOM (train_action=floop_siom) — growing manifold; no fixed grid/epochs.
+        topology: z.enum(["free", "chain"]).optional(),
+        max_nodes: z.number().int().min(2).optional(),
+        effort: z.enum(["quick", "standard", "thorough"]).optional(),
+        n_initial: z.number().int().min(2).optional(),
+        n_passes: z.number().int().min(1).optional(),
+        growth_interval: z.number().int().min(1).optional(),
+        gamma: z.number().optional(),
+        siom_decay: z.number().optional(),
+        siom_penalty: z.enum(["linear", "log", "exp"]).optional(),
+        penalty_alpha: z.number().optional(),
+        elastic_lambda: z.number().optional(),
+        elastic_mu: z.number().optional(),
+        elastic_anchor: z.number().optional(),
     };
     registerAppTool(server, "training_prep", {
         title: "Training Preparation",
-        description: "Interactive training prep UI + guarded submit (submit_prepared_training). Prep ladder: prepare_training prompt = narrative checklist; training_guidance tool = JSON/presets; this tool = visual review. Opens inline review of variables, transforms, encodings, and hyperparameters.",
+        description: "Interactive training prep UI + guarded submit (submit_prepared_training). Shows the RESOLVED decisions before a job is committed: per-column normalization (z-score / MAD / SEPD / sigmoidal) with its stat, transforms, encodings, grid/epochs/model. Tweak normalization_methods, transforms, columns, or train_action and re-call to iterate preprocessing before submitting. Prep ladder: prepare_training prompt = narrative checklist; training_guidance tool = JSON/presets; this tool = visual review + guarded submit.",
         inputSchema: trainPrepSchema,
         _meta: { ui: { resourceUri: TRAINING_PREP_URI } },
-    }, async ({ dataset_id, ...args }) => runMcpToolAudit("training_prep", "default", { dataset_id, ...args }, async () => {
-        const payload = await buildTrainingPrepPayload(dataset_id, args);
+    }, async ({ dataset_id, train_action, ...args }) => runMcpToolAudit("training_prep", "default", { dataset_id, train_action, ...args }, async () => {
+        const payload = await buildTrainingPrepPayload(dataset_id, args, (train_action ?? "map"));
         return structuredTextResult(payload, undefined, buildTrainingPrepContent(payload));
     }));
     registerAuditedTool(server, "submit_prepared_training", "Submit a previously reviewed training-prep configuration. Requires an unexpired review token and explicit confirmation.", {