@barivia/barsom-mcp 0.11.1 → 0.14.0

package/dist/tools/jobs.js

@@ -1,56 +1,31 @@
 import { z } from "zod";
 import { registerAuditedTool } from "../audit.js";
 import { apiCall, textResult } from "../shared.js";
-export const JOBS_DESCRIPTION_BASE = `Manage and inspect jobs.
+import { runTrain } from "./train.js";
+import { runBatchPredict } from "./inference.js";
+import { TRAINING_INPUT_SCHEMA } from "./training_core.js";
+export const JOBS_DESCRIPTION_BASE = `Manage and inspect jobs (lifecycle).
 
 | Action | Use when |
 |--------|----------|
-| status | Polling after any async job submission — call every 10–15s |
-| list | Finding job IDs, checking what is pending/completed, reviewing hyperparameters. Response includes job_type (train_map, report, recolor, project, transition_flow, compare, predict, impute_column, annotated_dataset, reduce_spectral) to filter or display. |
-| compare | Picking the best training run from a set of completed jobs |
-| train_map | Submitting a new map training job — returns job_id for polling |
-| train_impute | Sparse training data: train a map AND impute missing cells in one job (accelerated missSOM) — returns map + imputed.csv |
-| train_siom_map | Submitting a self-interacting map training job — same map flow with SIOM coverage control |
-| train_floop_siom | Submitting a FLooP-SIOM job (growing manifold; default topology=free / CHL) — requires Premium or Enterprise plan (all_algorithms) |
-| train_floop_chain | Deprecated alias for train_floop_siom — same behavior; prefer train_floop_siom |
+| status | Polling after any async submission — call every 10–15s |
+| list | Finding job IDs / reviewing pipeline state (optionally filter by dataset_id) |
+| compare | Picking the best TRAINING run from a set (metrics table). NOT inference(compare), which diffs one dataset's distribution against the training set. |
 | cancel | Stopping a running or pending job to free the worker |
 | delete | Permanently removing a job and all its S3 result files |
 
-For parameter hints (grid, epochs, batch, model, periodic, FLooP max_nodes/effort), call the **training_guidance** tool or use the **prepare_training** prompt before training.
+To SUBMIT training, use the **train** tool (train(action=map | siom_map | impute | floop_siom | baseline_study)); to score data, use **inference**. The jobs(action=train_map | train_siom_map | train_impute | train_floop_siom | run_baseline_study | batch_predict) actions still work as **deprecated** forwarders for one release — migrate to train / inference.
 
 ASYNC POLLING PROTOCOL (action=status):
 - Poll every 10-15 seconds. Do NOT poll faster — it wastes context.
-- Progress increases through phases (ordering then convergence for map training). Other job types may use different phase logic.
+- Progress increases through phases (ordering then convergence for map training); other job types differ.
 - For large grids (40×40+), do not assume failure before 3 minutes on CPU.
-- Wait for status "completed" before calling results(action=get).
 - Map training typical times: 10×10 ~30s | 20×20 ~3–5 min | 40×40 ~15–30 min.
+- completed → results(action=get); failed → read error + optional failure_stage (preprocessing/training/metrics/visualization/upload): memory error → smaller grid/batch and retrain; column missing → datasets(action=preview); NaN on a standard map → train(action=impute) for sparse columns or clean the CSV.
 
