@fastino-ai/pioneer-cli 0.2.9 → 0.2.10

package/src/index.tsx

@@ -5,7 +5,7 @@
  */
 
 import React, { useState, useEffect, useRef } from "react";
-import { render, Box, Text, useApp, useInput, useStdin, Static } from "ink";
+import { render, Box, Text, useApp, useInput, useStdin, useStdout, Static } from "ink";
 import Spinner from "ink-spinner";
 import TextInput from "ink-text-input";
 import * as fs from "fs";
@@ -167,6 +167,8 @@ const BOOLEAN_FLAGS = new Set([
   "format-results",
   "reasoning-trace",
   "use-meta-felix",
+  "json",
+  "all",
 ]);
 
 function parseArgs(argv: string[]): {
@@ -2091,7 +2093,7 @@ function ModelCreateInteractive({
       ) : (
         <Box flexDirection="column">
           {topMatches.map((model, index) => {
-            const suffix = [model.label, model.task_type, model.type].filter(Boolean).join(" · ");
+            const suffix = [model.label, model.task_type].filter(Boolean).join(" · ");
             const modelLine = `${model.id}${suffix ? ` (${suffix})` : ""}`;
             const isHighlighted = index === highlightIndex;
             return (
@@ -2111,6 +2113,1210 @@ function ModelCreateInteractive({
   );
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Job ID Resolver
+// ─────────────────────────────────────────────────────────────────────────────
+
+function WithResolvedJobId({
+  rawId,
+  render,
+}: {
+  rawId: string;
+  render: (jobId: string) => React.ReactElement;
+}) {
+  const initiallyResolved = isUuid(rawId);
+  const [state, setState] = useState<"resolving" | "resolved" | "error">(
+    initiallyResolved ? "resolved" : "resolving"
+  );
+  const [resolvedId, setResolvedId] = useState(initiallyResolved ? rawId : "");
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    if (initiallyResolved) {
+      return;
+    }
+    let isActive = true;
+    (async () => {
+      const result = await api.listJobs();
+      if (!isActive) return;
+      if (!result.ok) {
+        setError(result.error ?? "Failed to look up training jobs.");
+        setState("error");
+        return;
+      }
+      const jobs = result.data?.training_jobs ?? [];
+      const norm = rawId.toLowerCase();
+      const matches = jobs.filter((job) =>
+        typeof job.id === "string" && job.id.toLowerCase().startsWith(norm)
+      );
+      if (matches.length === 0) {
+        setError(
+          `No training job matches "${rawId}". Run \`pioneer job list\` to see available IDs.`
+        );
+        setState("error");
+        return;
+      }
+      if (matches.length > 1) {
+        const preview = matches
+          .slice(0, 5)
+          .map((j) => `${j.id} (${j.model_name ?? "—"})`)
+          .join(", ");
+        setError(
+          `Ambiguous job id "${rawId}". Matches: ${preview}${matches.length > 5 ? "…" : ""}. Use a longer prefix or the full UUID.`
+        );
+        setState("error");
+        return;
+      }
+      setResolvedId(matches[0]!.id!);
+      setState("resolved");
+    })();
+
+    return () => {
+      isActive = false;
+    };
+  }, [rawId, initiallyResolved]);
+
+  if (state === "resolving") {
+    return <Loading message={`Resolving job id ${rawId}...`} />;
+  }
+  if (state === "error") {
+    return <ErrorMessage error={error} />;
+  }
+  return render(resolvedId);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Job List Command (tabular output)
+// ─────────────────────────────────────────────────────────────────────────────
+
+function shortJobId(id?: string): string {
+  if (!id) return "—";
+  return id.length > 8 ? id.slice(0, 8) : id;
+}
+
+function shortBaseModel(baseModel?: string): string {
+  if (!baseModel) return "—";
+  const parts = baseModel.split("/");
+  return parts[parts.length - 1] || baseModel;
+}
+
+function relativeTime(iso?: string): string {
+  if (!iso) return "—";
+  const ts = Date.parse(iso);
+  if (Number.isNaN(ts)) return iso;
+  const diffMs = Date.now() - ts;
+  const seconds = Math.round(diffMs / 1000);
+  if (seconds < 60) return `${Math.max(seconds, 0)}s ago`;
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.round(hours / 24);
+  if (days < 30) return `${days}d ago`;
+  const months = Math.round(days / 30);
+  if (months < 12) return `${months}mo ago`;
+  const years = Math.round(days / 365);
+  return `${years}y ago`;
+}
+
+function statusColor(status?: string): string | undefined {
+  const normalized = (status ?? "").toLowerCase();
+  if (normalized === "complete" || normalized === "completed" || normalized === "succeeded") {
+    return "green";
+  }
+  if (normalized === "failed" || normalized === "error" || normalized === "cancelled" || normalized === "canceled") {
+    return "red";
+  }
+  if (normalized === "running" || normalized === "training" || normalized === "in_progress") {
+    return "cyan";
+  }
+  if (normalized === "pending" || normalized === "queued" || normalized === "starting") {
+    return "yellow";
+  }
+  return undefined;
+}
+
+function padCell(value: string, width: number): string {
+  if (value.length === width) return value;
+  if (value.length > width) {
+    if (width <= 1) return value.slice(0, width);
+    return `${value.slice(0, Math.max(width - 1, 1))}…`;
+  }
+  return value + " ".repeat(width - value.length);
+}
+
+interface JobRow {
+  id: string;
+  model: string;
+  baseModel: string;
+  task: string;
+  status: string;
+  created: string;
+  [key: string]: string;
+}
+
+function jobsToRows(jobs: api.TrainingJob[]): JobRow[] {
+  return jobs.map((job) => ({
+    id: shortJobId(job.id),
+    model: job.model_name?.trim() || "—",
+    baseModel: shortBaseModel(job.base_model),
+    task: job.task_type?.trim() || "—",
+    status: job.status?.trim() || "—",
+    created: relativeTime(job.created_at),
+  }));
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Reusable Table + DetailView primitives
+// Used by: job list/get, dataset list/get, model base-models, model endpoints get,
+//          model endpoints quality-metrics, model artifacts download.
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface TableColumn<TRow> {
+  key: keyof TRow & string;
+  header: string;
+  minWidth: number;
+  maxWidth: number;
+  flexible?: boolean;
+  color?: (row: TRow) => string | undefined;
+}
+
+function computeTableWidths<TRow extends Record<string, string>>(
+  columns: TableColumn<TRow>[],
+  rows: TRow[],
+  terminalWidth: number
+): number[] {
+  const desired = columns.map((column) => {
+    const headerLength = column.header.length;
+    const dataLength = rows.reduce(
+      (max, row) => Math.max(max, ((row[column.key] as string | undefined) ?? "").length),
+      0
+    );
+    const want = Math.max(headerLength, dataLength);
+    return Math.max(column.minWidth, Math.min(column.maxWidth, want));
+  });
+
+  const separators = (columns.length - 1) * 2;
+  const available = Math.max(40, terminalWidth - 1);
+  const total = desired.reduce((sum, w) => sum + w, 0) + separators;
+
+  if (total <= available) return desired;
+
+  let overflow = total - available;
+  const flexIndices = columns
+    .map((column, idx) => (column.flexible ? idx : -1))
+    .filter((idx) => idx >= 0);
+
+  while (overflow > 0) {
+    let trimmedThisPass = false;
+    for (const idx of flexIndices) {
+      if (overflow <= 0) break;
+      if (desired[idx]! > columns[idx]!.minWidth) {
+        desired[idx] = desired[idx]! - 1;
+        overflow -= 1;
+        trimmedThisPass = true;
+      }
+    }
+    if (!trimmedThisPass) break;
+  }
+
+  return desired;
+}
+
+function useTerminalWidth(): number {
+  const { stdout } = useStdout();
+  const [width, setWidth] = useState(() => {
+    const cols = stdout?.columns;
+    if (typeof cols === "number" && cols > 0) return cols;
+    const env = parseInt(process.env.COLUMNS ?? "", 10);
+    return Number.isFinite(env) && env > 0 ? env : 80;
+  });
+  useEffect(() => {
+    if (!stdout) return;
+    const handler = () => {
+      if (typeof stdout.columns === "number" && stdout.columns > 0) {
+        setWidth(stdout.columns);
+      }
+    };
+    stdout.on("resize", handler);
+    return () => {
+      stdout.off("resize", handler);
+    };
+  }, [stdout]);
+  return width;
+}
+
+function DataTable<TRow extends Record<string, string>>({
+  columns,
+  rows,
+  footer,
+}: {
+  columns: TableColumn<TRow>[];
+  rows: TRow[];
+  footer?: string;
+}) {
+  const terminalWidth = useTerminalWidth();
+  const widths = computeTableWidths(columns, rows, terminalWidth);
+
+  const headerCells = columns.map((column, idx) =>
+    padCell(column.header, widths[idx]!)
+  );
+
+  return (
+    <Box flexDirection="column">
+      <Text bold dimColor>{headerCells.join("  ")}</Text>
+      {rows.map((row, rowIdx) => {
+        const cells = columns.map((column, idx) => {
+          const raw = (row[column.key] as string | undefined) ?? "";
+          return padCell(String(raw), widths[idx]!);
+        });
+        return (
+          <Text key={rowIdx}>
+            {columns.map((column, idx) => {
+              const cell = cells[idx]!;
+              const color = column.color?.(row);
+              return (
+                <React.Fragment key={String(column.key)}>
+                  {idx > 0 ? "  " : ""}
+                  {color ? <Text color={color}>{cell}</Text> : cell}
+                </React.Fragment>
+              );
+            })}
+          </Text>
+        );
+      })}
+      {footer ? (
+        <Box marginTop={1}>
+          <Text dimColor>{footer}</Text>
+        </Box>
+      ) : null}
+    </Box>
+  );
+}
+
+interface DetailRow {
+  label: string;
+  value: string;
+  valueColor?: string;
+}
+
+function DetailView({
+  rows,
+  footer,
+}: {
+  rows: DetailRow[];
+  footer?: string;
+}) {
+  if (rows.length === 0) {
+    return <Text dimColor>No data.</Text>;
+  }
+  // Render single-record details through the same DataTable primitive used for
+  // list views, so `<thing> get` and `<thing> list` share the exact same
+  // visual style (uppercase headers, column padding, ellipsizing).
+  const tableRows = rows.map((row) => ({
+    field: row.label.toUpperCase(),
+    value: row.value,
+    __valueColor: row.valueColor ?? "",
+  }));
+  const columns: TableColumn<(typeof tableRows)[number]>[] = [
+    { key: "field", header: "FIELD", minWidth: 6, maxWidth: 24 },
+    {
+      key: "value",
+      header: "VALUE",
+      minWidth: 10,
+      maxWidth: 80,
+      flexible: true,
+      color: (row) => row.__valueColor || undefined,
+    },
+  ];
+  return <DataTable columns={columns} rows={tableRows} footer={footer} />;
+}
+
+const JOB_COLUMNS: TableColumn<JobRow>[] = [
+  { key: "id", header: "ID", minWidth: 8, maxWidth: 8 },
+  { key: "model", header: "MODEL", minWidth: 8, maxWidth: 32, flexible: true },
+  { key: "baseModel", header: "BASE MODEL", minWidth: 10, maxWidth: 30, flexible: true },
+  { key: "task", header: "TASK", minWidth: 4, maxWidth: 14, flexible: true },
+  { key: "status", header: "STATUS", minWidth: 6, maxWidth: 10, color: (row) => statusColor(row.status) },
+  { key: "created", header: "CREATED", minWidth: 7, maxWidth: 10 },
+];
+
+export function JobListCommand() {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done" | "error">("loading");
+  const [jobs, setJobs] = useState<api.TrainingJob[]>([]);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    (async () => {
+      const result = await api.listJobs();
+      if (!result.ok) {
+        setError(result.error ?? "Failed to load training jobs.");
+        setState("error");
+      } else {
+        setJobs(result.data?.training_jobs ?? []);
+        setState("done");
+      }
+      setTimeout(() => exit(), 500);
+    })();
+  }, [exit]);
+
+  if (state === "loading") return <Loading message="Loading training jobs..." />;
+  if (state === "error") return <ErrorMessage error={error} />;
+  if (jobs.length === 0) {
+    return (
+      <Box flexDirection="column">
+        <Text>No training jobs found.</Text>
+        <Text dimColor>Create one with `pioneer agent` — it will guide you through picking a base model and datasets.</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <DataTable
+      columns={JOB_COLUMNS}
+      rows={jobsToRows(jobs)}
+      footer={`${jobs.length} job${jobs.length === 1 ? "" : "s"} · the short ID prefix above is enough for \`pioneer job get/logs/delete\` · use \`--json\` for raw JSON`}
+    />
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Job Get Command (single-job key/value layout)
+// ─────────────────────────────────────────────────────────────────────────────
+
+function formatTimestamp(iso?: string): string {
+  if (!iso) return "—";
+  const ts = Date.parse(iso);
+  if (Number.isNaN(ts)) return iso;
+  const date = new Date(ts);
+  const pad = (n: number) => n.toString().padStart(2, "0");
+  const yyyy = date.getUTCFullYear();
+  const mm = pad(date.getUTCMonth() + 1);
+  const dd = pad(date.getUTCDate());
+  const hh = pad(date.getUTCHours());
+  const mi = pad(date.getUTCMinutes());
+  const ss = pad(date.getUTCSeconds());
+  return `${yyyy}-${mm}-${dd} ${hh}:${mi}:${ss} UTC (${relativeTime(iso)})`;
+}
+
+function formatDuration(startIso?: string, endIso?: string): string {
+  if (!startIso || !endIso) return "—";
+  const start = Date.parse(startIso);
+  const end = Date.parse(endIso);
+  if (Number.isNaN(start) || Number.isNaN(end) || end < start) return "—";
+  const seconds = Math.floor((end - start) / 1000);
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const remSeconds = seconds % 60;
+  const parts: string[] = [];
+  if (days) parts.push(`${days}d`);
+  if (hours) parts.push(`${hours}h`);
+  if (minutes) parts.push(`${minutes}m`);
+  if (!parts.length || remSeconds) parts.push(`${remSeconds}s`);
+  return parts.join(" ");
+}
+
+function formatDatasetList(
+  datasets?: Array<{ name?: string; version?: string | number }>
+): string {
+  if (!datasets || datasets.length === 0) return "—";
+  return datasets
+    .map((ds) => {
+      const name = ds?.name ?? "(unnamed)";
+      const version = ds?.version != null && ds.version !== "" ? ` (v${ds.version})` : "";
+      return `${name}${version}`;
+    })
+    .join(", ");
+}
+
+function formatLabels(labels?: string[]): string {
+  if (!labels || labels.length === 0) return "—";
+  return labels.join(", ");
+}
+
+function formatBoolean(value: unknown): string {
+  if (value === true) return "yes";
+  if (value === false) return "no";
+  return "—";
+}
+
+function formatNumber(value: unknown): string {
+  if (typeof value !== "number" || Number.isNaN(value)) return "—";
+  return Number.isInteger(value) ? String(value) : value.toString();
+}
+
+function formatPercent(value: unknown): string {
+  if (typeof value !== "number" || Number.isNaN(value)) return "—";
+  const pct = value > 1 ? value : value * 100;
+  return `${Number.isInteger(pct) ? pct : pct.toFixed(1)}%`;
+}
+
+function formatNonEmpty(value: unknown): string {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : "—";
+  }
+  return "—";
+}
+
+function jobToDetailRows(job: api.TrainingJob): DetailRow[] {
+  const record = job as unknown as Record<string, unknown>;
+  const provider =
+    typeof record.provider_name === "string" ? record.provider_name : undefined;
+  const progressPercent = typeof record.progress_percent === "number" ? record.progress_percent : undefined;
+  const currentEpoch = typeof record.current_epoch === "number" ? record.current_epoch : undefined;
+
+  const rows: DetailRow[] = [
+    { label: "ID", value: formatNonEmpty(job.id) },
+    { label: "Model", value: formatNonEmpty(job.model_name) },
+    { label: "Base model", value: formatNonEmpty(job.base_model) },
+    { label: "Task", value: formatNonEmpty(job.task_type) },
+    { label: "Status", value: formatNonEmpty(job.status), valueColor: statusColor(job.status) },
+    { label: "Provider", value: formatNonEmpty(provider) },
+    { label: "Datasets", value: formatDatasetList(job.datasets) },
+    { label: "Labels", value: formatLabels(job.labels) },
+    { label: "Epochs", value: formatNumber(job.nr_epochs) },
+    { label: "Batch size", value: formatNumber(job.batch_size) },
+    { label: "Learning rate", value: formatNumber(job.learning_rate) },
+    { label: "Validation split", value: formatPercent(job.validation_data_percentage) },
+    { label: "Auto-selected", value: formatBoolean(job.model_auto_selected) },
+    { label: "Version", value: formatNonEmpty(job.version_number) },
+    { label: "Created", value: formatTimestamp(job.created_at) },
+    { label: "Started", value: formatTimestamp(job.started_at) },
+    { label: "Completed", value: formatTimestamp(job.completed_at) },
+    { label: "Duration", value: formatDuration(job.started_at, job.completed_at) },
+    { label: "Updated", value: formatTimestamp(job.updated_at) },
+  ];
+
+  if (progressPercent !== undefined) {
+    rows.splice(5, 0, {
+      label: "Progress",
+      value: `${progressPercent.toFixed(1)}%${currentEpoch != null ? ` (epoch ${currentEpoch})` : ""}`,
+    });
+  }
+  if (job.error_message) {
+    rows.push({
+      label: "Error",
+      value: job.error_message,
+      valueColor: "red",
+    });
+  }
+
+  return rows;
+}
+
+function JobGetCommand({ jobId }: { jobId: string }) {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done" | "error">("loading");
+  const [job, setJob] = useState<api.TrainingJob | null>(null);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    let isActive = true;
+    (async () => {
+      const result = await api.getJob(jobId);
+      if (!isActive) return;
+      if (!result.ok) {
+        setError(result.error ?? "Failed to load training job.");
+        setState("error");
+      } else {
+        setJob((result.data as api.TrainingJob | undefined) ?? null);
+        setState("done");
+      }
+      setTimeout(() => exit(), 500);
+    })();
+    return () => {
+      isActive = false;
+    };
+  }, [jobId, exit]);
+
+  if (state === "loading") {
+    return <Loading message={`Loading training job ${jobId}...`} />;
+  }
+  if (state === "error") {
+    return <ErrorMessage error={error} />;
+  }
+  if (!job) {
+    return <ErrorMessage error="Training job response was empty." />;
+  }
+
+  return (
+    <DetailView
+      rows={jobToDetailRows(job)}
+      footer={`Use \`pioneer job get ${jobId} --json\` for the raw JSON payload.`}
+    />
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Base Models List Command (tabular)
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface BaseModelRow {
+  id: string;
+  name: string;
+  type: string;
+  context: string;
+  inference: string;
+  training: string;
+  [key: string]: string;
+}
+
+const BASE_MODEL_COLUMNS: TableColumn<BaseModelRow>[] = [
+  { key: "id", header: "ID", minWidth: 12, maxWidth: 36, flexible: true },
+  { key: "name", header: "NAME", minWidth: 8, maxWidth: 30, flexible: true },
+  { key: "type", header: "TYPE", minWidth: 4, maxWidth: 8 },
+  { key: "context", header: "CONTEXT", minWidth: 7, maxWidth: 8 },
+  { key: "inference", header: "INFERENCE", minWidth: 9, maxWidth: 9, color: (row) => (row.inference === "yes" ? "green" : "red") },
+  { key: "training", header: "TRAINING", minWidth: 8, maxWidth: 8, color: (row) => (row.training === "yes" ? "green" : "red") },
+];
+
+function formatContextWindow(n?: number): string {
+  if (typeof n !== "number" || !Number.isFinite(n) || n <= 0) return "—";
+  if (n >= 1_000_000) {
+    const v = n / 1_000_000;
+    return `${Number.isInteger(v) ? v : v.toFixed(1)}M`;
+  }
+  if (n >= 1000) {
+    const v = n / 1000;
+    return `${Number.isInteger(v) ? v : v.toFixed(0)}K`;
+  }
+  return String(n);
+}
+
+function BaseModelsListCommand() {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done" | "error">("loading");
+  const [models, setModels] = useState<api.BaseModelInfo[]>([]);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    (async () => {
+      const result = await api.listBaseModels();
+      if (!result.ok) {
+        setError(result.error ?? "Failed to load base models.");
+        setState("error");
+      } else {
+        setModels(normalizeBaseModels(result.data));
+        setState("done");
+      }
+      setTimeout(() => exit(), 500);
+    })();
+  }, [exit]);
+
+  if (state === "loading") return <Loading message="Loading base models..." />;
+  if (state === "error") return <ErrorMessage error={error} />;
+  if (models.length === 0) {
+    return <Text>No base models available.</Text>;
+  }
+
+  const rows: BaseModelRow[] = models.map((m) => {
+    const inference = m.supports_inference ?? m.supports_on_demand_inference;
+    return {
+      id: m.id || "—",
+      name: (m.label || m.name || m.id || "—").trim() || "—",
+      type: m.task_type || "—",
+      context: formatContextWindow(m.context_window),
+      inference: inference === undefined ? "—" : inference ? "yes" : "no",
+      training: m.supports_training === undefined ? "—" : m.supports_training ? "yes" : "no",
+    };
+  });
+
+  return (
+    <DataTable
+      columns={BASE_MODEL_COLUMNS}
+      rows={rows}
+      footer={`${models.length} base model${models.length === 1 ? "" : "s"} · use \`--json\` for raw JSON`}
+    />
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Model Endpoint Get Command (single-resource key/value layout, with dataset count)
+// ─────────────────────────────────────────────────────────────────────────────
+
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function ModelEndpointGetCommand({ modelId }: { modelId: string }) {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done" | "error">("loading");
+  const [project, setProject] = useState<api.ProjectResponse | null>(null);
+  const [datasetCount, setDatasetCount] = useState<api.ProjectDatasetCountResponse | null>(null);
+  const [activeJob, setActiveJob] = useState<api.TrainingJob | null>(null);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    let active = true;
+    (async () => {
+      // Sequential to dodge Bun concurrent-fetch keep-alive flakiness.
+      const projectResult = await api.getProject(modelId);
+      if (!active) return;
+      if (!projectResult.ok) {
+        setError(projectResult.error ?? "Failed to load model endpoint.");
+        setState("error");
+        setTimeout(() => exit(), 500);
+        return;
+      }
+      setProject(projectResult.data ?? null);
+
+      const countResult = await api.getProjectDatasetCount(modelId);
+      if (!active) return;
+      if (countResult.ok) setDatasetCount(countResult.data ?? null);
+
+      // If the selected model id is a UUID, it's a training job (a deployed
+      // fine-tuned checkpoint). Hydrate it so we can show a friendly name
+      // instead of just the UUID.
+      const selected = projectResult.data?.selected_model_id ?? "";
+      if (UUID_REGEX.test(selected)) {
+        const jobResult = await api.getJob(selected);
+        if (!active) return;
+        if (jobResult.ok) setActiveJob(jobResult.data ?? null);
+      }
+
+      setState("done");
+      setTimeout(() => exit(), 500);
+    })();
+    return () => {
+      active = false;
+    };
+  }, [modelId, exit]);
+
+  if (state === "loading") return <Loading message={`Loading model endpoint ${modelId}...`} />;
+  if (state === "error") return <ErrorMessage error={error} />;
+  if (!project) return <ErrorMessage error="Model endpoint response was empty." />;
+
+  const selected = project.selected_model_id ?? "";
+  const selectedDisplay = (() => {
+    if (!selected) return "—";
+    if (activeJob) {
+      const parts: string[] = [];
+      if (activeJob.model_name) parts.push(activeJob.model_name);
+      if (activeJob.base_model) parts.push(`base: ${activeJob.base_model}`);
+      const tail = parts.length ? `  (${parts.join(", ")})` : "";
+      return `${shortJobId(selected)}${tail}`;
+    }
+    // Stock model id (or UUID we couldn't resolve) — render as-is.
+    return UUID_REGEX.test(selected) ? shortJobId(selected) : selected;
+  })();
+
+  const rows: DetailRow[] = [
+    { label: "ID", value: formatNonEmpty(project.id) },
+    { label: "Name", value: formatNonEmpty(project.name) },
+    { label: "Description", value: formatNonEmpty(project.description) },
+    { label: "Icon", value: formatNonEmpty(project.icon) },
+    { label: "Repo", value: formatNonEmpty(project.repo) },
+    { label: "Selected model", value: selectedDisplay },
+    { label: "Created", value: formatTimestamp(project.created_at) },
+    { label: "Updated", value: formatTimestamp(project.updated_at) },
+  ];
+  if (datasetCount) {
+    rows.push(
+      { label: "Datasets", value: formatNumber(datasetCount.dataset_count) },
+      {
+        label: "Can delete",
+        value: formatBoolean(datasetCount.can_delete),
+        valueColor: datasetCount.can_delete ? "green" : "yellow",
+      }
+    );
+  }
+
+  return (
+    <DetailView
+      rows={rows}
+      footer={`Use \`pioneer model endpoints get ${modelId} --json\` for the raw JSON payload.`}
+    />
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Model Endpoint Quality Metrics Command (compact key/value layout)
+// ─────────────────────────────────────────────────────────────────────────────
+
+function ModelQualityMetricsCommand({ modelId }: { modelId: string }) {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done" | "error">("loading");
+  const [data, setData] = useState<api.QualityMetricsResponse | null>(null);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    let active = true;
+    (async () => {
+      const result = await api.getProjectQualityMetrics(modelId);
+      if (!active) return;
+      if (!result.ok) {
+        setError(result.error ?? "Failed to load quality metrics.");
+        setState("error");
+      } else {
+        setData(result.data ?? null);
+        setState("done");
+      }
+      setTimeout(() => exit(), 500);
+    })();
+    return () => {
+      active = false;
+    };
+  }, [modelId, exit]);
+
+  if (state === "loading") return <Loading message={`Loading quality metrics for ${modelId}...`} />;
+  if (state === "error") return <ErrorMessage error={error} />;
+  if (!data) return <ErrorMessage error="Quality metrics response was empty." />;
+
+  const rows: DetailRow[] = [
+    { label: "Model ID", value: formatNonEmpty(data.project_id) },
+    { label: "Total judged", value: formatNumber(data.total_judged) },
+    { label: "Pass count", value: formatNumber(data.pass_count), valueColor: "green" },
+    { label: "Fail count", value: formatNumber(data.fail_count), valueColor: data.fail_count > 0 ? "red" : undefined },
+    { label: "Uncertain count", value: formatNumber(data.uncertain_count), valueColor: data.uncertain_count > 0 ? "yellow" : undefined },
+    { label: "Pass rate", value: formatPercent(data.pass_rate), valueColor: "green" },
+    { label: "Fail rate", value: formatPercent(data.fail_rate), valueColor: data.fail_rate > 0 ? "red" : undefined },
+  ];
+
+  return (
+    <DetailView
+      rows={rows}
+      footer={`Use \`pioneer model endpoints quality-metrics ${modelId} --json\` for the raw JSON payload.`}
+    />
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Deploy Job Picker (interactive picker for `model endpoints deploy` with no --job)
+// ─────────────────────────────────────────────────────────────────────────────
+
+function isJobDeployable(status?: string): boolean {
+  const s = (status ?? "").trim().toLowerCase();
+  return s === "complete" || s === "completed" || s === "succeeded" || s === "deployed";
+}
+
+/**
+ * Normalize a model identifier to a "family" key for matching.
+ * Strips the org/namespace prefix, lowercases, and drops common
+ * variant suffixes (-instruct, -chat, -base, -it, -hf) so that, e.g.,
+ *   "qwen/Qwen3-8B-Instruct"  →  "qwen3-8b"
+ *   "Qwen/Qwen3-8B"           →  "qwen3-8b"
+ *   "meta-llama/Llama-3.1-8B-Instruct" → "llama-3.1-8b"
+ * are treated as the same family.
+ */
+function modelFamilyKey(modelId?: string | null): string {
+  if (!modelId) return "";
+  const last = modelId.toLowerCase().split("/").pop() ?? "";
+  return last
+    .replace(/-instruct$/, "")
+    .replace(/-chat$/, "")
+    .replace(/-base$/, "")
+    .replace(/-it$/, "")
+    .replace(/-hf$/, "")
+    .trim();
+}
+
+function jobMatchesEndpoint(job: api.TrainingJob, selectedModelId?: string): boolean {
+  if (!selectedModelId) return true;
+  const want = modelFamilyKey(selectedModelId);
+  const have = modelFamilyKey(job.base_model);
+  if (!want || !have) return true;
+  return want === have || want.startsWith(have) || have.startsWith(want);
+}
+
+export function DeployJobPickerCommand({
+  modelId,
+  reason,
+  showAll,
+}: {
+  modelId: string;
+  reason?: string;
+  showAll?: boolean;
+}) {
+  const { exit } = useApp();
+  const { isRawModeSupported } = useStdin();
+  const [phase, setPhase] = useState<"loading" | "picking" | "deploying" | "done" | "error">("loading");
+  const [jobs, setJobs] = useState<api.TrainingJob[]>([]);
+  const [endpointModel, setEndpointModel] = useState<string | undefined>(undefined);
+  const [filterApplied, setFilterApplied] = useState<boolean>(false);
+  const [filterSource, setFilterSource] = useState<"project" | "family" | "none">("none");
+  const [error, setError] = useState("");
+  const [searchQuery, setSearchQuery] = useState("");
+  const [highlightIndex, setHighlightIndex] = useState(0);
+  const [selectedJobId, setSelectedJobId] = useState<string | null>(null);
+  const [deployResult, setDeployResult] = useState<unknown>(null);
+
+  useEffect(() => {
+    let active = true;
+    (async () => {
+      // Run sequentially to avoid Bun concurrent-fetch keep-alive flakiness
+      // ("socket connection was closed unexpectedly"). Retry once on transient
+      // network errors.
+      const isTransient = (err?: string) =>
+        !!err && /socket|ECONNRESET|fetch failed|network|EAI_AGAIN|timeout/i.test(err);
+
+      const fetchWithRetry = async <T,>(fn: () => Promise<api.ApiResult<T>>): Promise<api.ApiResult<T>> => {
+        let r = await fn();
+        if (!r.ok && (r.status === 0 || isTransient(r.error))) {
+          await new Promise((res) => setTimeout(res, 250));
+          r = await fn();
+        }
+        return r;
+      };
+
+      const sortByRecent = (list: api.TrainingJob[]) =>
+        list.slice().sort((a, b) => {
+          const at = Date.parse(a.completed_at ?? a.updated_at ?? a.created_at ?? "");
+          const bt = Date.parse(b.completed_at ?? b.updated_at ?? b.created_at ?? "");
+          if (Number.isNaN(at) || Number.isNaN(bt)) return 0;
+          return bt - at;
+        });
+
+      // 1. Resolve the endpoint. A hard 404/403 means the endpoint doesn't exist
+      //    on this backend — fail fast rather than open a picker for a target
+      //    that any subsequent deploy call will reject. Other errors (5xx,
+      //    transient network) degrade gracefully: we just can't apply the
+      //    family filter.
+      const projectResult = await fetchWithRetry(() => api.getProject(modelId));
+      if (!active) return;
+      if (!projectResult.ok && (projectResult.status === 404 || projectResult.status === 403)) {
+        const reason =
+          projectResult.status === 403
+            ? "You do not have access to this endpoint."
+            : "This endpoint does not exist on the current backend.";
+        setError(
+          `${reason} (model id: ${modelId})\nList valid endpoints with:  pioneer model endpoints list`
+        );
+        setPhase("error");
+        setTimeout(() => exit(), 500);
+        return;
+      }
+      const selected = projectResult.ok ? projectResult.data?.selected_model_id : undefined;
+      setEndpointModel(selected ?? undefined);
+
+      // 2. Try server-side filter by project_id. Today most jobs have project_id=null
+      //    so this often returns []; we fall back to all-jobs + family match below.
+      let list: api.TrainingJob[] = [];
+      let didFilter = false;
+      let filterSource: "project" | "family" | "none" = "none";
+
+      if (!showAll) {
+        const scoped = await fetchWithRetry(() => api.listJobs({ project_id: modelId }));
+        if (!active) return;
+        if (scoped.ok) {
+          const scopedDeployable = sortByRecent(
+            (scoped.data?.training_jobs ?? []).filter((j) => isJobDeployable(j.status))
+          );
+          if (scopedDeployable.length > 0) {
+            list = scopedDeployable;
+            didFilter = true;
+            filterSource = "project";
+          }
+        }
+      }
+
+      // 3. Fall back to all jobs (and optionally family-match against the endpoint).
+      if (list.length === 0) {
+        const allResult = await fetchWithRetry(() => api.listJobs());
+        if (!active) return;
+        if (!allResult.ok) {
+          setError(allResult.error ?? "Failed to load training jobs.");
+          setPhase("error");
+          setTimeout(() => exit(), 500);
+          return;
+        }
+        const allDeployable = sortByRecent(
+          (allResult.data?.training_jobs ?? []).filter((j) => isJobDeployable(j.status))
+        );
+
+        if (!showAll && selected) {
+          const familyMatched = allDeployable.filter((j) => jobMatchesEndpoint(j, selected));
+          if (familyMatched.length > 0) {
+            list = familyMatched;
+            didFilter = true;
+            filterSource = "family";
+          } else {
+            list = allDeployable;
+          }
+        } else {
+          list = allDeployable;
+        }
+      }
+
+      setFilterApplied(didFilter);
+      setFilterSource(filterSource);
+      setJobs(list);
+      setPhase("picking");
+    })();
+    return () => {
+      active = false;
+    };
+  }, [exit, modelId, showAll]);
+
+  const matching = jobs.filter((job) => {
+    const q = searchQuery.trim().toLowerCase();
+    if (!q) return true;
+    return (
+      (job.id ?? "").toLowerCase().includes(q) ||
+      (job.model_name ?? "").toLowerCase().includes(q) ||
+      (job.base_model ?? "").toLowerCase().includes(q)
+    );
+  });
+
+  const deploy = async (jobId: string) => {
+    setSelectedJobId(jobId);
+    setPhase("deploying");
+
+    // The deploy endpoint requires `training_jobs.project_id == project_id`
+    // (server-side WHERE clause). Most jobs are created with project_id=null,
+    // so we PATCH first to link the job to the target project. The PATCH is
+    // a no-op if the job is already linked.
+    const job = jobs.find((j) => j.id === jobId);
+    if (!job || job.project_id !== modelId) {
+      const patch = await api.updateTrainingJob(jobId, { project_id: modelId });
+      if (!patch.ok) {
+        const detail =
+          patch.status === 403
+            ? "You do not have permission to assign this job to this project."
+            : patch.error ?? "Failed to link job to project.";
+        setError(`Could not assign job to project before deploy: ${detail}`);
+        setPhase("error");
+        setTimeout(() => exit(), 1500);
+        return;
+      }
+    }
+
+    const result = await api.deployTrainingJobToProject(modelId, {
+      training_job_id: jobId,
+      ...(reason ? { reason } : {}),
+    });
+    if (!result.ok) {
+      let msg = result.error ?? "Deployment failed.";
+      if (result.status === 404) {
+        msg =
+          `Backend rejected the deploy with 404 "${result.error ?? "Resource not found."}".\n` +
+          `  • Project ${modelId} and training job ${jobId} both exist and are linked.\n` +
+          `  • Inspect job state:  pioneer job get ${jobId}`;
+      }
+      setError(msg);
+      setPhase("error");
+    } else {
+      // CLI-side enrichment: the deploy record's `base_model` is null for
+      // training-job deploys (mutually-exclusive with `training_job_id` in
+      // the current schema), but users want to see what base the fine-tune
+      // is built on. Populate it from the picked job until the backend
+      // change lands.
+      const enriched =
+        result.data && typeof result.data === "object" && job?.base_model
+          ? { ...result.data, base_model: (result.data as { base_model?: string | null }).base_model ?? job.base_model }
+          : result.data;
+      setDeployResult(enriched);
+      setPhase("done");
+    }
+    setTimeout(() => exit(), 1500);
+  };
+
+  useInput(
+    (input, key) => {
+      if (phase !== "picking" || !matching.length) {
+        if (key.return && phase === "picking" && !matching.length) {
+          setError("No matching jobs.");
+        }
+        return;
+      }
+      if (key.upArrow) {
+        setHighlightIndex((idx) => (idx === 0 ? matching.length - 1 : idx - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setHighlightIndex((idx) => (idx === matching.length - 1 ? 0 : idx + 1));
+        return;
+      }
+      if (key.return) {
+        const selected = matching[highlightIndex];
+        if (selected?.id) {
+          void deploy(selected.id);
+        }
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setSearchQuery((q) => q.slice(0, -1));
+        setHighlightIndex(0);
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        setSearchQuery((q) => q + input);
+        setHighlightIndex(0);
+      }
+    },
+    { isActive: isRawModeSupported && phase === "picking" }
+  );
+
+  if (!isRawModeSupported) {
+    return (
+      <Box flexDirection="column">
+        <ErrorMessage error="Interactive job picker requires a TTY." />
+        <Text>List trained jobs with `pioneer job list` and pass an explicit ID:</Text>
+        <Text dimColor>  pioneer model endpoints deploy {modelId} --job &lt;training-job-id&gt;</Text>
+      </Box>
+    );
+  }
+
+  if (phase === "loading") return <Loading message="Loading deployable training jobs..." />;
+  if (phase === "error") return <ErrorMessage error={error} />;
+
+  if (phase === "deploying") {
+    return <Loading message={`Deploying job ${selectedJobId} to endpoint ${modelId}...`} />;
+  }
+
+  if (phase === "done") {
+    return (
+      <Box flexDirection="column">
+        <Success message={`Deployment initiated for endpoint ${modelId} from job ${selectedJobId}`} />
+        {deployResult ? (
+          <Text dimColor>{JSON.stringify(deployResult, null, 2)}</Text>
+        ) : null}
+      </Box>
+    );
+  }
+
+  if (jobs.length === 0) {
+    return (
+      <Box flexDirection="column">
+        <ErrorMessage error="No deployable training jobs found." />
+        <Text dimColor>Only jobs with status `complete` / `succeeded` / `deployed` are eligible.</Text>
+        <Text dimColor>Run `pioneer job list` to inspect job statuses, or start training with `pioneer agent`.</Text>
+      </Box>
+    );
+  }
+
+  const visible = matching.slice(0, 12);
+  const offsetIndex = Math.max(0, Math.min(highlightIndex - visible.length + 1, matching.length - visible.length));
+  const window = matching.slice(offsetIndex, offsetIndex + visible.length);
+
+  const navHint = "Type to filter · ↑/↓ navigate · Enter to deploy";
+  const headerLine = (() => {
+    const n = jobs.length;
+    const noun = `job${n === 1 ? "" : "s"}`;
+    if (showAll) {
+      const tail = endpointModel ? ` Endpoint base model: "${endpointModel}".` : "";
+      return `Showing all ${n} deployable ${noun} (--all).${tail} ${navHint}.`;
+    }
+    if (filterApplied && filterSource === "project") {
+      return `Showing ${n} ${noun} scoped to this endpoint via project_id. ${navHint} · pass --all to see every job.`;
+    }
+    if (filterApplied && filterSource === "family" && endpointModel) {
+      return `Showing ${n} ${noun} matching base model "${endpointModel}". ${navHint} · pass --all to disable family match.`;
+    }
+    if (endpointModel) {
+      return `No jobs scoped to this endpoint and none match base model "${endpointModel}". Showing all ${n} deployable ${noun} as fallback. ${navHint}.`;
+    }
+    return `Showing ${n} deployable ${noun}. ${navHint}.`;
+  })();
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>Pick a training job to deploy to endpoint <Text color="cyan">{modelId}</Text>:</Text>
+      <Text dimColor>{headerLine}</Text>
+      <Text> </Text>
+      {searchQuery ? (
+        <Text>
+          <Text dimColor>Filter: </Text>
+          <Text>{searchQuery}</Text>
+        </Text>
+      ) : null}
+      {window.length === 0 ? (
+        <Text color="yellow">No jobs match `{searchQuery}`.</Text>
+      ) : (
+        window.map((job, idx) => {
+          const realIndex = offsetIndex + idx;
+          const isHighlighted = realIndex === highlightIndex;
+          const idShort = shortJobId(job.id);
+          const modelName = job.model_name?.trim() || "—";
+          const baseModel = shortBaseModel(job.base_model);
+          const status = job.status ?? "—";
+          const completed = relativeTime(job.completed_at ?? job.updated_at ?? job.created_at);
+          return (
+            <Text key={job.id || realIndex} color={isHighlighted ? "cyan" : undefined} bold={isHighlighted}>
+              {isHighlighted ? "▶ " : "  "}
+              {padCell(idShort, 8)}  {padCell(modelName, 28)}  {padCell(baseModel, 22)}  <Text color={statusColor(status)}>{padCell(status, 10)}</Text>  {completed}
+            </Text>
+          );
+        })
+      )}
+      {error ? (
+        <Box marginTop={1}>
+          <Text color="red">{error}</Text>
+        </Box>
+      ) : null}
+    </Box>
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Model Artifact Download Command (key/value layout for a download URL response)
+// ─────────────────────────────────────────────────────────────────────────────
+
+function ModelArtifactDownloadCommand({ jobId }: { jobId: string }) {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done" | "error">("loading");
+  const [data, setData] = useState<Record<string, unknown> | null>(null);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    let active = true;
+    (async () => {
+      const result = await api.downloadModel(jobId);
+      if (!active) return;
+      if (!result.ok) {
+        setError(result.error ?? "Failed to fetch model artifact download URL.");
+        setState("error");
+      } else {
+        setData((result.data as Record<string, unknown> | undefined) ?? null);
+        setState("done");
+      }
+      setTimeout(() => exit(), 500);
+    })();
+    return () => {
+      active = false;
+    };
+  }, [jobId, exit]);
+
+  if (state === "loading") return <Loading message={`Fetching download URL for ${jobId}...`} />;
+  if (state === "error") return <ErrorMessage error={error} />;
+  if (!data) return <ErrorMessage error="Download response was empty." />;
+
+  const stringField = (key: string) => {
+    const v = data[key];
+    return typeof v === "string" && v.trim() ? v : undefined;
+  };
+  const numberField = (key: string) => {
+    const v = data[key];
+    return typeof v === "number" ? v : undefined;
+  };
+
+  const downloadUrl = stringField("download_url") || stringField("url");
+  const expiresAt = stringField("expires_at") || stringField("expiry");
+  const sizeBytes = numberField("size") ?? numberField("size_bytes");
+  const filename = stringField("filename") || stringField("file_name");
+  const contentType = stringField("content_type") || stringField("mime_type");
+
+  const rows: DetailRow[] = [
+    { label: "Job ID", value: jobId },
+    { label: "Filename", value: formatNonEmpty(filename) },
+    { label: "Content type", value: formatNonEmpty(contentType) },
+    { label: "Size", value: sizeBytes !== undefined ? `${sizeBytes.toLocaleString()} bytes` : "—" },
+    { label: "Expires", value: expiresAt ? formatTimestamp(expiresAt) : "—" },
+    { label: "Download URL", value: downloadUrl || "—", valueColor: downloadUrl ? "cyan" : undefined },
+  ];
+
+  return (
+    <DetailView
+      rows={rows}
+      footer={
+        downloadUrl
+          ? `Tip: pipe the URL into curl, e.g. \`curl -L -o artifact.zip "$URL"\` · use \`--json\` for raw JSON`
+          : `Use \`pioneer model artifacts download ${jobId} --json\` for the raw JSON payload.`
+      }
+    />
+  );
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Job Logs Command (prettified output)
 // ─────────────────────────────────────────────────────────────────────────────
@@ -2305,469 +3511,202 @@ function GenerateCommand<T extends GenerateResult>({
       {savedDatasetId && (
         <Text color="green">Saved to remote: {savedDatasetId}</Text>
       )}
-      {remoteSaveFailed && (
-        <Text color="yellow">⚠ Remote save failed (check server logs). Saved locally instead.</Text>
-      )}
-      {savedPath && (
-        <Text color="cyan">Saved to: {savedPath}</Text>
-      )}
-    </Box>
-  );
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Helper: Infer format from file extension
-// ─────────────────────────────────────────────────────────────────────────────
-
-function inferFormatFromPath(
-  path: string | undefined,
-  defaultFormat: string = "jsonl"
-): "csv" | "jsonl" | "parquet" {
-  if (!path) return defaultFormat as "csv" | "jsonl" | "parquet";
-
-  const ext = path.toLowerCase().split(".").pop();
-  if (ext === "csv" || ext === "jsonl" || ext === "parquet") {
-    return ext;
-  }
-  return defaultFormat as "csv" | "jsonl" | "parquet";
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Dataset List Command (shows both remote and local)
-// ─────────────────────────────────────────────────────────────────────────────
-
-function DatasetListCommand() {
-  const { exit } = useApp();
-  const [state, setState] = useState<"loading" | "done">("loading");
-  const [remoteData, setRemoteData] = useState<api.DatasetListResponse | null>(null);
-  const [remoteError, setRemoteError] = useState<string | null>(null);
-  const [localDatasets, setLocalDatasets] = useState<LocalDataset[]>([]);
-
-  useEffect(() => {
-    (async () => {
-      // Fetch remote and local datasets
-      const result = await api.listDatasets();
-      const local = listLocalDatasets();
-      setLocalDatasets(local);
-
-      if (result.ok) {
-        setRemoteData(result.data ?? null);
-      } else {
-        setRemoteError(result.error ?? "Unknown error");
-      }
-      setState("done");
-      setTimeout(() => exit(), 500);
-    })();
-  }, [exit]);
-
-  if (state === "loading") {
-    return <Loading />;
-  }
-
-  const remoteDatasets = remoteData?.datasets ?? [];
-
-  return (
-    <Box flexDirection="column">
-      <Text bold color="cyan">Remote Datasets {remoteError ? "" : `(${remoteDatasets.length})`}</Text>
-      {remoteError ? (
-        <Box flexDirection="column">
-          {remoteError.split("\n").map((line, idx) => (
-            <Text key={idx} color="red">  {line}</Text>
-          ))}
-        </Box>
-      ) : remoteDatasets.length === 0 ? (
-        <Text dimColor>  No remote datasets</Text>
-      ) : (
-        remoteDatasets.map((ds) => (
-          <Box key={ds.id} flexDirection="column">
-            <Text>
-              {"  "}<Text color="yellow">{ds.dataset_name}:{ds.version_number || "v1"}</Text> <Text dimColor>({ds.dataset_type}, {ds.sample_size} examples)</Text>
-            </Text>
-            <Text dimColor>    {ds.id}</Text>
-          </Box>
-        ))
-      )}
-      <Text> </Text>
-      <Text bold color="cyan">Local Datasets ({localDatasets.length})</Text>
-      {localDatasets.length === 0 ? (
-        <Text dimColor>  No local datasets in ./datasets/</Text>
-      ) : (
-        localDatasets.map((ds) => (
-          <Text key={ds.id}>
-            {"  "}<Text color="green">{ds.name}</Text> <Text dimColor>({ds.type}, {ds.sample_size} examples)</Text>
-          </Text>
-        ))
-      )}
-    </Box>
-  );
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Job Create Command (with auto-upload for local datasets)
-// ─────────────────────────────────────────────────────────────────────────────
-
-interface ParsedDataset {
-  type: "local" | "remote";
-  name?: string;      // for remote name:version format
-  version?: string;   // for remote name:version format
-  id?: string;        // for remote UUID format
-}
-
-interface JobCreateCommandProps {
-  modelName: string;
-  datasets: ParsedDataset[];
-  baseModel?: string;
-  epochs?: number;
-}
-
-interface DatasetUploadStatus {
-  name: string;
-  path: string;
-  status: "pending" | "uploading" | "done" | "error";
-  error?: string;
-  uploadedRef?: api.DatasetRef;
-}
-
-// UUID pattern: 8-4-4-4-12 hex characters
-const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
-function isUUID(str: string): boolean {
-  return UUID_PATTERN.test(str);
-}
-
-function parseDatasetString(ds: string): ParsedDataset | { error: string } {
-  const trimmed = ds.trim();
-
-  if (trimmed.startsWith("local:")) {
-    const name = trimmed.slice(6); // remove "local:"
-    if (!name) {
-      return { error: `Invalid local dataset format: ${ds}. Use local:<name>` };
-    }
-    return { type: "local", name };
-  }
-
-  if (trimmed.startsWith("remote:")) {
-    const rest = trimmed.slice(7); // remove "remote:"
-
-    // Check if it's a UUID
-    if (isUUID(rest)) {
-      return { type: "remote", id: rest };
-    }
-
-    // Otherwise parse as name:version
-    const colonIndex = rest.lastIndexOf(":");
-    if (colonIndex === -1) {
-      // No version, default to latest
-      return { type: "remote", name: rest, version: "latest" };
-    }
-    return {
-      type: "remote",
-      name: rest.slice(0, colonIndex),
-      version: rest.slice(colonIndex + 1),
-    };
-  }
-
-  return { error: `Invalid dataset format: ${ds}. Use remote:<name>:<version>, remote:<uuid>, or local:<name>` };
-}
-
-function resolveLocalDatasetPath(name: string): string | null {
-  // Check if it's a local dataset by name (in ./datasets/ directory)
-  const localPath = path.join(DATASETS_DIR, `${name}.json`);
-  if (fs.existsSync(localPath)) {
-    return localPath;
-  }
-  // Check if it's a direct file path
-  if (fs.existsSync(name) && (name.endsWith(".json") || name.endsWith(".jsonl"))) {
-    return name;
-  }
-  return null;
-}
-
-function getLocalDatasetType(filePath: string): "ner" | "classification" | "custom" {
-  try {
-    const content = fs.readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(content);
-    const data = Array.isArray(parsed) ? parsed : parsed.data ?? [];
-    if (parsed.task_type) {
-      return parsed.task_type as "ner" | "classification" | "custom";
-    }
-    const firstItem = data[0] as Record<string, unknown> | undefined;
-    if (firstItem?.spans) return "ner";
-    if (firstItem?.label) return "classification";
-    return "custom";
-  } catch {
-    return "custom";
-  }
-}
-
-function convertJsonToJsonl(filePath: string): string {
-  // Convert JSON array to JSONL format for upload
-  const content = fs.readFileSync(filePath, "utf-8");
-  const parsed = JSON.parse(content);
-  const data = Array.isArray(parsed) ? parsed : parsed.data ?? [];
-
-  // Create temp JSONL file
-  const tempPath = filePath.replace(".json", ".jsonl");
-  const jsonlContent = data.map((item: unknown) => JSON.stringify(item)).join("\n");
-  fs.writeFileSync(tempPath, jsonlContent);
-  return tempPath;
-}
-
-function JobCreateCommand({ modelName, datasets, baseModel, epochs }: JobCreateCommandProps) {
-  const { exit } = useApp();
-  const [state, setState] = useState<"resolving" | "uploading" | "creating" | "done" | "error">("resolving");
-  const [uploadStatuses, setUploadStatuses] = useState<DatasetUploadStatus[]>([]);
-  const [jobResult, setJobResult] = useState<api.TrainingJob | null>(null);
-  const [error, setError] = useState("");
-
-  useEffect(() => {
-    (async () => {
-      // Separate local and remote datasets
-      const localDatasets = datasets.filter((d): d is ParsedDataset & { type: "local"; name: string } =>
-        d.type === "local" && !!d.name
-      );
-      const remoteByNameVersion = datasets.filter((d): d is ParsedDataset & { type: "remote"; name: string } =>
-        d.type === "remote" && !!d.name
-      );
-      const remoteByUUID = datasets.filter((d): d is ParsedDataset & { type: "remote"; id: string } =>
-        d.type === "remote" && !!d.id
-      );
-
-      // Resolve UUIDs to name:version
-      const remoteDatasets: api.DatasetRef[] = remoteByNameVersion.map(d => ({
-        name: d.name,
-        version: d.version ?? "latest"
-      }));
-
-      if (remoteByUUID.length > 0) {
-        // Fetch dataset list to resolve UUIDs
-        const listResult = await api.listDatasets();
-        if (!listResult.ok || !listResult.data) {
-          setError(`Failed to resolve dataset UUIDs: ${listResult.error ?? "Unknown error"}`);
-          setState("error");
-          setTimeout(() => exit(), 500);
-          return;
-        }
-
-        for (const uuidDataset of remoteByUUID) {
-          const found = listResult.data.datasets.find(ds => ds.id === uuidDataset.id);
-          if (!found) {
-            setError(`Dataset not found with UUID: ${uuidDataset.id}`);
-            setState("error");
-            setTimeout(() => exit(), 500);
-            return;
-          }
-          remoteDatasets.push({
-            name: found.dataset_name,
-            version: found.version_number ?? "latest",
-          });
-        }
-      }
-
-      // Validate local datasets exist
-      const statuses: DatasetUploadStatus[] = [];
-      for (const local of localDatasets) {
-        const localPath = resolveLocalDatasetPath(local.name);
-        if (!localPath) {
-          setError(`Local dataset not found: ${local.name}`);
-          setState("error");
-          setTimeout(() => exit(), 500);
-          return;
-        }
-        statuses.push({ name: local.name, path: localPath, status: "pending" });
-      }
-
-      if (statuses.length === 0) {
-        // No local datasets, proceed directly to job creation
-        setState("creating");
-        const result = await api.createJob({
-          model_name: modelName,
-          datasets: remoteDatasets,
-          base_model: baseModel,
-          nr_epochs: epochs,
-        });
-        if (result.ok && result.data) {
-          setJobResult(result.data);
-          setState("done");
-        } else {
-          setError(result.error ?? "Failed to create job");
-          setState("error");
-        }
-        setTimeout(() => exit(), 500);
-        return;
-      }
-
-      // Upload local datasets
-      setUploadStatuses(statuses);
-      setState("uploading");
-
-      const uploadedDatasets: api.DatasetRef[] = [...remoteDatasets];
-      let hasError = false;
+      {remoteSaveFailed && (
+        <Text color="yellow">⚠ Remote save failed (check server logs). Saved locally instead.</Text>
+      )}
+      {savedPath && (
+        <Text color="cyan">Saved to: {savedPath}</Text>
+      )}
+    </Box>
+  );
+}
 
-      for (let i = 0; i < statuses.length; i++) {
-        const status = statuses[i];
+// ─────────────────────────────────────────────────────────────────────────────
+// Helper: Infer format from file extension
+// ─────────────────────────────────────────────────────────────────────────────
 
-        // Update status to uploading
-        setUploadStatuses(prev => prev.map((s, idx) =>
-          idx === i ? { ...s, status: "uploading" as const } : s
-        ));
+function inferFormatFromPath(
+  path: string | undefined,
+  defaultFormat: string = "jsonl"
+): "csv" | "jsonl" | "parquet" {
+  if (!path) return defaultFormat as "csv" | "jsonl" | "parquet";
 
-        try {
-          // Convert JSON to JSONL if needed
-          let uploadPath = status.path;
-          let isTemp = false;
-          if (status.path.endsWith(".json")) {
-            uploadPath = convertJsonToJsonl(status.path);
-            isTemp = true;
-          }
+  const ext = path.toLowerCase().split(".").pop();
+  if (ext === "csv" || ext === "jsonl" || ext === "parquet") {
+    return ext;
+  }
+  return defaultFormat as "csv" | "jsonl" | "parquet";
+}
 
-          const result = await api.uploadDataset(uploadPath, {
-            dataset_name: status.name,
-            dataset_type: getLocalDatasetType(status.path),
-            format: "jsonl",
-          });
+// ─────────────────────────────────────────────────────────────────────────────
+// Dataset List Command (tabular: remote + local in one table)
+// ─────────────────────────────────────────────────────────────────────────────
 
-          // Clean up temp file
-          if (isTemp && uploadPath !== status.path) {
-            try { fs.unlinkSync(uploadPath); } catch { /* ignore */ }
-          }
+interface DatasetRow {
+  source: string;
+  id: string;
+  name: string;
+  version: string;
+  type: string;
+  samples: string;
+  created: string;
+  [key: string]: string;
+}
 
-          if (result.ok && result.data) {
-            const uploadedRef: api.DatasetRef = {
-              name: result.data.dataset_name,
-              version: result.data.version_number ?? "latest",
-            };
-            uploadedDatasets.push(uploadedRef);
-            setUploadStatuses(prev => prev.map((s, idx) =>
-              idx === i ? { ...s, status: "done" as const, uploadedRef } : s
-            ));
-          } else {
-            hasError = true;
-            setUploadStatuses(prev => prev.map((s, idx) =>
-              idx === i ? { ...s, status: "error" as const, error: result.error } : s
-            ));
-          }
-        } catch (err) {
-          hasError = true;
-          setUploadStatuses(prev => prev.map((s, idx) =>
-            idx === i ? { ...s, status: "error" as const, error: err instanceof Error ? err.message : String(err) } : s
-          ));
-        }
-      }
+function shortDatasetId(id?: string): string {
+  if (!id) return "—";
+  return id.length > 8 ? id.slice(0, 8) : id;
+}
 
-      if (hasError) {
-        setError("Some datasets failed to upload");
-        setState("error");
-        setTimeout(() => exit(), 500);
-        return;
-      }
+function formatSampleCount(n?: number): string {
+  if (typeof n !== "number" || Number.isNaN(n)) return "—";
+  return n.toLocaleString();
+}
 
-      // Create the job with all datasets
-      setState("creating");
+const DATASET_COLUMNS: TableColumn<DatasetRow>[] = [
+  { key: "source", header: "SOURCE", minWidth: 6, maxWidth: 6, color: (row) => (row.source === "remote" ? "cyan" : "green") },
+  { key: "id", header: "ID", minWidth: 8, maxWidth: 8 },
+  { key: "name", header: "NAME", minWidth: 10, maxWidth: 38, flexible: true },
+  { key: "version", header: "VERSION", minWidth: 4, maxWidth: 8 },
+  { key: "type", header: "TYPE", minWidth: 4, maxWidth: 14, flexible: true },
+  { key: "samples", header: "SAMPLES", minWidth: 7, maxWidth: 10 },
+  { key: "created", header: "CREATED", minWidth: 7, maxWidth: 10 },
+];
 
-      const result = await api.createJob({
-        model_name: modelName,
-        datasets: uploadedDatasets,
-        base_model: baseModel,
-        nr_epochs: epochs,
-      });
+function DatasetListCommand() {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done">("loading");
+  const [remoteData, setRemoteData] = useState<api.DatasetListResponse | null>(null);
+  const [remoteError, setRemoteError] = useState<string | null>(null);
+  const [localDatasets, setLocalDatasets] = useState<LocalDataset[]>([]);
 
-      if (result.ok && result.data) {
-        setJobResult(result.data);
-        setState("done");
-      } else {
-        setError(result.error ?? "Failed to create job");
-        setState("error");
-      }
+  useEffect(() => {
+    (async () => {
+      const result = await api.listDatasets();
+      setLocalDatasets(listLocalDatasets());
+      if (result.ok) setRemoteData(result.data ?? null);
+      else setRemoteError(result.error ?? "Unknown error");
+      setState("done");
       setTimeout(() => exit(), 500);
     })();
-  }, [modelName, datasets, baseModel, epochs, exit]);
-
-  if (state === "resolving") {
-    return <Loading message="Resolving datasets..." />;
-  }
-
-  if (state === "uploading") {
-    return (
-      <Box flexDirection="column">
-        <Text>
-          <Text color="blue"><Spinner type="dots" /></Text>
-          {" "}Uploading local datasets...
-        </Text>
-        {uploadStatuses.map((status, idx) => (
-          <Box key={idx}>
-            <Text>
-              {"  "}
-              {status.status === "pending" && <Text color="gray">○</Text>}
-              {status.status === "uploading" && <Text color="yellow"><Spinner type="dots" /></Text>}
-              {status.status === "done" && <Text color="green">✓</Text>}
-              {status.status === "error" && <Text color="red">✗</Text>}
-              {" "}{status.name}
-              {status.status === "done" && status.uploadedRef && (
-                <Text color="gray"> → {status.uploadedRef.name}:{status.uploadedRef.version}</Text>
-              )}
-              {status.status === "error" && status.error && (
-                <Text color="red"> ({status.error})</Text>
-              )}
-            </Text>
-          </Box>
-        ))}
-      </Box>
-    );
-  }
+  }, [exit]);
 
-  if (state === "creating") {
-    return <Loading message="Creating training job..." />;
-  }
+  if (state === "loading") return <Loading />;
 
-  if (state === "error") {
+  const remoteDatasets = remoteData?.datasets ?? [];
+  const remoteRows: DatasetRow[] = remoteDatasets.map((ds) => ({
+    source: "remote",
+    id: shortDatasetId(ds.id),
+    name: ds.dataset_name || "—",
+    version: ds.version_number ? `v${ds.version_number}` : "v1",
+    type: ds.dataset_type || "—",
+    samples: formatSampleCount(ds.sample_size),
+    created: relativeTime(ds.created_at),
+  }));
+  const localRows: DatasetRow[] = localDatasets.map((ds) => ({
+    source: "local",
+    id: "—",
+    name: ds.name,
+    version: "—",
+    type: ds.type || "—",
+    samples: formatSampleCount(ds.sample_size),
+    created: "—",
+  }));
+  const rows = [...remoteRows, ...localRows];
+
+  if (rows.length === 0 && !remoteError) {
     return (
       <Box flexDirection="column">
-        {uploadStatuses.length > 0 && uploadStatuses.some(s => s.status === "done") && (
-          <Box flexDirection="column" marginBottom={1}>
-            <Text color="green">✓ Uploaded datasets:</Text>
-            {uploadStatuses.filter(s => s.status === "done").map((status, idx) => (
-              <Text key={idx} color="gray">
-                {"  "}{status.name} → {status.uploadedRef?.name}:{status.uploadedRef?.version}
-              </Text>
-            ))}
-          </Box>
-        )}
-        <ErrorMessage error={error} />
+        <Text>No datasets found.</Text>
+        <Text dimColor>Use the Pioneer web app at agent.pioneer.ai to create datasets, or drop JSON/JSONL files in ./datasets/.</Text>
       </Box>
     );
   }
 
   return (
     <Box flexDirection="column">
-      {uploadStatuses.length > 0 && (
-        <Box flexDirection="column" marginBottom={1}>
-          <Text color="green">✓ Uploaded local datasets:</Text>
-          {uploadStatuses.map((status, idx) => (
-            <Text key={idx} color="gray">
-              {"  "}{status.name} → {status.uploadedRef?.name}:{status.uploadedRef?.version}
-            </Text>
+      {remoteError ? (
+        <Box flexDirection="column" marginBottom={rows.length ? 1 : 0}>
+          {remoteError.split("\n").map((line, idx) => (
+            <Text key={idx} color="red">{line}</Text>
           ))}
         </Box>
-      )}
-      <Success message="Training job created" />
-      {jobResult && (
-        <Box flexDirection="column">
-          <Text>
-            {"  "}Job ID: <Text color="cyan">{jobResult.id}</Text>
-          </Text>
-          <Text>
-            {"  "}Model: <Text color="yellow">{jobResult.model_name}</Text>
-          </Text>
-          <Text>
-            {"  "}Status: <Text color="blue">{jobResult.status}</Text>
-          </Text>
-        </Box>
-      )}
+      ) : null}
+      {rows.length > 0 ? (
+        <DataTable
+          columns={DATASET_COLUMNS}
+          rows={rows}
+          footer={`${remoteRows.length} remote · ${localRows.length} local · use \`pioneer dataset get <name[:version]>\` for details · use \`--json\` for raw JSON`}
+        />
+      ) : null}
     </Box>
   );
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Dataset Get Command (single-resource key/value layout)
+// ─────────────────────────────────────────────────────────────────────────────
+
+function datasetToDetailRows(ds: api.Dataset): DetailRow[] {
+  const rows: DetailRow[] = [
+    { label: "ID", value: formatNonEmpty(ds.id) },
+    { label: "Name", value: formatNonEmpty(ds.dataset_name) },
+    { label: "Version", value: ds.version_number ? `v${ds.version_number}` : "—" },
+    { label: "Type", value: formatNonEmpty(ds.dataset_type) },
+    { label: "Status", value: formatNonEmpty(ds.status), valueColor: statusColor(ds.status) },
+    { label: "Samples", value: formatSampleCount(ds.sample_size) },
+    { label: "Train ratio", value: ds.train_ratio != null ? formatPercent(ds.train_ratio) : "—" },
+    { label: "Visibility", value: formatNonEmpty(ds.visibility) },
+    { label: "Labels", value: formatLabels(ds.labels) },
+    { label: "Annotation status", value: formatNonEmpty(ds.annotation_status) },
+    { label: "Project ID", value: formatNonEmpty(ds.project_id) },
+    { label: "Root dataset ID", value: formatNonEmpty(ds.root_dataset_id) },
+    { label: "Created", value: formatTimestamp(ds.created_at) },
+    { label: "Updated", value: formatTimestamp(ds.updated_at) },
+  ];
+  if (ds.processing_error) {
+    rows.push({ label: "Error", value: ds.processing_error, valueColor: "red" });
+  }
+  return rows;
+}
+
+function DatasetGetCommand({ dataset }: { dataset: api.DatasetRef }) {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done" | "error">("loading");
+  const [data, setData] = useState<api.Dataset | null>(null);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    let active = true;
+    (async () => {
+      const result = await api.getDataset(dataset);
+      if (!active) return;
+      if (!result.ok) {
+        setError(result.error ?? "Failed to load dataset.");
+        setState("error");
+      } else {
+        setData(result.data ?? null);
+        setState("done");
+      }
+      setTimeout(() => exit(), 500);
+    })();
+    return () => {
+      active = false;
+    };
+  }, [dataset.name, dataset.version, exit]);
+
+  if (state === "loading") return <Loading message={`Loading dataset ${dataset.name}:${dataset.version}...`} />;
+  if (state === "error") return <ErrorMessage error={error} />;
+  if (!data) return <ErrorMessage error="Dataset response was empty." />;
+
+  return (
+    <DetailView
+      rows={datasetToDetailRows(data)}
+      footer={`Use \`pioneer dataset get ${dataset.name}:${dataset.version} --json\` for the raw JSON payload.`}
+    />
+  );
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Dataset Download Command
 // ─────────────────────────────────────────────────────────────────────────────
@@ -2943,13 +3882,6 @@ function TrainedModelCard({ model, index }: TrainedModelCardProps) {
         <Box width={24}>
           <Text color="blue">{datasetInfo.substring(0, 22)}</Text>
         </Box>
-        <Box width={14}>
-          <Text>
-            <Text color="yellow">{model.nr_epochs}</Text>
-            <Text dimColor>e </Text>
-            <Text color="yellow">{model.learning_rate}</Text>
-          </Text>
-        </Box>
         <Box width={30}>
           <Text color="green">{metricsDisplay || "N/A"}</Text>
         </Box>
@@ -2960,11 +3892,6 @@ function TrainedModelCard({ model, index }: TrainedModelCardProps) {
           <Text dimColor>{formatDateShort(model.completed_at || model.started_at || model.created_at)}</Text>
         </Box>
       </Box>
-      {model.error_message && (
-        <Box marginLeft={2}>
-          <Text color="red">Error: {model.error_message}</Text>
-        </Box>
-      )}
     </Box>
   );
 }
@@ -3036,15 +3963,33 @@ function DeployedModelCard({ model, index }: DeployedModelCardProps) {
 interface ProjectModelCardProps {
   model: api.ProjectResponse;
   index: number;
+  jobIndex?: Map<string, api.TrainingJob>;
 }
 
-function ProjectModelCard({ model, index }: ProjectModelCardProps) {
+function ProjectModelCard({ model, index, jobIndex }: ProjectModelCardProps) {
   const formatDateShort = (dateStr: string | null | undefined) => {
     if (!dateStr) return "N/A";
     const date = new Date(dateStr);
     return date.toLocaleDateString() + " " + date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
   };
 
+  // Drop "<org>/" prefix from HF model ids for compact list display.
+  const stripOrg = (modelId: string) => {
+    const idx = modelId.indexOf("/");
+    return idx >= 0 ? modelId.slice(idx + 1) : modelId;
+  };
+  const selected = model.selected_model_id ?? "";
+  const activeJob = selected && UUID_REGEX.test(selected) ? jobIndex?.get(selected) : undefined;
+  const selectedDisplay = (() => {
+    if (!selected) return "N/A";
+    if (activeJob) {
+      const name = activeJob.model_name ?? shortJobId(selected);
+      const base = activeJob.base_model ? ` ← ${stripOrg(activeJob.base_model)}` : "";
+      return `${name}${base}`;
+    }
+    return UUID_REGEX.test(selected) ? shortJobId(selected) : stripOrg(selected);
+  })();
+
   return (
     <Box flexDirection="column" marginTop={index > 0 ? 0 : 0}>
       <Box>
@@ -3056,8 +4001,8 @@ function ProjectModelCard({ model, index }: ProjectModelCardProps) {
         <Box width={38}>
           <Text dimColor>{model.id}</Text>
         </Box>
-        <Box width={24}>
-          <Text color="magenta">{model.selected_model_id || "N/A"}</Text>
+        <Box width={36}>
+          <Text color="magenta" wrap="truncate-end">{selectedDisplay}</Text>
         </Box>
         <Box width={18}>
           <Text dimColor>{formatDateShort(model.created_at)}</Text>
@@ -3086,21 +4031,41 @@ function ModelListCommand({ filter }: ModelListCommandProps) {
   const { exit } = useApp();
   const [state, setState] = useState<"loading" | "done" | "error">("loading");
   const [data, setData] = useState<api.AllModelsResponse | null>(null);
+  const [jobIndex, setJobIndex] = useState<Map<string, api.TrainingJob>>(new Map());
   const [error, setError] = useState("");
 
   useEffect(() => {
     (async () => {
       const result = await api.listAllModels();
-      if (result.ok) {
-        setData(result.data ?? null);
-        setState("done");
-      } else {
+      if (!result.ok) {
         setError(result.error ?? "Unknown error");
         setState("error");
+        setTimeout(() => exit(), 500);
+        return;
+      }
+      setData(result.data ?? null);
+
+      // For "registered" (Model Entries), each project's selected_model_id may
+      // be a training-job UUID. Pull all jobs once and build a lookup so we
+      // can render `model_name (base_model)` in place of the bare UUID.
+      const projects = result.data?.projects ?? [];
+      const needsHydration = projects.some((p) =>
+        p.selected_model_id && UUID_REGEX.test(p.selected_model_id),
+      );
+      if (filter === "registered" && needsHydration) {
+        const jobsResult = await api.listJobs();
+        if (jobsResult.ok) {
+          const map = new Map<string, api.TrainingJob>();
+          for (const j of jobsResult.data?.training_jobs ?? []) {
+            if (j.id) map.set(j.id, j);
+          }
+          setJobIndex(map);
+        }
       }
+      setState("done");
       setTimeout(() => exit(), 500);
     })();
-  }, [exit]);
+  }, [exit, filter]);
 
   if (state === "loading") {
     return <Loading />;
@@ -3131,15 +4096,20 @@ function ModelListCommand({ filter }: ModelListCommandProps) {
                 <Box width={38}>
                   <Text bold dimColor>Model ID</Text>
                 </Box>
-                <Box width={24}>
-                  <Text bold dimColor>Base Model</Text>
+                <Box width={36}>
+                  <Text bold dimColor>Active Model</Text>
                 </Box>
                 <Box width={18}>
                   <Text bold dimColor>Created</Text>
                 </Box>
               </Box>
               {data?.projects.map((model, index) => (
-                <ProjectModelCard key={model.id || index} model={model} index={index} />
+                <ProjectModelCard
+                  key={model.id || index}
+                  model={model}
+                  index={index}
+                  jobIndex={jobIndex}
+                />
               ))}
             </Box>
           )}
@@ -3200,9 +4170,6 @@ function ModelListCommand({ filter }: ModelListCommandProps) {
                 <Box width={24}>
                   <Text bold dimColor>Dataset</Text>
                 </Box>
-                <Box width={14}>
-                  <Text bold dimColor>Config</Text>
-                </Box>
                 <Box width={30}>
                   <Text bold dimColor>Metrics</Text>
                 </Box>
@@ -3265,7 +4232,7 @@ function normalizeModelId(modelId: string): string {
 
 function getDecoderTaskType(model: api.BaseModelInfo | null | undefined): string {
   if (!model) return "";
-  return `${model.task_type ?? model.type ?? ""}`.trim().toLowerCase();
+  return `${model.task_type ?? ""}`.trim().toLowerCase();
 }
 
 function modelSupportsDecoderInference(model: api.BaseModelInfo | null | undefined): boolean {
@@ -3542,112 +4509,11 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <Text dimColor>  Dataset format: name[:version] (version defaults to "latest")</Text>
         <Text dimColor>  Examples: my-dataset, my-dataset:v1, my-dataset:latest</Text>
         <Text> </Text>
-        <Text>  dataset list              List all datasets</Text>
-        <Text>  dataset get {"<name[:version]>"}          Get dataset details</Text>
-        <Text>  dataset delete {"<name[:version]>"}       Delete a dataset</Text>
-        <Text>  dataset analyze {"<name[:version]>"}      Analyze a dataset</Text>
-        <Text>  dataset analyze-llm {"<name[:version]>"}  LLM-only dataset analysis</Text>
+        <Text>  dataset list                              List all datasets (tabular). Add --json for raw JSON.</Text>
+        <Text>  dataset get {"<name[:version]>"}          Get dataset details (key/value layout). Add --json for raw JSON.</Text>
         <Text> </Text>
-        <Text bold>  Generate:</Text>
-        <Text>  dataset generate ner</Text>
-        <Text>    --labels {"<l1,l2,...>"}      Entity labels (required)</Text>
-        <Text>    --num {"<n>"}                 Number of examples (default: 10)</Text>
-        <Text>    --domain {"<desc>"}           Domain description</Text>
-        <Text>    --save true               Save to database</Text>
-        <Text>    --name {"<name>"}             Dataset name (required if --save)</Text>
-        <Text> </Text>
-        <Text>  dataset generate classification</Text>
-        <Text>    --labels {"<l1,l2,...>"}      Class labels (required)</Text>
-        <Text>    --num {"<n>"}                 Number of examples (default: 10)</Text>
-        <Text>    --domain {"<desc>"}           Domain description</Text>
-        <Text>    --multi-label true        Enable multi-label</Text>
-        <Text>    --save true               Save to database</Text>
-        <Text>    --name {"<name>"}             Dataset name (required if --save)</Text>
-        <Text> </Text>
-        <Text>  dataset generate custom</Text>
-        <Text>    --prompt {"<prompt>"}         Task description (required)</Text>
-        <Text>    --format {"<json>"}           Output format as JSON (required)</Text>
-        <Text>    --num {"<n>"}                 Number of examples (default: 10)</Text>
-        <Text>    --save true               Save to database</Text>
-        <Text>    --name {"<name>"}             Dataset name (required if --save)</Text>
-        <Text> </Text>
-        <Text>  dataset generate decoder</Text>
-        <Text>    --domain {"<desc>"}           Domain/task description (required)</Text>
-        <Text>    --instruction {"<text>"}      System instruction (optional, auto-inferred)</Text>
-        <Text>    --num {"<n>"}                 Number of examples (default: 10)</Text>
-        <Text>    --save true               Save to database</Text>
-        <Text>    --name {"<name>"}             Dataset name (required if --save)</Text>
-        <Text>  Advanced generation flags:</Text>
-        <Text>    --quality {"<light|medium|heavy>"}        Generation quality profile</Text>
-        <Text>    --generation-profile {"<auto|fast|balanced|quality>"}  Runtime profile</Text>
-        <Text>    --reasoning-trace {"true|false"}         Include reasoning traces (decoder only)</Text>
-        <Text>    --reasoning-effort {"<low|medium|high>"}  Reasoning effort</Text>
-        <Text>    --multiplicator {"<json>"}               Multiplicator settings</Text>
-        <Text>    --use-meta-felix {"true|false"}          Use MetaFelix metadata</Text>
-        <Text>    --min-criteria {"<n>"}                 Minimum diversity criteria</Text>
-        <Text>    --target-choices {"<n>"}                Diversity target choices</Text>
-        <Text>    --project-id {"<id>"}                   Project ID</Text>
-        <Text>    --type {"training|evaluation|split"}    Dataset type</Text>
-        <Text>    --visibility {"private|public"}         Dataset visibility</Text>
-        <Text>    --split-ratio {"<train:eval>|{json>}"}  Split dataset ratio</Text>
-        <Text>    --negative-ratio {"<n>"}                Percent negative samples</Text>
-        <Text>    --classified-examples {"<json>"}        Classified examples with feedback</Text>
-        <Text> </Text>
-        <Text bold>  Infer Labels:</Text>
-        <Text>  dataset infer ner              Infer NER labels from description</Text>
-        <Text>  dataset infer classification   Infer classification labels</Text>
-        <Text>  dataset infer fields           Infer input/output fields</Text>
-        <Text>    --domain {"<desc>"}           Domain description (required)</Text>
-        <Text>  dataset infer infer-advanced   Infer constraints and multiplicator from a prompt</Text>
-        <Text>    --prompt {"<prompt>"}        Prompt for inference</Text>
-        <Text>    --labels {"<l1,l2,...>"}     Optional labels to guide suggestions</Text>
-        <Text>    --data-type {"<type>"}       entity_extraction|classification|json_extraction</Text>
-        <Text>  dataset infer improve-prompt   Improve a generation prompt</Text>
-        <Text>    --prompt {"<prompt>"}        Prompt to improve</Text>
-        <Text>    --data-type {"<type>"}       Optional prompt domain hint</Text>
-        <Text>  dataset label-existing ner             Label existing NER texts</Text>
-        <Text>    --labels {"<l1,l2,...>"}             Labels for entities</Text>
-        <Text>    --inputs {"[{\"text\":\"...\"},...]"}  Input texts JSON array (required)</Text>
-        <Text>    --name {"<name>"}                    Output dataset name (optional if --save false)</Text>
-        <Text>    --project-id {"<project_id>"}        Assign output dataset to project</Text>
-        <Text>    --save {"<true|false>"}             Save dataset (default: false)</Text>
-        <Text>  dataset label-existing classification    Label existing classification texts</Text>
-        <Text>    --labels {"<l1,l2,...>"}             Labels for classes</Text>
-        <Text>    --inputs {"[{\"text\":\"...\"},...]"}  Input texts JSON array (required)</Text>
-        <Text>    --name {"<name>"}                    Output dataset name (optional if --save false)</Text>
-        <Text>    --project-id {"<project_id>"}        Assign output dataset to project</Text>
-        <Text>    --save {"<true|false>"}             Save dataset (default: false)</Text>
-        <Text>  dataset label-existing fields            Label existing structured records</Text>
-        <Text>    --input-fields {"[{\"name\":\"...\"},...]"}  Input schema fields (required)</Text>
-        <Text>    --output-fields {"[{\"name\":\"...\"},...]"} Output schema fields (required)</Text>
-        <Text>    --inputs {"[{\"f1\":\"v\"},...]"}           Input records JSON array (required)</Text>
-        <Text>    --name {"<name>"}                    Output dataset name (optional if --save false)</Text>
-        <Text>    --project-id {"<project_id>"}        Assign output dataset to project</Text>
-        <Text>    --save {"<true|false>"}             Save dataset (default: false)</Text>
-        <Text> </Text>
-        <Text bold>  Upload/Download:</Text>
-        <Text>  dataset upload {"<file>"}          Upload local file to Pioneer</Text>
-        <Text>    --name {"<name>"}               Dataset name (required)</Text>
-        <Text>    --type {"<type>"}               Type: ner, classification, custom</Text>
-        <Text>  dataset upload {"<name[:version]>"} --to hf    Upload Pioneer dataset to Hugging Face</Text>
-        <Text>    --repo {"<repo>"}               HF repo (required, e.g., username/dataset)</Text>
-        <Text>    --private                   Make repo private</Text>
-        <Text dimColor>    Note: Set HF token with 'pioneer auth hf' first</Text>
-        <Text>  dataset download {"<name[:version]>"}          Download from Pioneer to local file</Text>
-        <Text>    --format {"<type>"}             Format: jsonl, csv, parquet (default: jsonl)</Text>
-        <Text>    --output {"<path>"}             Output file path</Text>
-        <Text>  dataset download --from hf     Download from Hugging Face to Pioneer</Text>
-        <Text>    --repo {"<repo>"}               HF repo (required, e.g., username/dataset)</Text>
-        <Text>    --name {"<name>"}               Local dataset name (optional)</Text>
-        <Text>    --revision {"<rev>"}            Git revision/branch (optional)</Text>
-        <Text dimColor>    Note: For private repos, set HF token with 'pioneer auth hf'</Text>
-        <Text> </Text>
-        <Text bold>  Data Editing:</Text>
-        <Text>  dataset edit --help               Show data editing commands</Text>
-        <Text>  dataset edit scan-pii {"<name[:version]>"}        Scan for PII</Text>
-        <Text>  dataset edit dismiss-outlier {"<name[:version]>"}  Dismiss an outlier fingerprint</Text>
-        <Text>    --fingerprint {"<hash>"}              Outlier fingerprint from dataset analysis</Text>
-        <Text>  dataset edit subsample {"<name[:version]>"}       Create a subsample</Text>
+        <Text dimColor>  Other dataset subcommands (generate/edit/upload/etc.) are temporarily hidden in this version.</Text>
+        <Text dimColor>  Use the Pioneer web app at agent.pioneer.ai to create or edit datasets.</Text>
       </Box>
     );
   }
@@ -3710,18 +4576,13 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
     return (
       <Box flexDirection="column">
         <Text bold>Job Commands:</Text>
-        <Text>  job list           List training jobs</Text>
-        <Text>  job get {"<id>"}       Get job details</Text>
+        <Text>  job list           List training jobs (tabular). Add --json for raw JSON.</Text>
+        <Text>  job get {"<id>"}       Get job details (key/value layout). Add --json for raw JSON. Accepts a unique short prefix from `job list`.</Text>
         <Text>  job logs {"<id>"}      Get job logs</Text>
         <Text>  job delete {"<id>"}    Delete a training job</Text>
-        <Text>  job create         Create training job</Text>
-        <Text>    --model-name {"<name>"}   Model name (required)</Text>
-        <Text>    --dataset-ids {"<ids>"}   Comma-separated datasets (required)</Text>
-        <Text>                         remote:{"<name>"}:{"<version>"} - by name and version</Text>
-        <Text>                         remote:{"<uuid>"} - by UUID</Text>
-        <Text>                         local:{"<name>"} - auto-upload from ./datasets/</Text>
-        <Text>    --base-model {"<model>"}  Base model (default: fastino/gliner2-base-v1)</Text>
-        <Text>    --epochs {"<n>"}          Number of epochs (default: 5)</Text>
+        <Text> </Text>
+        <Text dimColor>  To create a training job, use `pioneer agent` — it will help you pick a base model,</Text>
+        <Text dimColor>  select datasets, and configure training conversationally.</Text>
       </Box>
     );
   }
@@ -3740,13 +4601,13 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <Text>    --description {"<text>"}                    Optional</Text>
         <Text>    --model {"<base-model-id>"}                 Optional (starts interactive picker when omitted)</Text>
         <Text>    --example {"<json>"}                        Optional</Text>
-        <Text>  model endpoints get {"<model-id>"}            Get endpoint/model entry details</Text>
+        <Text>  model endpoints get {"<model-id>"}            Get endpoint details (key/value layout, includes dataset count). Add --json for raw JSON.</Text>
         <Text>  model endpoints update {"<model-id>"}         Update endpoint metadata</Text>
         <Text>    --name {"<name>"} --icon {"<icon>"} --repo {"<repo-url>"} --description {"<text>"} --model-id {"<id>"}</Text>
         <Text>  model endpoints delete {"<model-id>"}         Delete an endpoint/model entry</Text>
-        <Text>  model endpoints dataset-count {"<model-id>"}   Get attached dataset count</Text>
-        <Text>  model endpoints quality-metrics {"<model-id>"} Show LLMAJ pass/fail metrics</Text>
-        <Text>  model endpoints deploy {"<model-id>"} --job {"<training-job-id>"} [--reason {"<text>"}]  Deploy a trained job to the endpoint</Text>
+        <Text>  model endpoints quality-metrics {"<model-id>"} Show LLMAJ pass/fail metrics. Add --json for raw JSON.</Text>
+        <Text>  model endpoints deploy {"<model-id>"} [--job {"<training-job-id>"}] [--reason {"<text>"}] [--all]</Text>
+        <Text dimColor>     If --job is omitted, pick from a list of deployable jobs interactively. By default the list is filtered to jobs whose base model matches the endpoint; pass --all to bypass that filter.</Text>
         <Text>  model endpoints rollback {"<model-id>"} {"<deployment-id>"}  Rollback endpoint to previous deployment</Text>
       </Box>
     );
@@ -3761,7 +4622,7 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <Text>  model artifacts list                               Show both trained and deployed artifacts</Text>
         <Text>  model artifacts trained                            List trained artifacts</Text>
         <Text>  model artifacts deployed                           List deployed artifacts</Text>
-        <Text>  model artifacts download {"<job-id>"}               Download model artifact</Text>
+        <Text>  model artifacts download {"<job-id>"}               Get a signed download URL for the artifact (key/value layout). Add --json for raw JSON.</Text>
         <Text>  model artifacts delete {"<job-id>"}                Delete deployed artifact record</Text>
         <Text>  model artifacts upload {"<job-id>"} --to hf        Upload trained model artifact to Hugging Face</Text>
         <Text>    --repo {"<repo>"}                             HF repo (required, e.g., username/model)</Text>
@@ -3779,17 +4640,20 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <Text bold>Model Commands:</Text>
         <Text>  model endpoints ... (alias: model_endpoints)   Manage model catalog entries (from /projects)</Text>
         <Text>  model artifacts ... (alias: model_artifacts)    Manage trained/deployed artifacts (from /felix)</Text>
+        <Text>  model base-models                              List available base models (tabular)</Text>
         <Text> </Text>
         <Text>  model endpoints list</Text>
         <Text>  model endpoints create</Text>
         <Text>  model endpoints get {"<model-id>"}</Text>
-        <Text>  model endpoints deploy {"<model-id>"} --job {"<training-job-id>"} [--reason {"<text>"}]</Text>
+        <Text>  model endpoints quality-metrics {"<model-id>"}</Text>
+        <Text>  model endpoints deploy {"<model-id>"} [--job {"<training-job-id>"}] [--reason {"<text>"}] [--all]</Text>
         <Text>  model endpoints rollback {"<model-id>"} {"<deployment-id>"}</Text>
         <Text>  model artifacts list</Text>
         <Text>  model artifacts trained</Text>
-      <Text>  model artifacts deployed</Text>
-      <Text>  model artifacts download {"<job-id>"}</Text>
+        <Text>  model artifacts deployed</Text>
+        <Text>  model artifacts download {"<job-id>"}</Text>
         <Text> </Text>
+        <Text dimColor>  Most read commands accept `--json` for the raw JSON payload.</Text>
       </Box>
     );
   }
@@ -3921,13 +4785,8 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
     rest[0] === "create" &&
     parseErrors.length === 1 &&
     parseErrors[0] === "--model";
-  const isModelEndpointsDeployMissingJob =
-    group === "model" &&
-    normalizedAction === "endpoints" &&
-    rest[0] === "deploy" &&
-    !flags["job"];
 
-  if (group === "dataset" || group === "inference" || group === "eval" || group === "benchmark") {
+  if (group === "inference" || group === "eval" || group === "benchmark") {
     return (
       <ErrorMessage
         error={`The '${group}' command group is temporarily hidden for this version. Use 'pioneer --help' to see available commands.`}
@@ -3935,6 +4794,19 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
     );
   }
 
+  if (group === "dataset") {
+    const allowedDatasetActions = new Set(["list", "get", "help", undefined, ""]);
+    const subAction = action ?? "";
+    const isHelp = flags["help"] === "true" || subAction === "" || subAction === "help";
+    if (!isHelp && !allowedDatasetActions.has(subAction)) {
+      return (
+        <ErrorMessage
+          error={`'dataset ${subAction}' is temporarily hidden for this version. Available: pioneer dataset list, pioneer dataset get <name[:version]>.`}
+        />
+      );
+    }
+  }
+
   if (hasParseErrors && !isModelCreateMissingModel) {
     const missingValueHints: Record<string, string> = {
       "--model": "<base-model-id>",
@@ -3960,7 +4832,6 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
       "--labels": "<json-array>",
       "--label-column": "<column>",
       "--text-column": "<column>",
-      "--dataset-ids": "<comma-separated-ids>",
       "--output": "<path>",
       "--format-results": "<true|false>",
       "--include-confidence": "<true|false>",
@@ -3975,28 +4846,6 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
       return missingValueHints[flag] ?? "<value>";
     };
 
-    if (isModelEndpointsDeployMissingJob) {
-      const errorMessage = rest[1]
-        ? `Training job ID required: model endpoints deploy ${rest[1]} --job <training-job-id>`
-        : "Training job ID required: model endpoints deploy <model-id> --job <training-job-id>";
-
-      return (
-        <ApiCommand
-          action={() =>
-            Promise.resolve<api.ApiResult<{ message: string }>>({
-              ok: false,
-              status: 400,
-              error: errorMessage,
-              data: {
-                message: errorMessage,
-              },
-            })
-          }
-          successMessage="Validation failed"
-        />
-      );
-    }
-
     return (
       <Box flexDirection="column">
         <ErrorMessage error="One or more flags are missing values. Please provide values for: " />
@@ -4360,6 +5209,9 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
     }
 
     if (action === "list") {
+      if (flags.json === "true") {
+        return <ApiCommand action={api.listDatasets} />;
+      }
       return <DatasetListCommand />;
     }
     if (action === "get" && rest[0]) {
@@ -4367,7 +5219,10 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
       if (!dataset) {
         return <ErrorMessage error={`Invalid dataset format: ${rest[0]}. Use name[:version] format (e.g., my-dataset or my-dataset:v1).`} />;
       }
-      return <ApiCommand action={() => api.getDataset(dataset)} />;
+      if (flags.json === "true") {
+        return <ApiCommand action={() => api.getDataset(dataset)} />;
+      }
+      return <DatasetGetCommand dataset={dataset} />;
     }
     if (action === "delete" && rest[0]) {
       const dataset = parseDatasetRef(rest[0]);
@@ -4884,48 +5739,55 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
       return <Help context="job" />;
     }
     if (action === "list") {
-      return <ApiCommand action={api.listJobs} />;
+      if (flags.json === "true") {
+        return <ApiCommand action={api.listJobs} />;
+      }
+      return <JobListCommand />;
     }
     if (action === "get" && rest[0]) {
-      return <ApiCommand action={() => api.getJob(rest[0])} />;
+      const wantsJson = flags.json === "true";
+      return (
+        <WithResolvedJobId
+          rawId={rest[0]}
+          render={(jobId) =>
+            wantsJson ? (
+              <ApiCommand action={() => api.getJob(jobId)} />
+            ) : (
+              <JobGetCommand jobId={jobId} />
+            )
+          }
+        />
+      );
     }
     if (action === "logs" && rest[0]) {
-      return <JobLogsCommand jobId={rest[0]} />;
+      return (
+        <WithResolvedJobId
+          rawId={rest[0]}
+          render={(jobId) => <JobLogsCommand jobId={jobId} />}
+        />
+      );
     }
     if (action === "delete" && rest[0]) {
       return (
-        <ApiCommand
-          action={() => api.deleteJob(rest[0])}
-          successMessage={`Training job ${rest[0]} deleted`}
+        <WithResolvedJobId
+          rawId={rest[0]}
+          render={(jobId) => (
+            <ApiCommand
+              action={() => api.deleteJob(jobId)}
+              successMessage={`Training job ${jobId} deleted`}
+            />
+          )}
         />
       );
     }
     if (action === "create") {
-      const modelName = flags["model-name"];
-      const datasetStrings = flags["dataset-ids"]?.split(",").filter(Boolean) ?? [];
-      const baseModel = flags["base-model"];
-      const epochs = flags["epochs"] ? parseInt(flags["epochs"], 10) : undefined;
-
-      if (!modelName || datasetStrings.length === 0) {
-        return <ErrorMessage error="--model-name and --dataset-ids are required" />;
-      }
-
-      // Parse dataset strings with explicit local:/remote: prefixes
-      const datasets: ParsedDataset[] = [];
-      for (const ds of datasetStrings) {
-        const parsed = parseDatasetString(ds);
-        if ("error" in parsed) {
-          return <ErrorMessage error={parsed.error} />;
-        }
-        datasets.push(parsed);
-      }
-
       return (
-        <JobCreateCommand
-          modelName={modelName}
-          datasets={datasets}
-          baseModel={baseModel}
-          epochs={epochs}
+        <ErrorMessage
+          error={
+            "`pioneer job create` has been removed.\n" +
+            "Use `pioneer agent` to create training jobs conversationally — it will help you pick a base model,\n" +
+            "select datasets, and configure training without needing to remember flags or dataset IDs."
+          }
         />
       );
     }
@@ -4939,7 +5801,10 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
     }
 
     if (action === "base-models" || action === "models" || action === "list") {
-      return <ApiCommand action={api.listBaseModels} />;
+      if (flags.json === "true") {
+        return <ApiCommand action={api.listBaseModels} />;
+      }
+      return <BaseModelsListCommand />;
     }
 
     if (action === "encoder") {
@@ -5137,6 +6002,13 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
       return <Help context="model" />;
     }
 
+    if (normalizedAction === "base-models" || normalizedAction === "models") {
+      if (flags.json === "true") {
+        return <ApiCommand action={api.listBaseModels} />;
+      }
+      return <BaseModelsListCommand />;
+    }
+
     if (normalizedAction === "endpoints") {
       const endpointAction = rest[0];
       const endpointArgs = rest.slice(1);
@@ -5213,7 +6085,10 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
         if (!modelId) {
           return <ErrorMessage error="Model ID required: model endpoints get <model-id>" />;
         }
-        return <ApiCommand action={() => api.getProject(modelId)} />;
+        if (flags.json === "true") {
+          return <ApiCommand action={() => api.getProject(modelId)} />;
+        }
+        return <ModelEndpointGetCommand modelId={modelId} />;
       }
 
       if (endpointAction === "update") {
@@ -5264,11 +6139,14 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
       }
 
       if (endpointAction === "dataset-count" || endpointAction === "count") {
-        const modelId = endpointArgs[0];
-        if (!modelId) {
-          return <ErrorMessage error="Model ID required: model endpoints dataset-count <model-id>" />;
-        }
-        return <ApiCommand action={() => api.getProjectDatasetCount(modelId)} />;
+        return (
+          <ErrorMessage
+            error={
+              "`pioneer model endpoints dataset-count` has been removed.\n" +
+              "The dataset count and `can_delete` flag are now surfaced inline in `pioneer model endpoints get <model-id>`."
+            }
+          />
+        );
       }
 
       if (endpointAction === "quality-metrics" || endpointAction === "quality") {
@@ -5276,40 +6154,75 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
         if (!modelId) {
           return <ErrorMessage error="Model ID required: model endpoints quality-metrics <model-id>" />;
         }
-        return <ApiCommand action={() => api.getProjectQualityMetrics(modelId)} />;
+        if (flags.json === "true") {
+          return <ApiCommand action={() => api.getProjectQualityMetrics(modelId)} />;
+        }
+        return <ModelQualityMetricsCommand modelId={modelId} />;
       }
 
       if (endpointAction === "deploy") {
         const modelId = endpointArgs[0];
-        const jobId = flags["job"];
+        const rawJobId = flags["job"];
 
         if (!modelId) {
-          return <ErrorMessage error="Model ID required: model endpoints deploy <model-id> --job <training-job-id>" />;
-        }
-        if (!jobId) {
-          return <ErrorMessage error="Training job ID required: model endpoints deploy <model-id> --job <training-job-id>" />;
-        }
-        if (jobId.length !== 36) {
-          return (
-            <Box flexDirection="column">
-              <ErrorMessage error="Invalid job ID: must be full UUID (36 characters)" />
-              <Text dimColor>  Provided: {jobId} ({jobId.length} characters)</Text>
-              <Text dimColor>  Tip: Use 'pioneer model artifacts list' and 'pioneer model artifacts trained' to see full job IDs</Text>
-            </Box>
-          );
+          return <ErrorMessage error="Model ID required: model endpoints deploy <model-id> [--job <training-job-id>]" />;
         }
 
         const reason = flags["reason"];
 
+        if (!rawJobId) {
+          if (!isRawModeSupported) {
+            return (
+              <Box flexDirection="column">
+                <ErrorMessage error="Interactive job picker requires a TTY." />
+                <Text>List trained jobs with `pioneer job list` and pass an explicit ID:</Text>
+                <Text dimColor>  pioneer model endpoints deploy {modelId} --job &lt;training-job-id&gt;</Text>
+              </Box>
+            );
+          }
+          const showAll = flags["all"] === "true";
+          return <DeployJobPickerCommand modelId={modelId} reason={reason} showAll={showAll} />;
+        }
+
         return (
-          <ApiCommand
-            action={() =>
-              api.deployTrainingJobToProject(modelId, {
-                training_job_id: jobId,
-                ...(reason ? { reason } : {}),
-              })
-            }
-            successMessage={`Deployment initiated for project ${modelId} from job ${jobId}`}
+          <WithResolvedJobId
+            rawId={rawJobId}
+            render={(jobId) => (
+              <ApiCommand
+                action={async () => {
+                  // Deploy requires the job's project_id to match the target.
+                  // PATCH first to link them; the backend treats a no-op assign
+                  // as success. While we have the job around, capture its
+                  // base_model so we can enrich the deployment record (which
+                  // currently returns base_model=null for training-job deploys).
+                  const jobInfo = await api.getJob(jobId);
+                  const patch = await api.updateTrainingJob(jobId, {
+                    project_id: modelId,
+                  });
+                  if (!patch.ok) {
+                    return patch as api.ApiResult<unknown>;
+                  }
+                  const result = await api.deployTrainingJobToProject(modelId, {
+                    training_job_id: jobId,
+                    ...(reason ? { reason } : {}),
+                  });
+                  if (
+                    result.ok &&
+                    result.data &&
+                    jobInfo.ok &&
+                    jobInfo.data?.base_model &&
+                    !result.data.base_model
+                  ) {
+                    return {
+                      ...result,
+                      data: { ...result.data, base_model: jobInfo.data.base_model },
+                    };
+                  }
+                  return result;
+                }}
+                successMessage={`Deployment initiated for project ${modelId} from job ${jobId}`}
+              />
+            )}
           />
         );
       }
@@ -5370,37 +6283,33 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
         if (!artifactArgs[0]) {
           return <ErrorMessage error="Job ID required: model artifacts download <job-id>" />;
         }
-        const jobId = artifactArgs[0];
-        if (jobId.length !== 36) {
-          return (
-            <Box flexDirection="column">
-              <ErrorMessage error="Invalid job ID: must be full UUID (36 characters)" />
-              <Text dimColor>  Provided: {jobId} ({jobId.length} characters)</Text>
-              <Text dimColor>  Tip: Use 'pioneer model artifacts trained' or 'pioneer model artifacts deployed' to see full job IDs</Text>
-            </Box>
-          );
-        }
-        return <ApiCommand action={() => api.downloadModel(jobId)} />;
+        return (
+          <WithResolvedJobId
+            rawId={artifactArgs[0]}
+            render={(jobId) =>
+              flags.json === "true" ? (
+                <ApiCommand action={() => api.downloadModel(jobId)} />
+              ) : (
+                <ModelArtifactDownloadCommand jobId={jobId} />
+              )
+            }
+          />
+        );
       }
 
       if (artifactsAction === "delete") {
         if (!artifactArgs[0]) {
           return <ErrorMessage error="Model ID required: model artifacts delete <job-id>" />;
         }
-        const jobId = artifactArgs[0];
-        if (jobId.length !== 36) {
-          return (
-            <Box flexDirection="column">
-              <ErrorMessage error="Invalid job ID: must be full UUID (36 characters)" />
-              <Text dimColor>  Provided: {jobId} ({jobId.length} characters)</Text>
-              <Text dimColor>  Tip: Use 'pioneer model artifacts list' to see full job IDs</Text>
-            </Box>
-          );
-        }
         return (
-          <ApiCommand
-            action={() => api.deleteModel(jobId)}
-            successMessage={`Model ${jobId} deleted`}
+          <WithResolvedJobId
+            rawId={artifactArgs[0]}
+            render={(jobId) => (
+              <ApiCommand
+                action={() => api.deleteModel(jobId)}
+                successMessage={`Model ${jobId} deleted`}
+              />
+            )}
           />
         );
       }
@@ -5426,7 +6335,7 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
           if (!artifactArgs[0]) {
             return <ErrorMessage error="Job ID required: model artifacts upload <job-id> --to hf --repo <repo>" />;
           }
-          const jobId = artifactArgs[0];
+          const rawJobId = artifactArgs[0];
           const repo = flags["repo"];
           const hfTokenFlag = flags["hf-token"];
           const isPrivate = flags["private"]?.toLowerCase() === "true";
@@ -5450,15 +6359,20 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
           }
 
           return (
-            <ApiCommand
-              action={() =>
-                api.pushModelToHub(jobId, {
-                  hf_token: hfToken,
-                  repo_id: repo,
-                  private: isPrivate,
-                })
-              }
-              successMessage={`Model uploaded to Hugging Face: ${repo}`}
+            <WithResolvedJobId
+              rawId={rawJobId}
+              render={(jobId) => (
+                <ApiCommand
+                  action={() =>
+                    api.pushModelToHub(jobId, {
+                      hf_token: hfToken,
+                      repo_id: repo,
+                      private: isPrivate,
+                    })
+                  }
+                  successMessage={`Model uploaded to Hugging Face: ${repo}`}
+                />
+              )}
             />
           );
         }