-ESCALATION (action=status):
-- completed → call results(action=get) to retrieve the map and metrics
-- failed → error message and optional failure_stage (e.g. preprocessing, training, metrics, visualization, upload) indicate which phase broke:
-  - memory/allocation error: reduce batch_size or grid size and retrain
-  - column missing: verify with datasets(action=preview)
-  - NaN error on train_map: use jobs(action=train_impute) for sparse training columns, or clean the CSV for complete-case train_map
-
-action=train_map / train_siom_map: Submits a grid-map training job. Returns job_id — poll with jobs(action=status, job_id=...).
-action=train_impute: Submits missing-tolerant map training (accelerated missSOM / SIOM missSOM). Use when many cells are missing across training columns; use inference(impute_column) when you already have a complete-case map and need to fill one held-out column. Plain numeric columns only (no cyclic/temporal/categorical). Defaults: model=auto (SIOM on som_siom+ plans), cv_folds=5 → quality.csv. quality.csv reports two clearly-labeled numbers per column: kfold_holdout_pool (honest held-out) and resubstitution_optimistic (in-sample, optimistic). status returns progress_phase (e.g. ordering/convergence/cv/upload). High-dimensional datasets automatically adjust visualization density, metric set, and backend (call training_guidance for specifics). Params: viz_mode, viz_top_components, emit_cell_uncertainty, quality_metrics. Artifacts: imputed.csv, imputation_mask.csv, optional imputation_uncertainty.csv. Completed train_impute job_id is a valid parent for inference(impute_column).
-  Presets: quick | standard | refined | high_res — use preset=... for grid/epochs/batch defaults; call training_guidance for details.
-  Presets refined/high_res may use GPU. On CPU-only hosts pass backend=cpu. API expects strings "cpu" | "gpu" | "gpu_graphs" (no colon). Future backends (e.g. non-CUDA) may be added under the same contract.
-  normalize: "auto" (default) = scale only non-cyclic features; "all" = scale every feature. Use "auto" when using cyclic_features.
-  categorical_features: optional baseline categorical support using explicit weighted one-hot encoding. Provide the raw column name, allowed categories, and a weight. Advanced categorical embeddings are intentionally outside this default tool surface.
-  label (optional, ≤120 chars): user-supplied run name; appears in jobs(list) and jobs(compare) output. Strongly recommended for sweeps so compare rows stay readable.
-  train_siom_map only: siom_feature_geometry l2 (default) | mixed | auto — torus distance on cyclic (cos,sin) pairs when mixed or auto with cyclic encodings. siom_qe_backend cpu|cuda|auto and siom_qe_batch_size align siom_qe with training geometry when mixed.
-action=train_floop_siom (preferred) or train_floop_chain (deprecated alias): Submits FLooP-SIOM — a growing node-budget manifold instead of a fixed hex grid. **Only if the API key’s plan includes all_algorithms** (Premium or Enterprise); otherwise the API returns a clear upgrade message. Default topology is free (CHL dynamic graph); topology=chain is optional for a strict 1D linked-list backbone.
-  Key params: topology (default free), max_nodes, effort, gamma, siom_decay.
-  max_nodes is a total node budget, not a grid width or area. If omitted, the backend uses a dataset-size heuristic (roughly 2*sqrt(n_samples), capped for stability).
-  effort controls passes only: quick≈15, standard≈30, thorough≈60. If coverage collapses, reduce max_nodes before increasing effort.
-action=compare: Returns a metrics table (QE, TE, explained variance, silhouette) for 2+ jobs. The table only shows hyperparameter columns that actually differ across the compared runs (preset, backend, batch_size, normalize, periodic, n_features, etc.) so multi-run sweeps stay readable. Tip: pass label="sweep_a" / "sweep_b" on train_map to make rows self-explanatory.
+action=compare: metrics table (QE, TE, explained variance, silhouette) for 2+ COMPLETED TRAINING jobs — pick the best run in a sweep. NOT inference(action=compare) (single trained job + second dataset → density-diff heatmap). Only hyperparameter columns that differ across runs are shown; pass label="…" at train time for readable rows.
 action=cancel: Not instant — worker checks between phases. Expect up to 30s delay.
 action=delete: WARNING — job ID will no longer work with results or any other tool.`;
-export async function fetchTrainingPresets() {
-    const configData = (await apiCall("GET", "/v1/training/config"));
-    return configData?.presets || {};
-}
 /**
  * Render the jobs(compare) markdown table. Strategy: always show job_id (or label
  * if present) + the four core metrics (QE, TE, Expl.Var, Silhouette); add any
@@ -142,435 +117,81 @@ export function renderCompareTable(comparisons) {
     }
     if (varying.length === 0 && ok.length >= 2) {
         lines.push("");
-        lines.push("(All hyperparameters identical across compared jobs — only metrics shown. Pass label=\"…\" on train_map for readable run names.)");
+        lines.push("(All hyperparameters identical across compared jobs — only metrics shown. Pass label=\"…\" at train time for readable run names.)");
     }
     else if (!anyLabel && ok.length >= 2) {
         lines.push("");
-        lines.push("Tip: pass label=\"sweep_xyz\" on train_map / train_siom_map / train_floop_siom to make compare rows readable.");
+        lines.push("Tip: pass label=\"sweep_xyz\" on train(action=map | siom_map | floop_siom) to make compare rows readable.");
     }
     return lines.join("\n");
 }
-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 p = preset ? presets[preset] : undefined;
-    const params = {
-        model: model ?? "SOM",
-        periodic: periodic ?? true,
-        normalize: normalize ?? "auto",
-    };
-    if (grid_x !== undefined && grid_y !== undefined)
-        params.grid = [grid_x, grid_y];
-    else if (p)
-        params.grid = p.grid;
-    if (epochs !== undefined)
-        params.epochs = epochs;
-    else if (p)
-        params.epochs = p.epochs;
-    if (cyclic_features?.length)
-        params.cyclic_features = cyclic_features;
-    if (columns?.length)
-        params.columns = columns;
-    if (auto_log_transforms)
-        params.auto_log_transforms = auto_log_transforms;
-    if (time_delay_embeddings?.length)
-        params.time_delay_embeddings = time_delay_embeddings;
-    if (categorical_features?.length)
-        params.categorical_features = categorical_features;
-    if (transforms && Object.keys(transforms).length > 0)
-        params.transforms = transforms;
-    if (temporal_features?.length)
-        params.temporal_features = temporal_features;
-    if (feature_weights && Object.keys(feature_weights).length > 0)
-        params.feature_weights = feature_weights;
-    if (sigma_f !== undefined)
-        params.sigma_f = sigma_f;
-    if (learning_rate !== undefined)
-        params.learning_rate = learning_rate;
-    if (batch_size !== undefined)
-        params.batch_size = batch_size;
-    else if (p)
-        params.batch_size = p.batch_size;
-    if (quality_metrics !== undefined)
-        params.quality_metrics = quality_metrics;
-    if (backend !== undefined && backend !== "auto")
-        params.backend = backend;
-    else if (p?.backend)
-        params.backend = p.backend;
-    params.output_format = output_format ?? "png";
-    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 (row_range && row_range.length >= 2 && row_range[0] <= row_range[1])
-        params.row_range = row_range;
-    if (siom_feature_geometry !== undefined)
-        params.siom_feature_geometry = siom_feature_geometry;
-    if (siom_qe_backend !== undefined)
-        params.siom_qe_backend = siom_qe_backend;
-    if (siom_qe_batch_size !== undefined)
-        params.siom_qe_batch_size = siom_qe_batch_size;
-    const effectiveGrid = params.grid;
-    const effectiveEpochs = params.epochs;
-    const effectiveBatch = params.batch_size;
-    const effectiveBackend = params.backend;
-    const paramSummary = [
-        effectiveGrid ? `grid=${effectiveGrid[0]}×${effectiveGrid[1]}` : "grid=auto",
-        effectiveEpochs ? `epochs=${Array.isArray(effectiveEpochs) ? effectiveEpochs.join("+") : effectiveEpochs}` : "epochs=auto",
-        effectiveBatch ? `batch=${effectiveBatch}` : "batch=auto",
-        `model=${params.model}`,
-        effectiveBackend ? `backend=${effectiveBackend}` : "",
-        preset ? `(from preset: ${preset})` : "",
-    ].filter(Boolean).join(", ");
-    return { params, paramSummary, effectiveGrid };
-}
+/** Deprecated jobs(train_*) / run_baseline_study actions -> the train tool's concise actions. */
+const TRAIN_ALIAS = {
+    train_map: "map",
+    train_siom_map: "siom_map",
+    train_impute: "impute",
+    train_floop_siom: "floop_siom",
+    run_baseline_study: "baseline_study",
+};
 export function registerJobsTool(server, description) {
     registerAuditedTool(server, "jobs", description, {
         action: z
-            .enum(["status", "list", "compare", "cancel", "delete", "train_map", "train_impute", "train_siom_map", "train_floop_siom", "train_floop_chain", "batch_predict", "run_baseline_study"])
-            .describe("status: check progress; list: see all jobs; compare: metrics table; cancel: stop job; delete: remove job + files; train_map: submit standard map training; train_siom_map: submit SIOM map training; train_floop_siom: submit FLooP-SIOM (preferred); train_floop_chain: deprecated alias for train_floop_siom; batch_predict: submit multiple predict jobs at once; run_baseline_study: auto-configure and train a baseline SOM"),
+            .enum([
+            "status", "list", "compare", "cancel", "delete",
+            // Deprecated forwarders (kept for one release; use train / inference).
+            "train_map", "train_siom_map", "train_impute", "train_floop_siom", "run_baseline_study", "batch_predict",
+        ])
+            .describe("status: check progress; list: see all jobs; compare: metrics table; cancel: stop job; delete: remove job + files. DEPRECATED forwarders: train_map/train_siom_map/train_impute/train_floop_siom/run_baseline_study (use the train tool); batch_predict (use inference)."),
         job_id: z
             .string()
             .optional()
-            .describe("Job ID — required for action=status, cancel, delete, batch_predict (parent training job)"),
-        inputs: z
-            .array(z.object({
-            dataset_id: z.string().optional(),
-            rows: z.array(z.record(z.string(), z.number())).optional(),
-        }))
-            .optional()
-            .describe("action=batch_predict: array of inputs; each item has dataset_id and/or rows (same as inference predict)."),
+            .describe("Job ID — required for action=status, cancel, delete, and the deprecated batch_predict (parent training job)."),
         job_ids: z
             .array(z.string())
             .optional()
-            .describe("Array of job IDs — required for action=compare (minimum 2)"),
+            .describe("Array of job IDs — required for action=compare (minimum 2)."),
         dataset_id: z
             .string()
             .optional()
-            .describe("Required for action=train_map. For action=list, filter jobs by this dataset ID."),
+            .describe("action=list: filter jobs by this dataset ID. Also required by the deprecated train_* forwarders."),
         label: z
             .string()
             .max(120)
             .optional()
-            .describe("Optional run label (≤120 chars) for train_map / train_siom_map / train_floop_siom — appears in jobs(list) and the jobs(compare) table; sanitized server-side. Useful for sweeps (e.g. label=\"sweep_periodic_true\")."),
-        preset: z.enum(["quick", "standard", "refined", "high_res"]).optional(),
-        grid_x: z.number().int().optional()
-            .describe("Grid width. Omit grid_x AND grid_y (and preset) to auto-size the map (~5·√√n per side); the result reports hit_stats.active_node_fraction and a grid_suggestion when too many nodes are dead."),
-        grid_y: z.number().int().optional().describe("Grid height. See grid_x for auto-sizing."),
-        epochs: z.preprocess((v) => {
-            if (v === undefined || v === null)
-                return v;
-            if (typeof v === "string") {
-                const n = parseInt(v, 10);
-                if (!Number.isNaN(n))
-                    return n;
-                const m = v.match(/^\[\s*(\d+)\s*,\s*(\d+)\s*\]$/);
-                if (m)
-                    return [parseInt(m[1], 10), parseInt(m[2], 10)];
-            }
-            return v;
-        }, z.union([z.number().int(), z.array(z.number().int()).length(2)]).optional()),
-        model: z.enum(["auto", "SOM", "SIOM", "RSOM", "SOM-SOFT", "RSOM-SOFT"]).optional(),
-        periodic: z.boolean().optional().default(true),
-        columns: z.array(z.string()).optional(),
-        cyclic_features: z.array(z.object({
-            feature: z.string(),
-            period: z.number(),
-        })).optional(),
-        temporal_features: z.array(z.object({
-            columns: z.array(z.string()),
-            format: z.string(),
-            extract: z.array(z.enum(["hour_of_day", "day_of_year", "month", "day_of_week", "minute_of_hour"])),
-            cyclic: z.boolean().default(true),
-            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(),
-        auto_log_transforms: z.boolean().optional().default(false),
-        time_delay_embeddings: z.array(z.object({
-            feature: z.string(),
-            lags: z.array(z.number().int().min(1))
-        })).optional(),
-        categorical_features: z.array(z.object({
-            feature: z.string(),
-            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"),
-        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()]),
-                convergence: z.tuple([z.number(), z.number()]),
-            })]).optional()),
-        batch_size: z.number().int().optional(),
-        quality_metrics: z.union([z.enum(["fast", "standard", "full"]), z.array(z.string())]).optional(),
-        backend: z.enum(["auto", "cpu", "gpu", "gpu_graphs"]).optional().default("auto"),
-        output_format: z.enum(["png", "pdf", "svg"]).optional().default("png"),
-        output_dpi: z.enum(["standard", "retina", "print"]).optional().default("retina"),
-        colormap: z.string().optional(),
-        row_range: z.tuple([z.number().int().min(1), z.number().int().min(1)]).optional(),
-        cv_folds: z.number().int().min(0).max(20).optional()
-            .describe("train_impute only: per-column imputation quality → quality.csv with two labeled methods (kfold_holdout_pool = held-out; resubstitution_optimistic = in-sample). 0=off, default 5."),
-        viz_mode: z.enum(["full", "summary", "summary_plus_top"]).optional()
-            .describe("Visualization density; auto-capped when feature count > 40"),
-        viz_top_components: z.number().int().min(0).max(64).optional()
-            .describe("With viz_mode=summary_plus_top: upload top-N component maps by variance (default 8)"),
-        emit_cell_uncertainty: z.boolean().optional()
-            .describe("train_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(),
-        siom_feature_geometry: z.enum(["l2", "mixed", "auto"]).optional().describe("train_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("train_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("train_siom_map: batch size for GPU SIOM QE (default 256 on worker)"),
-        topology: z.enum(["free", "chain"]).optional().default("free"),
-        max_nodes: z.number().int().min(2).optional(),
-        effort: z.enum(["quick", "standard", "thorough"]).optional().default("standard"),
-        n_initial: z.number().int().min(2).optional(),
-        n_passes: z.number().int().min(1).optional(),
-        growth_interval: z.number().int().min(1).optional(),
-        neighborhood_size: z.number().int().min(1).optional(),
-        edge_max_age: z.number().int().min(1).optional(),
-        max_degree: z.number().int().min(0).optional(),
-        error_threshold: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
-        error_decay: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
-        ring_close_threshold: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
-        sigma_0: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
-        eta_0: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
-        eta_f: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
-        elastic_lambda: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
-        elastic_mu: z.preprocess((v) => (v !== undefined && v !== null && typeof v === "string") ? parseFloat(v) : v, z.number().optional()),
-        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()),
+            .describe("Optional run label for the deprecated train_* forwarders (≤120 chars; appears in jobs(list) and the jobs(compare) table)."),
+        inputs: z
+            .array(z.object({
+            dataset_id: z.string().optional(),
+            rows: z.array(z.record(z.string(), z.number())).optional(),
+        }))
+            .optional()
+            .describe("Deprecated batch_predict forwarder: array of inputs; each item has dataset_id and/or rows."),
+        // Deprecated: training parameters accepted only by the jobs(train_*) forwarders.
+        // Submit training via the `train` tool instead; these are removed in a later release.
+        ...TRAINING_INPUT_SCHEMA,
     }, async (args) => {
         const { action, job_id, job_ids, dataset_id } = args;
-        if (action === "run_baseline_study") {
-            if (!dataset_id)
-                throw new Error("jobs(run_baseline_study) requires dataset_id");
-            // Fetch dataset preview to get row count
-            const dsInfo = await apiCall("GET", `/v1/datasets/${dataset_id}/preview?n_rows=1`);
-            const nSamples = dsInfo.total_rows || 1000;
-            // Heuristic grid size: 5 * sqrt(N)
-            const totalNodes = Math.round(5 * Math.sqrt(nSamples));
-            const side = Math.max(5, Math.round(Math.sqrt(totalNodes)));
-            const params = {
-                model: "SOM",
-                periodic: false,
-                normalize: "mad", // robust normalization
-                grid: [side, side],
-                epochs: [10, 20],
-                batch_size: 32,
-                quality_metrics: "standard",
-                output_format: "png",
-                output_dpi: 2,
-                colormap: "coolwarm"
+        // ---- Deprecated forwarders -> train / inference ----
+        const mapped = TRAIN_ALIAS[action];
+        if (mapped) {
+            const result = await runTrain(mapped, args);
+            return {
+                content: [
+                    ...result.content,
+                    { type: "text", text: `Note: jobs(action=${action}) is deprecated; use train(action=${mapped}).` },
+                ],
             };
-            const data = (await apiCall("POST", "/v1/jobs", { dataset_id, params }));
-            const jid = String(data.id ?? "");
-            return { content: [{ type: "text", text: `Baseline study submitted. Job ID: ${jid}\nGrid size: ${side}x${side}\nNormalization: MAD\n\nPoll with jobs(action=status, job_id="${jid}") until complete, then retrieve with results(action=get, job_id="${jid}"). Optional: training_monitor(job_id="${jid}") for a visual panel—not required.` }] };
         }
-        if (action === "train_map" || action === "train_siom_map" || action === "train_impute") {
-            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, gamma, gamma_f, siom_decay, siom_penalty, penalty_alpha, reset_per_epoch, siom_feature_geometry, siom_qe_backend, siom_qe_batch_size, label, cv_folds, viz_mode, viz_top_components, emit_cell_uncertainty, } = args;
-            let PRESETS = {};
-            try {
-                PRESETS = await fetchTrainingPresets();
-            }
-            catch (e) {
-                if (e.httpStatus === 401 || e.httpStatus === 403)
-                    throw e;
-                if (preset && grid_x === undefined && epochs === undefined) {
-                    throw new Error("Could not fetch training config from server, and missing explicit grid/epochs.");
-                }
-            }
-            if (!dataset_id)
-                throw new Error(`jobs(${action}) requires dataset_id`);
-            const { params, paramSummary, effectiveGrid } = buildTrainMapParams({
-                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,
-            }, PRESETS);
-            if (action === "train_impute") {
-                params._job_type = "train_impute";
-                params.model = model ?? "auto";
-                params.cv_folds = cv_folds ?? 5;
-                if (viz_mode !== undefined)
-                    params.viz_mode = viz_mode;
-                if (viz_top_components !== undefined)
-                    params.viz_top_components = viz_top_components;
-                if (emit_cell_uncertainty !== undefined)
-                    params.emit_cell_uncertainty = emit_cell_uncertainty;
-                // Plain numeric path only — strip unsupported keys if caller passed them
-                delete params.cyclic_features;
-                delete params.temporal_features;
-                delete params.categorical_features;
-                delete params.transforms;
-                delete params.auto_log_transforms;
-                delete params.time_delay_embeddings;
-            }
-            if (action === "train_siom_map") {
-                params._job_type = "train_siom";
-                if (gamma !== undefined)
-                    params.gamma = gamma;
-                if (gamma_f !== undefined)
-                    params.gamma_f = gamma_f;
-                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 (reset_per_epoch !== undefined)
-                    params.reset_per_epoch = reset_per_epoch;
-                if (siom_feature_geometry !== undefined)
-                    params.siom_feature_geometry = siom_feature_geometry;
-                if (siom_qe_backend !== undefined)
-                    params.siom_qe_backend = siom_qe_backend;
-                if (siom_qe_batch_size !== undefined)
-                    params.siom_qe_batch_size = siom_qe_batch_size;
-            }
-            let totalRows = 0;
-            try {
-                const preview = (await apiCall("GET", `/v1/datasets/${dataset_id}/preview?n_rows=1`));
-                totalRows = Number(preview?.total_rows ?? 0);
-            }
-            catch { /* ignore */ }
-            const submitBody = { dataset_id, params };
-            if (label && label.trim() !== "")
-                submitBody.label = label;
-            const data = (await apiCall("POST", "/v1/jobs", submitBody));
-            const newJobId = data.id;
-            const variantPrefix = action === "train_siom_map" ? "variant=siom"
-                : action === "train_impute" ? "variant=train_impute"
-                    : "variant=som";
-            data.effective_params = `${variantPrefix}, ${paramSummary}`;
-            try {
-                const sys = (await apiCall("GET", "/v1/system/info"));
-                const pending = Number(sys.status?.pending_jobs ?? sys.pending_jobs ?? 0);
-                const totalEta = Number(sys.training_time_estimates_seconds?.total ??
-                    (sys.gpu_available ? 45 : 120));
-                const waitMinutes = Math.round((pending * totalEta) / 60);
-                let msg = `Job submitted (${variantPrefix}, ${paramSummary}). `;
-                if (waitMinutes > 1)
-                    msg += `You are #${pending + 1} in queue. Estimated wait: ~${waitMinutes} min. `;
-                msg += `Poll with jobs(action=status, job_id="${newJobId}"). When status is completed, use results(action=get, job_id="${newJobId}") to view the map${action === "train_impute" ? " and imputed.csv" : ""} and metrics.`;
-                msg += ` Optional: training_monitor(job_id="${newJobId}") for charts—not required.`;
-                if (effectiveGrid && totalRows > 0 && effectiveGrid[0] * effectiveGrid[1] > totalRows * 0.75) {
-                    msg += ` Note: Grid may be large for ${totalRows} rows (consider grid=auto for fewer dead nodes).`;
-                }
-                data.message = msg;
-            }
-            catch {
-                let msg = `Job submitted (${variantPrefix}, ${paramSummary}). Poll with jobs(action=status, job_id="${newJobId}"). When status is completed, use results(action=get, job_id="${newJobId}") to view the map${action === "train_impute" ? " and imputed.csv" : ""} and metrics.`;
-                msg += ` Optional: training_monitor(job_id="${newJobId}") for charts—not required.`;
-                if (effectiveGrid && totalRows > 0 && effectiveGrid[0] * effectiveGrid[1] > totalRows * 0.75) {
-                    msg += ` Note: Grid may be large for ${totalRows} rows (consider grid=auto for fewer dead nodes).`;
-                }
-                data.message = msg;
-            }
-            return textResult(data);
-        }
-        if (action === "train_floop_siom" || action === "train_floop_chain") {
-            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, label, } = args;
-            if (!dataset_id)
-                throw new Error("jobs(train_floop_siom) requires dataset_id");
-            const params = {
-                _job_type: "train_floop_siom",
-                topology,
-                effort,
-                normalize,
-                output_format: output_format ?? "png",
+        if (action === "batch_predict") {
+            const result = await runBatchPredict({ job_id, inputs: args.inputs });
+            return {
+                content: [
+                    ...result.content,
+                    { type: "text", text: "Note: jobs(action=batch_predict) is deprecated; use inference(action=batch_predict)." },
+                ],
             };
-            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 submitBody = { dataset_id, params };
-            if (label && label.trim() !== "")
-                submitBody.label = label;
-            const data = (await apiCall("POST", "/v1/jobs", submitBody));
-            const newJobId = data.id;
-            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"}`,
-                gamma !== undefined ? `gamma=${gamma}` : "",
-            ].filter(Boolean).join(", ");
-            data.effective_params = paramSummary;
-            data.message =
-                `Job submitted (${paramSummary}). Poll with jobs(action=status, job_id="${newJobId}"). ` +
-                    `When status is completed, use results(action=get, job_id="${newJobId}") to view FLooP-SIOM figures and metrics. ` +
-                    `Optional: training_monitor(job_id="${newJobId}") for charts—not required.` +
-                    (action === "train_floop_chain"
-                        ? " Note: action=train_floop_chain is deprecated; prefer train_floop_siom."
-                        : "");
-            return textResult(data);
         }
+        // ---- Lifecycle ----
         if (action === "status") {
             if (!job_id)
                 throw new Error("jobs(status) requires job_id");
@@ -626,22 +247,6 @@ export function registerJobsTool(server, description) {
             const data = await apiCall("DELETE", `/v1/jobs/${job_id}`);
             return textResult(data);
         }
-        if (action === "batch_predict") {
-            if (!job_id)
-                throw new Error("jobs(batch_predict) requires job_id (parent training job)");
-            if (!args.inputs || !Array.isArray(args.inputs) || args.inputs.length === 0) {
-                throw new Error("jobs(batch_predict) requires inputs (non-empty array of { dataset_id? or rows? })");
-            }
-            const body = { inputs: args.inputs };
-            const data = (await apiCall("POST", `/v1/results/${job_id}/batch_predict`, body));
-            const ids = (data.ids ?? []);
-            return {
-                content: [{
-                        type: "text",
-                        text: `Batch predict: ${ids.length} job(s) submitted. Parent: ${job_id}. Poll each with jobs(action=status, job_id="<id>"). IDs: ${ids.join(", ")}`,
-                    }],
-            };
-        }
         throw new Error("Invalid action");
     });
 }

package/dist/tools/results.js

@@ -307,7 +307,7 @@ NOT FOR: Jobs that haven't completed. Use jobs(action=status) to check first.`,
                     if (idxs)
                         lines.push(`Selected indices: [${idxs.join(", ")}]`);
                 }
-                lines.push(`The new columns are appended to the source dataset and ready to use in jobs(action=train_map, columns=[..., "${outCols[0] ?? "feat_1"}", …]).`);
+                lines.push(`The new columns are appended to the source dataset and ready to use in train(action=map, columns=[..., "${outCols[0] ?? "feat_1"}", …]).`);
                 content.push({ type: "text", text: lines.join("\n") });
             }
             else if (jobType === "train_floop_siom") {