@fastino-ai/pioneer-cli 0.2.6 → 0.2.8

package/src/index.tsx

@@ -4,7 +4,7 @@
  * Uses Ink (React) for terminal UI.
  */
 
-import React, { useState, useEffect } from "react";
+import React, { useState, useEffect, useRef } from "react";
 import { render, Box, Text, useApp, useInput, useStdin, Static } from "ink";
 import Spinner from "ink-spinner";
 import TextInput from "ink-text-input";
@@ -14,6 +14,7 @@ import * as path from "path";
 import {
   getApiKey,
   getBaseUrl,
+  getMleModel,
   saveConfig,
   clearApiKey,
   getHfToken,
@@ -21,7 +22,7 @@ import {
   clearHfToken,
 } from "./config.js";
 import * as api from "./api.js";
-import { ChatApp } from "./chat/ChatApp.js";
+import { WebSocketClient, type HistoryMessage } from "./client/WebSocketClient.js";
 import {
   isEnabled as isTelemetryEnabled,
   hasChosenTelemetry,
@@ -78,6 +79,53 @@ function formatJson(data: unknown): string {
   return JSON.stringify(filterInternalFields(data), null, 2);
 }
 
+function extractDetailMessage(payload: unknown): string | undefined {
+  if (payload === null || payload === undefined) return undefined;
+  if (typeof payload === "string") return payload;
+
+  if (Array.isArray(payload)) {
+    const parts = payload
+      .map((item) => extractDetailMessage(item))
+      .filter((item): item is string => Boolean(item && item.trim()));
+    return parts.length > 0 ? parts.join("; ") : undefined;
+  }
+
+  if (typeof payload === "object") {
+    const record = payload as Record<string, unknown>;
+    if (typeof record.detail === "string") return record.detail;
+    if (record.detail !== undefined) {
+      const detail = extractDetailMessage(record.detail);
+      if (detail) return detail;
+    }
+    if (typeof record.message === "string") return record.message;
+    if (typeof record.error === "string") return record.error;
+    if (typeof record.msg === "string") return record.msg;
+    if (Array.isArray(record.loc) && typeof record.msg === "string") {
+      return `${record.loc.join(".")}: ${record.msg}`;
+    }
+  }
+
+  return undefined;
+}
+
+function formatApiError(error: string): string {
+  const trimmed = error.trim();
+  if (!trimmed) return error;
+
+  const likelyJson =
+    (trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+    (trimmed.startsWith("[") && trimmed.endsWith("]"));
+
+  if (!likelyJson) return error;
+
+  try {
+    const parsed = JSON.parse(trimmed) as unknown;
+    return extractDetailMessage(parsed) || error;
+  } catch {
+    return error;
+  }
+}
+
 /**
  * Parse a dataset string in "name[:version]" format into a DatasetRef object.
  * If version is omitted, defaults to "latest".
@@ -103,9 +151,30 @@ function parseDatasetRef(datasetStr: string): api.DatasetRef | null {
   };
 }
 
-function parseArgs(argv: string[]): { command: string[]; flags: Record<string, string> } {
+const BOOLEAN_FLAGS = new Set([
+  "help",
+  "h",
+  "version",
+  "v",
+  "private",
+  "save",
+  "multi-label",
+  "include-spans",
+  "echo",
+  "include-confidence",
+  "format-results",
+  "reasoning-trace",
+  "use-meta-felix",
+]);
+
+function parseArgs(argv: string[]): {
+  command: string[];
+  flags: Record<string, string>;
+  parseErrors: string[];
+} {
   const command: string[] = [];
   const flags: Record<string, string> = {};
+  const parseErrors: string[] = [];
 
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
@@ -116,7 +185,12 @@ function parseArgs(argv: string[]): { command: string[]; flags: Record<string, s
         flags[key] = next;
         i++;
       } else {
-        flags[key] = "true";
+        if (BOOLEAN_FLAGS.has(key)) {
+          flags[key] = "true";
+        } else {
+          parseErrors.push(`--${key}`);
+          flags[key] = "";
+        }
       }
     } else if (arg.startsWith("-") && arg.length === 2) {
       // Handle short flags like -v, -h
@@ -126,14 +200,37 @@ function parseArgs(argv: string[]): { command: string[]; flags: Record<string, s
         flags[key] = next;
         i++;
       } else {
-        flags[key] = "true";
+        if (BOOLEAN_FLAGS.has(key)) {
+          flags[key] = "true";
+        } else {
+          parseErrors.push(`-${key}`);
+          flags[key] = "";
+        }
       }
     } else {
       command.push(arg);
     }
   }
 
-  return { command, flags };
+  return { command, flags, parseErrors };
+}
+
+type CreateProjectExample = Record<string, unknown> | undefined;
+
+function parseProjectExample(exampleStr: string | undefined): { value?: CreateProjectExample; error?: string } {
+  if (!exampleStr) {
+    return { value: undefined };
+  }
+
+  try {
+    const parsed = JSON.parse(exampleStr) as unknown;
+    if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") {
+      return { error: "--example must be a JSON object" };
+    }
+    return { value: parsed as CreateProjectExample };
+  } catch {
+    return { error: "--example must be valid JSON" };
+  }
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -151,7 +248,7 @@ const Loading: React.FC<{ message?: string }> = ({ message }) => (
 
 const ErrorMessage: React.FC<{ error: string }> = ({ error }) => (
   <Box>
-    <Text color="red">Error: {error}</Text>
+    <Text color="red">Error: {formatApiError(error)}</Text>
   </Box>
 );
 
@@ -470,18 +567,103 @@ const AuthStatus: React.FC = () => {
   const { exit } = useApp();
   const apiKey = getApiKey();
   const baseUrl = getBaseUrl();
+  const keyFromEnv = Boolean(process.env.PIONEER_API_KEY);
+  const [validationState, setValidationState] = useState<
+    "no-key" | "checking" | "valid" | "invalid" | "error"
+  >(apiKey ? "checking" : "no-key");
+  const [validationError, setValidationError] = useState<string | null>(null);
 
   useEffect(() => {
-    setTimeout(() => exit(), 500);
-  }, [exit]);
+    let cancelled = false;
+
+    if (!apiKey) {
+      setValidationState("no-key");
+      setValidationError(null);
+      return () => {
+        cancelled = true;
+      };
+    }
+
+    setValidationState("checking");
+    setValidationError(null);
+
+    (async () => {
+      const result = await api.validateApiKey(apiKey);
+      if (cancelled) return;
+
+      if (result.ok) {
+        setValidationState("valid");
+        return;
+      }
+
+      if (result.status === 401 || result.status === 403) {
+        setValidationState("invalid");
+        setValidationError(result.error ? formatApiError(result.error) : null);
+        return;
+      }
+
+      setValidationState("error");
+      setValidationError(
+        result.error ? formatApiError(result.error) : `HTTP ${result.status}`
+      );
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [apiKey]);
+
+  useEffect(() => {
+    if (validationState === "checking") return;
+    const timeout = setTimeout(() => exit(), validationState === "error" ? 2000 : 1200);
+    return () => clearTimeout(timeout);
+  }, [validationState, exit]);
 
   return (
     <Box flexDirection="column">
       <Text>Base URL: {baseUrl}</Text>
       <Text>
-        Logged in:{" "}
+        Logged in (key configured):{" "}
         <Text color={apiKey ? "green" : "red"}>{apiKey ? "Yes" : "No"}</Text>
       </Text>
+      {apiKey && (
+        <Text dimColor>
+          Key source: {keyFromEnv ? "PIONEER_API_KEY environment variable" : "saved config"}
+        </Text>
+      )}
+      {apiKey && (
+        <Text>
+          Key valid for current backend:{" "}
+          <Text
+            color={
+              validationState === "valid"
+                ? "green"
+                : validationState === "invalid"
+                  ? "red"
+                  : validationState === "error"
+                    ? "yellow"
+                    : "cyan"
+            }
+          >
+            {validationState === "valid"
+              ? "Yes"
+              : validationState === "invalid"
+                ? "No"
+                : validationState === "error"
+                  ? "Unable to verify"
+                  : "Checking..."}
+          </Text>
+        </Text>
+      )}
+      {validationState === "invalid" && (
+        <Text dimColor>
+          This API key is not valid for this backend. Dev and prod/local keys are different.
+        </Text>
+      )}
+      {validationError && validationState !== "checking" && (
+        <Text dimColor>Details: {validationError}</Text>
+      )}
+      {!apiKey && <Text dimColor>Run 'pioneer auth login' to configure an API key.</Text>}
     </Box>
   );
 };
@@ -531,133 +713,870 @@ function ApiCommand<T>({ action, successMessage }: ApiCommandProps<T>) {
   );
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Job Logs Command (prettified output)
-// ─────────────────────────────────────────────────────────────────────────────
+interface AgentInteractiveCommandProps {
+  message: string;
+  conversationId?: string;
+  history?: api.AgentChatHistoryItem[];
+}
 
-function JobLogsCommand({ jobId }: { jobId: string }) {
-  const { exit } = useApp();
-  const [state, setState] = useState<"loading" | "done" | "error">("loading");
-  const [logs, setLogs] = useState<api.TrainingLog[]>([]);
+function toHistoryMessages(
+  items: Array<api.AgentChatHistoryItem | api.ChatSessionMessage>
+): HistoryMessage[] {
+  return items
+    .filter((item) => Boolean(item && typeof item.content === "string" && typeof item.role === "string"))
+    .map((item) => {
+      const message: HistoryMessage = {
+        role: item.role as "user" | "assistant" | "tool" | string,
+        content: item.content,
+      };
+
+      const sessionMessage = item as api.ChatSessionMessage;
+      if (sessionMessage.tool_call_id) {
+        message.tool_call_id = sessionMessage.tool_call_id;
+      }
+      if (sessionMessage.tool_calls && Array.isArray(sessionMessage.tool_calls)) {
+        message.tool_calls = sessionMessage.tool_calls.filter((call) => Boolean(call));
+      }
+
+      return message;
+    });
+}
+
+function AgentInteractiveCommand({ message, conversationId, history }: AgentInteractiveCommandProps) {
+  const [state, setState] = useState<"connecting" | "running" | "done" | "error">("connecting");
+  const [stream, setStream] = useState("");
   const [error, setError] = useState("");
+  const [statusHint, setStatusHint] = useState("");
+  const [client] = useState(() => new WebSocketClient());
+  const doneHistory = useRef<HistoryMessage[] | undefined>(undefined);
 
   useEffect(() => {
-    (async () => {
-      const result = await api.getJobLogs(jobId);
-      if (result.ok && result.data) {
-        setLogs(result.data.logs || []);
+    let isActive = true;
+    const model = getMleModel();
+    let wsSessionId: string | undefined;
+    const finish = (code: number) => {
+      setTimeout(() => process.exit(code), 300);
+    };
+    const getLatestAssistantContent = (
+      messages: HistoryMessage[] | undefined
+    ): string => {
+      if (!messages?.length) {
+        return "";
+      }
+      const lastAssistant = [...messages]
+        .reverse()
+        .find(
+          (entry) =>
+            entry.role === "assistant" && typeof entry.content === "string" && entry.content.trim()
+        );
+      return lastAssistant?.content?.trim() ?? "";
+    };
+    let streamBuffer = "";
+    const appendStream = (content: string) => {
+      streamBuffer += content;
+      setStream(streamBuffer);
+    };
+    const runAgentFallback = async (
+      fallbackHistory: HistoryMessage[],
+      sessionIdHint?: string
+    ) => {
+      const plainHistory: api.AgentChatHistoryItem[] = fallbackHistory.map((entry) => ({
+        role: entry.role,
+        content: entry.content,
+      }));
+      const fallbackTimeout = (ms: number) =>
+        new Promise<never>((_, reject) => {
+          setTimeout(() => reject(new Error(`REST fallback timed out after ${ms}ms`)), ms);
+        });
+      setState("running");
+      setStatusHint("WebSocket unavailable, using REST fallback...");
+      try {
+        const runRequest = (sessionIdOverride?: string) => {
+          const requestConversationId = sessionIdOverride;
+          return Promise.race([
+            api.agentChat({
+              message,
+              ...(requestConversationId ? { conversation_id: requestConversationId } : {}),
+              ...(plainHistory.length ? { history: plainHistory } : {}),
+            }),
+            fallbackTimeout(8000),
+          ]);
+        };
+
+        const attempts = Array.from(
+          new Set([sessionIdHint, conversationId, undefined] as Array<string | undefined>)
+        );
+        let result: Awaited<ReturnType<typeof runRequest>> | undefined;
+        let lastError: string | undefined;
+
+        for (const attemptConversationId of attempts) {
+          const attemptResult = await runRequest(attemptConversationId);
+          if (attemptResult.ok && attemptResult.data?.answer) {
+            result = attemptResult;
+            break;
+          }
+          if (!attemptResult.ok && attemptResult.error) {
+            lastError = attemptResult.error;
+          }
+        }
+
+        if (!result) {
+          if (lastError) {
+            throw new Error(lastError || "Agent fallback request failed.");
+          }
+          result = {
+            ok: false,
+            status: 0,
+            error: "Agent fallback request failed.",
+          };
+        }
+
+        if (!isActive) {
+          return;
+        }
+        if (!result.ok) {
+          throw new Error(lastError || result.error || "Agent fallback request failed.");
+        }
+        setStream(result.data?.answer ?? "");
+        if (!result.data?.answer) {
+          setError("Agent returned no response content.");
+          setState("error");
+          setTimeout(() => process.exit(1), 300);
+          return;
+        }
+        setStatusHint("");
         setState("done");
-      } else {
-        setError(result.error ?? "Unknown error");
+        setTimeout(() => process.exit(0), 300);
+      } catch (fallbackError) {
+        if (!isActive) {
+          return;
+        }
+        const fallbackErrorMessage =
+          fallbackError instanceof Error
+            ? fallbackError.message
+            : String(fallbackError);
+        if (fallbackErrorMessage.includes("REST fallback timed out")) {
+          setError(
+            "Interactive mode timed out. Agent runtime is not reachable in this environment.\n" +
+            "Retry in standard mode (no mode flag needed), or set up a reachable WSS endpoint."
+          );
+        } else {
+          setError(fallbackErrorMessage);
+        }
         setState("error");
+        setTimeout(() => process.exit(1), 300);
       }
-      setTimeout(() => exit(), 500);
-    })();
-  }, [jobId, exit]);
+    };
+    const start = async () => {
+      doneHistory.current = undefined;
+      const mergedHistory: HistoryMessage[] = [];
+      let commandCompleted = false;
+      let responseTimeoutId: ReturnType<typeof setTimeout> | undefined;
+      const fallbackOnTimeout = async () => {
+        if (!isActive || commandCompleted) {
+          return;
+        }
+        commandCompleted = true;
+        if (responseTimeoutId) {
+          clearTimeout(responseTimeoutId);
+        }
+        client.disconnect();
+        await runAgentFallback(mergedHistory, wsSessionId);
+      };
+
+      const connectWithTimeout = async (ms: number): Promise<void> => {
+        return new Promise<void>((resolve, reject) => {
+          const timeoutId = setTimeout(() => {
+            reject(new Error(`WebSocket connect timed out after ${ms}ms`));
+          }, ms);
+
+          client.connect()
+            .then(() => {
+              clearTimeout(timeoutId);
+              resolve();
+            })
+            .catch((err) => {
+              clearTimeout(timeoutId);
+              reject(err);
+            });
+        });
+      };
+      const withTimeout = async <T,>(promise: Promise<T>, ms: number, label: string): Promise<T> => {
+        return new Promise<T>((resolve, reject) => {
+          const timeoutId = setTimeout(() => {
+            reject(new Error(`${label} timed out after ${ms}ms`));
+          }, ms);
+
+          promise.then(
+            (value) => {
+              clearTimeout(timeoutId);
+              resolve(value);
+            },
+            (error) => {
+              clearTimeout(timeoutId);
+              reject(error);
+            }
+          );
+        });
+      };
+
+      try {
+        if (conversationId) {
+          setStatusHint(`Loading conversation ${conversationId}...`);
+          const sessionResult = await api.getAgentSession(conversationId);
+          if (!sessionResult.ok) {
+            throw new Error(
+              sessionResult.error ??
+                `Could not load conversation ${conversationId}. Please check the conversation id and credentials.`
+            );
+          }
 
-  if (state === "loading") {
-    return <Loading />;
-  }
+          const session = sessionResult.data;
+          if (session?.messages?.length) {
+            mergedHistory.push(...toHistoryMessages(session.messages));
+          }
+        }
+
+        if (history?.length) {
+          mergedHistory.push(...toHistoryMessages(history));
+        }
+
+        const isWsHealthy = await withTimeout(client.health(), 3000, "WebSocket health check");
+        if (!isWsHealthy) {
+          throw new Error("WebSocket endpoint is not reachable.");
+        }
+
+        await connectWithTimeout(5000);
+        if (!isActive) {
+          return;
+        }
+
+        setStatusHint("");
+        setState("running");
+        responseTimeoutId = setTimeout(() => {
+          void fallbackOnTimeout();
+        }, 5000);
+
+        await client.chat(message, {
+          onStream: (content) => {
+            appendStream(content);
+          },
+          onAssistantMessage: (content) => {
+            appendStream(content);
+          },
+          onToolCall: async (call) => {
+            setStatusHint(`Tool requested: ${call.tool}`);
+            return "CLI does not execute tool calls yet.";
+          },
+          onError: (err) => {
+            if (!isActive) return;
+            setError(err.message || "WebSocket agent error");
+            setState("error");
+            finish(1);
+          },
+          onDone: (messages, sessionId) => {
+            if (!isActive) return;
+            commandCompleted = true;
+            if (responseTimeoutId) {
+              clearTimeout(responseTimeoutId);
+            }
+            doneHistory.current = messages;
+            wsSessionId = sessionId;
+          },
+        }, {
+          history: mergedHistory,
+          ...(model ? { config: { model } } : {}),
+          fileReferences: [],
+        });
+        if (!streamBuffer.trim()) {
+          const doneAssistantContent = getLatestAssistantContent(doneHistory.current);
+          if (doneAssistantContent) {
+            appendStream(doneAssistantContent);
+            setState("done");
+            finish(0);
+            return;
+          }
+
+          setStatusHint("No assistant content in websocket response; retrying via REST fallback.");
+          await runAgentFallback(mergedHistory, wsSessionId);
+          return;
+        }
+
+        setState("done");
+        finish(0);
+      } catch (err) {
+        if (!isActive) return;
+        commandCompleted = true;
+        if (responseTimeoutId) {
+          clearTimeout(responseTimeoutId);
+        }
+        const rawError = err instanceof Error ? err.message : String(err);
+        const unavailable =
+          rawError.includes("WebSocket") ||
+          rawError.includes("websocket") ||
+          rawError.includes("timed out") ||
+          rawError.includes("not reachable");
+
+        if (unavailable) {
+          const wsUrl = client.getWebSocketUrl();
+          setStatusHint(`WebSocket timed out at ${wsUrl}. Falling back to REST.`);
+          await runAgentFallback(mergedHistory);
+          return;
+        }
+        setError(
+          rawError || "Agent runtime unavailable. Retry by running `agent` in standard mode (omit --mode)."
+        );
+        setState("error");
+        finish(1);
+      }
+    };
+    start();
+
+    return () => {
+      isActive = false;
+      if (state !== "done" && state !== "error") {
+        client.disconnect();
+      }
+    };
+  }, [client, conversationId, history, message]);
+
+  useEffect(() => {
+    if (state === "done") {
+      setTimeout(() => process.exit(0), 300);
+    } else if (state === "error") {
+      setTimeout(() => process.exit(1), 300);
+    }
+  }, [state]);
 
   if (state === "error") {
-    return <ErrorMessage error={error} />;
+    return (
+      <Box flexDirection="column">
+        <ErrorMessage error={error || "WebSocket agent command failed."} />
+      </Box>
+    );
   }
 
-  const formatLogEntry = (log: api.TrainingLog): string => {
-    const ts = new Date(log.timestamp).toLocaleTimeString();
-    return `[${ts}] [${log.level}] ${log.message}`;
-  };
+  if (state === "connecting") {
+    return (
+      <Box flexDirection="column">
+        <Loading message={statusHint || "Connecting to agent runtime..."} />
+      </Box>
+    );
+  }
 
   return (
     <Box flexDirection="column">
-      {logs.length === 0 ? (
-        <Text dimColor>No logs available</Text>
+      {state === "running" ? (
+        <Loading message={stream ? "Streaming response..." : "Waiting for agent response..."} />
       ) : (
-        logs.map((log) => (
-          <Text key={log.id} color={log.level === "ERROR" ? "red" : log.level === "WARNING" ? "yellow" : undefined}>
-            {formatLogEntry(log)}
-          </Text>
-        ))
+        <Success message="Agent response received" />
       )}
+      {stream ? <Text>{stream}</Text> : <Text dimColor>No response content yet.</Text>}
+      {conversationId ? <Text dimColor>Conversation: {conversationId}</Text> : null}
     </Box>
   );
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Local Dataset Helpers
-// ─────────────────────────────────────────────────────────────────────────────
-
-const DATASETS_DIR = path.join(process.cwd(), "datasets");
+type AutoAgentTurnRole = "user" | "assistant";
 
-function ensureDatasetsDir(): void {
-  if (!fs.existsSync(DATASETS_DIR)) {
-    fs.mkdirSync(DATASETS_DIR, { recursive: true });
-  }
+interface AutoAgentTurn {
+  role: AutoAgentTurnRole;
+  content: string;
 }
 
-interface LocalDataset {
-  id: string;
-  name: string;
-  path: string;
-  type: string;
-  size: number;
-  sample_size: number;
-  created_at: string;
-  source: "local";
+function formatAutoAgentTurn(turn: AutoAgentTurn): string {
+  const prefix = turn.role === "user" ? "You: " : "Agent: ";
+  return `${prefix}${turn.content}`;
 }
 
-function listLocalDatasets(): LocalDataset[] {
-  if (!fs.existsSync(DATASETS_DIR)) {
-    return [];
-  }
+function AutoAgentInteractiveSession({
+  conversationId: initialConversationId,
+  history,
+  mode,
+  firstMessage,
+}: {
+  conversationId?: string;
+  history?: api.AgentChatHistoryItem[];
+  mode: "standard" | "research";
+  firstMessage?: string;
+}) {
+  const [input, setInput] = useState("");
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState("");
+  const [statusHint, setStatusHint] = useState("Start typing...");
+  const [conversationId, setConversationId] = useState(initialConversationId);
+  const [historyState, setHistoryState] = useState<api.AgentChatHistoryItem[]>(history ?? []);
+  const [turns, setTurns] = useState<AutoAgentTurn[]>(
+    (history ?? []).map((entry) =>
+      entry.role === "assistant"
+        ? { role: "assistant", content: entry.content }
+        : { role: "user", content: entry.content }
+    )
+  );
+  const didSeedFirstMessage = useRef(false);
 
-  const files = fs.readdirSync(DATASETS_DIR).filter((f) => f.endsWith(".json"));
-  return files.map((filename) => {
-    const filePath = path.join(DATASETS_DIR, filename);
-    const stats = fs.statSync(filePath);
-    let data: unknown[] = [];
-    let type = "unknown";
+  const runAutoTurn = async (rawMessage: string) => {
+    const trimmed = rawMessage.trim();
+    if (!trimmed || isLoading) {
+      return;
+    }
 
-    try {
-      const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-      data = Array.isArray(content) ? content : content.data ?? [];
-      const firstItem = data[0] as Record<string, unknown> | undefined;
-      type = content.task_type ?? (firstItem?.spans ? "ner" : firstItem?.label ? "classification" : "custom");
-    } catch {
-      // Ignore parse errors
+    const nextHistory: api.AgentChatHistoryItem[] = [
+      ...historyState,
+      { role: "user", content: trimmed },
+    ];
+    setHistoryState(nextHistory);
+    setTurns((current) => [...current, { role: "user", content: trimmed }]);
+    setInput("");
+    setError("");
+    setIsLoading(true);
+    setStatusHint("Thinking...");
+
+    const result = await api.agentChat({
+      message: trimmed,
+      ...(conversationId ? { conversation_id: conversationId } : {}),
+      ...(nextHistory.length ? { history: nextHistory } : {}),
+    });
+
+    if (!result.ok) {
+      if (
+        result.status === 403 &&
+        (result.error ?? "").toLowerCase().includes("deep research mode")
+      ) {
+        setError(
+          "Research mode requires a Pro subscription.\n" +
+            "To run this command, upgrade your account to Pro and retry.\n" +
+            "Go to Manage subscription under Billing at https://agent.pioneer.ai/account."
+        );
+      } else {
+        setError(result.error || "Agent request failed.");
+      }
+      setIsLoading(false);
+      setStatusHint("Ready for next message.");
+      return;
     }
 
-    return {
-      id: filename.replace(".json", ""),
-      name: filename.replace(".json", ""),
-      path: filePath,
-      type,
-      size: stats.size,
-      sample_size: data.length,
-      created_at: stats.birthtime.toISOString(),
-      source: "local" as const,
-    };
-  });
-}
+    const answer = result.data.answer?.trim() || "No response content yet.";
+    const nextConversationId = result.data.conversation_id || conversationId;
 
-function saveLocalDataset(name: string, data: unknown, type: string): string {
-  ensureDatasetsDir();
-  const filename = `${name.replace(/[^a-zA-Z0-9-_]/g, "_")}.json`;
-  const filePath = path.join(DATASETS_DIR, filename);
-  fs.writeFileSync(filePath, JSON.stringify({ task_type: type, data }, null, 2));
-  return filePath;
-}
+    setConversationId(nextConversationId);
+    setTurns((current) => [...current, { role: "assistant", content: answer }]);
+    setHistoryState((current) => [...current, { role: "assistant", content: answer }]);
+    setStatusHint("Ready for next message.");
+    setIsLoading(false);
+  };
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Generate Command (saves to local file when --save is false)
-// ─────────────────────────────────────────────────────────────────────────────
+  useEffect(() => {
+    if (!firstMessage || didSeedFirstMessage.current) {
+      return;
+    }
 
-interface GenerateCommandProps<T> {
-  action: () => Promise<api.ApiResult<T>>;
-  datasetName: string;
-  datasetType: string;
-  saveToRemote: boolean;
-}
+    didSeedFirstMessage.current = true;
+    void runAutoTurn(firstMessage);
+  }, [firstMessage]);
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>Agent mode selected.</Text>
+      <Text>
+        Mode: {mode === "research" ? "research" : "standard"}{" "}
+        {conversationId ? `(conversation ${conversationId})` : "(new conversation)"}
+      </Text>
+      <Box flexDirection="column" marginTop={1}>
+        {turns.map((entry, idx) => (
+          <Text key={`agent-turn-${idx}`} dimColor={entry.role === "user"}>
+            {formatAutoAgentTurn(entry)}
+          </Text>
+        ))}
+      </Box>
+      <Box marginTop={1}>
+        {isLoading ? <Loading message={statusHint} /> : <Text color="cyan">&gt; </Text>}
+        {isLoading ? null : (
+          <TextInput
+            value={input}
+            onChange={setInput}
+            onSubmit={runAutoTurn}
+          />
+        )}
+      </Box>
+      {error && (
+        <Box marginTop={1}>
+          <ErrorMessage error={error} />
+        </Box>
+      )}
+      <Text dimColor>Type Ctrl+C to exit.</Text>
+    </Box>
+  );
+}
+
+function AgentInteractivePrompt({
+  conversationId,
+  history,
+  mode,
+}: {
+  conversationId?: string;
+  history?: api.AgentChatHistoryItem[];
+  mode?: "standard" | "research";
+}) {
+  const [input, setInput] = useState("");
+  const [isReady, setReady] = useState(false);
+  const [message, setMessage] = useState("");
+  const { isRawModeSupported } = useStdin();
+  const shouldExitImmediately = !isRawModeSupported;
+
+  useEffect(() => {
+    if (!shouldExitImmediately) {
+      return;
+    }
+
+    const timeout = setTimeout(() => {
+      process.exit(0);
+    }, 75);
+
+    return () => clearTimeout(timeout);
+  }, [shouldExitImmediately]);
+
+  if (!isRawModeSupported) {
+    return (
+      <Box flexDirection="column">
+        <ErrorMessage error="Interactive input is not supported in this terminal." />
+        <Text>Use interactive mode for this environment:</Text>
+        <Text dimColor>{`  agent${mode === "research" ? " --mode research" : ""}`}</Text>
+        <Text dimColor>  agent --help</Text>
+      </Box>
+    );
+  }
+
+  if (!isReady) {
+    return (
+      <Box flexDirection="column">
+        <Text bold>Agent mode selected.</Text>
+        <Text>Type your message and press enter to start:</Text>
+        <Box>
+          <Text color="cyan">&gt; </Text>
+          <TextInput
+            value={input}
+            onChange={setInput}
+            onSubmit={(value) => {
+              const trimmed = value.trim();
+              if (!trimmed) {
+                return;
+              }
+              setMessage(trimmed);
+              setReady(true);
+            }}
+          />
+        </Box>
+        <Text dimColor>Type Ctrl+C to cancel.</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <AutoAgentInteractiveSession
+      conversationId={conversationId}
+      history={history}
+      mode={mode === "research" ? "research" : "standard"}
+      firstMessage={message}
+    />
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Interactive Model Create Selector
+// ─────────────────────────────────────────────────────────────────────────────
+
+function ModelCreateInteractive({
+  name,
+  icon,
+  repo,
+  description,
+  example,
+}: {
+  name?: string;
+  icon?: string;
+  repo?: string;
+  description?: string;
+  example?: CreateProjectExample;
+}) {
+  const [query, setQuery] = useState("");
+  const [models, setModels] = useState<api.BaseModelInfo[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState("");
+  const [selectedModelId, setSelectedModelId] = useState<string | null>(null);
+  const [highlightIndex, setHighlightIndex] = useState(0);
+
+  useEffect(() => {
+    (async () => {
+      const result = await api.listBaseModels();
+      if (!result.ok) {
+        setError(result.error ?? "Unable to load base models.");
+        setLoading(false);
+        return;
+      }
+      const modelsData = result.data
+        ? Array.isArray((result.data as api.BaseModelsResponse).models)
+          ? (result.data as api.BaseModelsResponse).models
+          : (result.data as api.BaseModelInfo[])
+        : [];
+      setModels(modelsData.sort((a, b) => a.id.localeCompare(b.id)));
+      setLoading(false);
+    })();
+  }, []);
+
+  const normalizedQuery = query.trim().toLowerCase();
+  const matchingModels = models.filter((model) => {
+    const text = `${model.id} ${model.name ?? ""} ${model.label ?? ""} ${model.description ?? ""}`.toLowerCase();
+    return normalizedQuery.length === 0 || text.includes(normalizedQuery);
+  });
+  const topMatches = matchingModels;
+  useEffect(() => {
+    setHighlightIndex(0);
+  }, [query]);
+
+  const resolveModelId = (queryValue: string): string | undefined => {
+    const trimmed = queryValue.trim();
+    if (!trimmed) {
+      return topMatches[highlightIndex]?.id;
+    }
+    const exact = models.find(
+      (model) => model.id.toLowerCase() === trimmed.toLowerCase()
+    );
+    if (exact) return exact.id;
+    return topMatches[highlightIndex]?.id;
+  };
+
+  useEffect(() => {
+    if (highlightIndex >= topMatches.length) {
+      setHighlightIndex(topMatches.length > 0 ? topMatches.length - 1 : 0);
+    }
+  }, [highlightIndex, topMatches.length]);
+
+  useInput((_, key) => {
+    if (!topMatches.length) return;
+    if (key.upArrow) {
+      setHighlightIndex((idx) => (idx === 0 ? topMatches.length - 1 : idx - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setHighlightIndex((idx) => (idx === topMatches.length - 1 ? 0 : idx + 1));
+      return;
+    }
+    if (key.return) {
+      const resolvedModel = resolveModelId(query);
+      if (!resolvedModel) {
+        setError("No matching models found. Refine your search and try again.");
+        return;
+      }
+      setSelectedModelId(resolvedModel);
+    }
+  });
+
+  if (error) {
+    return (
+      <Box flexDirection="column">
+        <ErrorMessage error={error} />
+        <Text> </Text>
+        <Text dimColor>Try again with --model explicitly, or check your API connectivity.</Text>
+      </Box>
+    );
+  }
+
+  if (selectedModelId) {
+    return (
+      <ApiCommand
+        action={() =>
+          api.createProject({
+            name: name ?? selectedModelId,
+            ...(icon ? { icon } : {}),
+            ...(repo ? { repo } : {}),
+            ...(description ? { description } : {}),
+            active_model_id: selectedModelId,
+            selected_model_id: selectedModelId,
+            ...(example ? { example } : {}),
+          })
+        }
+        successMessage="Model entry created"
+      />
+    );
+  }
+
+  if (loading) {
+    return <Loading message="Loading supported models..." />;
+  }
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>Choose a base model for this entry</Text>
+      <Text>Type to filter. Use ↑/↓ to navigate and Enter to select.</Text>
+      <Text dimColor>Type any part of model id, name, label, or description.</Text>
+      <Text> </Text>
+      <TextInput
+        value={query}
+        onChange={(value) => setQuery(value)}
+        onSubmit={(value) => {
+          const resolvedModel = resolveModelId(value);
+          if (!resolvedModel) {
+            setError("No matching models found. Refine your search and try again.");
+            return;
+          }
+          setSelectedModelId(resolvedModel);
+        }}
+        placeholder="e.g. qwen/qwen3-8b"
+      />
+      <Text> </Text>
+      {topMatches.length === 0 ? (
+        <Text dimColor>No matching models found.</Text>
+      ) : (
+        <Box flexDirection="column">
+          {topMatches.map((model, index) => {
+            const suffix = [model.label, model.task_type, model.type].filter(Boolean).join(" · ");
+            const modelLine = `${model.id}${suffix ? ` (${suffix})` : ""}`;
+            const isHighlighted = index === highlightIndex;
+            return (
+              <Text key={model.id} color={isHighlighted ? "cyan" : undefined} bold={isHighlighted}>
+                {isHighlighted ? "▶ " : "  "}
+                {modelLine}
+              </Text>
+            );
+          })}
+        </Box>
+      )}
+      <Text> </Text>
+      <Text dimColor>Press Enter to select the highlighted model.</Text>
+      <Text dimColor> </Text>
+      <Text dimColor>Tip: You can still run {"model endpoints create --model \"<base-model-id>\""} for exact model ids.</Text>
+    </Box>
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Job Logs Command (prettified output)
+// ─────────────────────────────────────────────────────────────────────────────
+
+function JobLogsCommand({ jobId }: { jobId: string }) {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done" | "error">("loading");
+  const [logs, setLogs] = useState<api.TrainingLog[]>([]);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    (async () => {
+      const result = await api.getJobLogs(jobId);
+      if (result.ok && result.data) {
+        setLogs(result.data.logs || []);
+        setState("done");
+      } else {
+        setError(result.error ?? "Unknown error");
+        setState("error");
+      }
+      setTimeout(() => exit(), 500);
+    })();
+  }, [jobId, exit]);
+
+  if (state === "loading") {
+    return <Loading />;
+  }
+
+  if (state === "error") {
+    return <ErrorMessage error={error} />;
+  }
+
+  const formatLogEntry = (log: api.TrainingLog): string => {
+    const ts = new Date(log.timestamp).toLocaleTimeString();
+    return `[${ts}] [${log.level}] ${log.message}`;
+  };
+
+  return (
+    <Box flexDirection="column">
+      {logs.length === 0 ? (
+        <Text dimColor>No logs available</Text>
+      ) : (
+        logs.map((log) => (
+          <Text key={log.id} color={log.level === "ERROR" ? "red" : log.level === "WARNING" ? "yellow" : undefined}>
+            {formatLogEntry(log)}
+          </Text>
+        ))
+      )}
+    </Box>
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Local Dataset Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+const DATASETS_DIR = path.join(process.cwd(), "datasets");
+
+function ensureDatasetsDir(): void {
+  if (!fs.existsSync(DATASETS_DIR)) {
+    fs.mkdirSync(DATASETS_DIR, { recursive: true });
+  }
+}
+
+interface LocalDataset {
+  id: string;
+  name: string;
+  path: string;
+  type: string;
+  size: number;
+  sample_size: number;
+  created_at: string;
+  source: "local";
+}
+
+function listLocalDatasets(): LocalDataset[] {
+  if (!fs.existsSync(DATASETS_DIR)) {
+    return [];
+  }
+
+  const files = fs.readdirSync(DATASETS_DIR).filter((f) => f.endsWith(".json"));
+  return files.map((filename) => {
+    const filePath = path.join(DATASETS_DIR, filename);
+    const stats = fs.statSync(filePath);
+    let data: unknown[] = [];
+    let type = "unknown";
+
+    try {
+      const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      data = Array.isArray(content) ? content : content.data ?? [];
+      const firstItem = data[0] as Record<string, unknown> | undefined;
+      type = content.task_type ?? (firstItem?.spans ? "ner" : firstItem?.label ? "classification" : "custom");
+    } catch {
+      // Ignore parse errors
+    }
+
+    return {
+      id: filename.replace(".json", ""),
+      name: filename.replace(".json", ""),
+      path: filePath,
+      type,
+      size: stats.size,
+      sample_size: data.length,
+      created_at: stats.birthtime.toISOString(),
+      source: "local" as const,
+    };
+  });
+}
+
+function saveLocalDataset(name: string, data: unknown, type: string): string {
+  ensureDatasetsDir();
+  const filename = `${name.replace(/[^a-zA-Z0-9-_]/g, "_")}.json`;
+  const filePath = path.join(DATASETS_DIR, filename);
+  fs.writeFileSync(filePath, JSON.stringify({ task_type: type, data }, null, 2));
+  return filePath;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Generate Command (saves to local file when --save is false)
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface GenerateCommandProps<T> {
+  action: () => Promise<api.ApiResult<T>>;
+  datasetName: string;
+  datasetType: string;
+  saveToRemote: boolean;
+}
 
 interface GenerateResult {
   data?: unknown[];
@@ -823,173 +1742,15 @@ function DatasetListCommand() {
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Competition List Command
+// Job Create Command (with auto-upload for local datasets)
 // ─────────────────────────────────────────────────────────────────────────────
 
-function CompetitionListCommand() {
-  const { exit } = useApp();
-  const [state, setState] = useState<"loading" | "done" | "error">("loading");
-  const [competitions, setCompetitions] = useState<api.CompetitionInfo[]>([]);
-  const [error, setError] = useState("");
-
-  useEffect(() => {
-    (async () => {
-      const result = await api.listCompetitions();
-      if (result.ok && result.data) {
-        setCompetitions(result.data.competitions || []);
-        setState("done");
-      } else {
-        setError(result.error ?? "Unknown error");
-        setState("error");
-      }
-      setTimeout(() => exit(), 500);
-    })();
-  }, [exit]);
-
-  if (state === "loading") {
-    return <Loading message="Loading competitions..." />;
-  }
-
-  if (state === "error") {
-    return <ErrorMessage error={error} />;
-  }
-
-  if (competitions.length === 0) {
-    return <Text dimColor>No active competitions found.</Text>;
-  }
-
-  return (
-    <Box flexDirection="column">
-      <Text bold color="cyan">Active Competitions ({competitions.length})</Text>
-      <Text> </Text>
-      {competitions.map((comp, idx) => (
-        <Box key={comp.dataset_id} flexDirection="column" marginBottom={1}>
-          <Text bold color="yellow">
-            {idx + 1}. {comp.dataset_name}
-          </Text>
-          <Text>
-            {"  "}Type: <Text color="magenta">{comp.dataset_type}</Text>
-            {"  "}Samples: <Text color="blue">{comp.sample_count ?? "N/A"}</Text>
-            {"  "}Entries: <Text color="green">{comp.total_entries}</Text>
-          </Text>
-          {comp.description && (
-            <Text dimColor>{"  "}{comp.description}</Text>
-          )}
-          {comp.labels && comp.labels.length > 0 && (
-            <Text>{"  "}Labels: <Text color="cyan">{comp.labels.join(", ")}</Text></Text>
-          )}
-          {comp.winner && (
-            <Text>
-              {"  "}Winner: <Text color="green" bold>{comp.winner.display_name}</Text>
-              {" "}(F1: <Text color="yellow">{comp.winner.f1_score.toFixed(4)}</Text>)
-            </Text>
-          )}
-          <Text dimColor>{"  "}ID: {comp.dataset_id}</Text>
-        </Box>
-      ))}
-    </Box>
-  );
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Leaderboard Command
-// ─────────────────────────────────────────────────────────────────────────────
-
-function LeaderboardCommand({ datasetId, limit }: { datasetId: string; limit?: number }) {
-  const { exit } = useApp();
-  const [state, setState] = useState<"loading" | "done" | "error">("loading");
-  const [data, setData] = useState<api.LeaderboardEntriesResponse | null>(null);
-  const [error, setError] = useState("");
-
-  useEffect(() => {
-    (async () => {
-      const result = await api.getLeaderboardEntries(datasetId, limit);
-      if (result.ok && result.data) {
-        setData(result.data);
-        setState("done");
-      } else {
-        setError(result.error ?? "Unknown error");
-        setState("error");
-      }
-      setTimeout(() => exit(), 500);
-    })();
-  }, [datasetId, limit, exit]);
-
-  if (state === "loading") {
-    return <Loading message="Loading leaderboard..." />;
-  }
-
-  if (state === "error") {
-    return <ErrorMessage error={error} />;
-  }
-
-  if (!data || data.entries.length === 0) {
-    return (
-      <Box flexDirection="column">
-        <Text bold color="cyan">Leaderboard: {data?.dataset_name ?? datasetId}</Text>
-        <Text dimColor>  No entries yet. Be the first to submit!</Text>
-      </Box>
-    );
-  }
-
-  return (
-    <Box flexDirection="column">
-      <Text bold color="cyan">Leaderboard: {data.dataset_name} ({data.total_entries} entries)</Text>
-      <Text> </Text>
-      {/* Header */}
-      <Box>
-        <Box width={6}><Text bold dimColor>Rank</Text></Box>
-        <Box width={22}><Text bold dimColor>Name</Text></Box>
-        <Box width={22}><Text bold dimColor>Model</Text></Box>
-        <Box width={10}><Text bold dimColor>F1</Text></Box>
-        <Box width={10}><Text bold dimColor>Precision</Text></Box>
-        <Box width={10}><Text bold dimColor>Recall</Text></Box>
-      </Box>
-      {/* Entries */}
-      {data.entries.map((entry, idx) => {
-        const rank = entry.rank ?? idx + 1;
-        const isFirst = rank === 1;
-        return (
-          <Box key={entry.id}>
-            <Box width={6}>
-              <Text color={isFirst ? "yellow" : undefined} bold={isFirst}>
-                {isFirst ? `#${rank}` : `#${rank}`}
-              </Text>
-            </Box>
-            <Box width={22}>
-              <Text color={isFirst ? "yellow" : undefined} bold={isFirst}>
-                {entry.display_name.substring(0, 20)}
-              </Text>
-            </Box>
-            <Box width={22}>
-              <Text color="cyan">{entry.model_name.substring(0, 20)}</Text>
-            </Box>
-            <Box width={10}>
-              <Text color="green" bold>{entry.f1_score.toFixed(4)}</Text>
-            </Box>
-            <Box width={10}>
-              <Text>{entry.precision_score?.toFixed(4) ?? "N/A"}</Text>
-            </Box>
-            <Box width={10}>
-              <Text>{entry.recall_score?.toFixed(4) ?? "N/A"}</Text>
-            </Box>
-          </Box>
-        );
-      })}
-    </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 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;
@@ -1607,11 +2368,54 @@ function DeployedModelCard({ model, index }: DeployedModelCardProps) {
   );
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Registered Model (Project) Visualization Component
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface ProjectModelCardProps {
+  model: api.ProjectResponse;
+  index: number;
+}
+
+function ProjectModelCard({ model, index }: 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" });
+  };
+
+  return (
+    <Box flexDirection="column" marginTop={index > 0 ? 0 : 0}>
+      <Box>
+        <Text bold color="green">●</Text>
+        <Text> </Text>
+        <Box width={28}>
+          <Text bold color="cyan">{model.name?.substring(0, 26) || "Unnamed"}</Text>
+        </Box>
+        <Box width={38}>
+          <Text dimColor>{model.id}</Text>
+        </Box>
+        <Box width={24}>
+          <Text color="magenta">{model.selected_model_id || "N/A"}</Text>
+        </Box>
+        <Box width={18}>
+          <Text dimColor>{formatDateShort(model.created_at)}</Text>
+        </Box>
+      </Box>
+      {model.description && (
+        <Box marginLeft={2}>
+          <Text dimColor>{model.description}</Text>
+        </Box>
+      )}
+    </Box>
+  );
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Model List Command
 // ─────────────────────────────────────────────────────────────────────────────
 
-type ModelListFilter = "all" | "trained" | "deployed";
+type ModelListFilter = "registered" | "trained" | "deployed" | "artifacts";
 
 interface ModelListCommandProps {
   filter: ModelListFilter;
@@ -1645,11 +2449,42 @@ function ModelListCommand({ filter }: ModelListCommandProps) {
     return <ErrorMessage error={error} />;
   }
 
-  const showDeployed = filter === "all" || filter === "deployed";
-  const showTrained = filter === "all" || filter === "trained";
+  const showProjects = filter === "registered";
+  const showDeployed = filter === "deployed" || filter === "artifacts";
+  const showTrained = filter === "trained" || filter === "artifacts";
 
   return (
     <Box flexDirection="column">
+      {showProjects && (
+        <>
+          <Text bold color="cyan">Model Entries ({data?.projects.length ?? 0})</Text>
+          {data?.projects.length === 0 ? (
+            <Text dimColor>  No model entries</Text>
+          ) : (
+            <Box flexDirection="column" marginTop={1}>
+              <Box marginBottom={0}>
+                <Text bold dimColor>  </Text>
+                <Box width={28}>
+                  <Text bold dimColor>Name</Text>
+                </Box>
+                <Box width={38}>
+                  <Text bold dimColor>Model ID</Text>
+                </Box>
+                <Box width={24}>
+                  <Text bold dimColor>Base 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} />
+              ))}
+            </Box>
+          )}
+        </>
+      )}
+      {showProjects && (showDeployed || showTrained) && <Text> </Text>}
       {showDeployed && (
         <>
           <Text bold color="cyan">Deployed Models ({data?.deployed.length ?? 0})</Text>
@@ -1728,11 +2563,281 @@ function ModelListCommand({ filter }: ModelListCommandProps) {
   );
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Model Generate Command (decoder pre-check + better errors)
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface ModelGenerateCommandProps {
+  modelId: string;
+  prompt: string;
+  systemMsg?: string;
+  maxTokens: number;
+  temperature: number;
+  topP?: number;
+  includeReasoningTrace?: boolean;
+  projectId?: string;
+}
+
+function normalizeBaseModels(
+  data: api.BaseModelsResponse | api.BaseModelInfo[] | null | undefined
+): api.BaseModelInfo[] {
+  if (!data) return [];
+  if (Array.isArray(data)) return data;
+  if (Array.isArray(data.models)) return data.models;
+  return [];
+}
+
+function isUuid(value: string): boolean {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+    value
+  );
+}
+
+function formatDecoderSuggestions(decoderIds: string[]): string {
+  if (decoderIds.length === 0) return "";
+  return `\nTry one of these decoder models: ${decoderIds.slice(0, 4).join(", ")}`;
+}
+
+function normalizeModelId(modelId: string): string {
+  return modelId.trim();
+}
+
+function getDecoderTaskType(model: api.BaseModelInfo | null | undefined): string {
+  if (!model) return "";
+  return `${model.task_type ?? model.type ?? ""}`.trim().toLowerCase();
+}
+
+function modelSupportsDecoderInference(model: api.BaseModelInfo | null | undefined): boolean {
+  if (!model) return false;
+  if (model.supports_inference !== undefined) {
+    return model.supports_inference;
+  }
+  if (model.supports_on_demand_inference !== undefined) {
+    return model.supports_on_demand_inference;
+  }
+  return true;
+}
+
+function isDecoderModel(model: api.BaseModelInfo | null | undefined): boolean {
+  const taskType = getDecoderTaskType(model);
+  return (
+    taskType === "decoder" ||
+    taskType === "llm" ||
+    taskType === "generative"
+  );
+}
+
+function shouldFallbackToTextCompletions(errorMessage: string): boolean {
+  const normalized = errorMessage.toLowerCase();
+  return (
+    normalized.includes("/v1/completions") ||
+    normalized.includes("without a chat template") ||
+    normalized.includes("text completion")
+  );
+}
+
+function buildTextCompletionPrompt(prompt: string, systemMsg?: string): string {
+  if (!systemMsg) return prompt;
+  return `System instruction:\n${systemMsg}\n\nUser prompt:\n${prompt}\n\nAssistant response:`;
+}
+
+function parseCommaSeparated(value?: string): string[] {
+  if (!value) return [];
+  return value
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function ModelGenerateCommand({
+  modelId,
+  prompt,
+  systemMsg,
+  maxTokens,
+  temperature,
+  topP,
+  includeReasoningTrace,
+  projectId,
+}: ModelGenerateCommandProps) {
+  const { exit } = useApp();
+  const [state, setState] = useState<"checking" | "running" | "done" | "error">(
+    "checking"
+  );
+  const [data, setData] = useState<api.InferenceResponse | api.TextCompletionResponse | null>(
+    null
+  );
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    let active = true;
+
+    (async () => {
+      const baseModelsResult = await api.listBaseModels();
+      const baseModels =
+        baseModelsResult.ok && baseModelsResult.data
+          ? normalizeBaseModels(baseModelsResult.data)
+          : [];
+      const decoderModelIds = baseModels
+        .filter((model) => isDecoderModel(model) && modelSupportsDecoderInference(model))
+        .map((model) => model.id);
+      const normalizedModelId = normalizeModelId(modelId);
+
+      const fail = (message: string) => {
+        if (!active) return;
+        setError(message);
+        setState("error");
+        setTimeout(() => exit(), 500);
+      };
+
+      const matchedBaseModel = baseModels.find((model) => model.id === normalizedModelId);
+      if (matchedBaseModel && (!isDecoderModel(matchedBaseModel) || !modelSupportsDecoderInference(matchedBaseModel))) {
+        const modelName = matchedBaseModel.label || matchedBaseModel.name || matchedBaseModel.id;
+        const taskType = getDecoderTaskType(matchedBaseModel) || "unknown";
+        const supportsInference = modelSupportsDecoderInference(matchedBaseModel);
+        fail(
+          `Model '${modelName}' is type '${taskType}' and is not decoder-compatible for inference` +
+            `${supportsInference ? "" : " (supports_inference = false)"} ` +
+            `(supports_inference: ${String(matchedBaseModel.supports_inference ?? "unknown")}, task_type: ${taskType}).` +
+            formatDecoderSuggestions(decoderModelIds)
+        );
+        return;
+      }
+
+      if (baseModels.length > 0 && !isUuid(normalizedModelId) && !matchedBaseModel) {
+        fail(
+          `Model '${modelId}' is not a recognized decoder base model and is not a valid job UUID.` +
+          ` Use 'model list' to copy a full training job UUID or provide a known decoder catalog ID.`
+        );
+        return;
+      }
+
+      if (isUuid(normalizedModelId)) {
+        const jobResult = await api.getJob(normalizedModelId);
+        if (jobResult.ok && jobResult.data) {
+          const taskType = jobResult.data.task_type?.toLowerCase();
+          if (taskType && !isDecoderModel({ task_type: taskType } as api.BaseModelInfo)) {
+            fail(
+              `Training job '${normalizedModelId}' has task_type '${taskType}', so it is not decoder-compatible.` +
+                formatDecoderSuggestions(decoderModelIds)
+            );
+            return;
+          }
+        }
+      }
+
+      if (!active) return;
+      setState("running");
+
+      const messages: api.InferenceMessage[] = [];
+      if (systemMsg) {
+        messages.push({ role: "system", content: systemMsg });
+      }
+      messages.push({ role: "user", content: prompt });
+
+      const result = await api.runInference({
+        model_id: normalizedModelId,
+        task: "generate",
+        messages,
+        max_tokens: maxTokens,
+        temperature,
+        ...(topP !== undefined ? { top_p: topP } : {}),
+        ...(includeReasoningTrace ? { include_reasoning_trace: true } : {}),
+        ...(projectId ? { project_id: projectId } : {}),
+      });
+
+      if (!active) return;
+
+      if (result.ok && result.data) {
+        setData(result.data);
+        setState("done");
+      } else {
+        const primaryError = result.error ?? "Unknown error";
+        const normalizedError = formatApiError(primaryError);
+        let message = normalizedError;
+
+        if (shouldFallbackToTextCompletions(normalizedError)) {
+          const completionResult = await api.runTextCompletion({
+            model: normalizedModelId,
+            prompt: buildTextCompletionPrompt(prompt, systemMsg),
+            max_tokens: maxTokens,
+            temperature,
+            ...(topP !== undefined ? { extra_body: { top_p: topP } } : {}),
+          });
+
+          if (!active) return;
+
+          if (completionResult.ok && completionResult.data) {
+            setData(completionResult.data);
+            setState("done");
+            setTimeout(() => exit(), 500);
+            return;
+          }
+
+          message =
+            "Decoder chat inference failed, and raw text fallback via /v1/completions also failed.\n" +
+            formatApiError(completionResult.error ?? "Unknown error");
+        } else if (normalizedError.toLowerCase().includes("inference failed")) {
+          message =
+            `${normalizedError}\nDecoder inference request reached the backend but failed to execute.` +
+            formatDecoderSuggestions(decoderModelIds);
+        }
+        setError(message);
+        setState("error");
+      }
+
+      setTimeout(() => exit(), 500);
+    })();
+
+    return () => {
+      active = false;
+    };
+  }, [
+    modelId,
+    prompt,
+    systemMsg,
+    maxTokens,
+    temperature,
+    topP,
+    includeReasoningTrace,
+    projectId,
+    exit,
+  ]);
+
+  if (state === "checking") {
+    return <Loading message="Checking decoder model compatibility..." />;
+  }
+
+  if (state === "running") {
+    return <Loading message="Running decoder inference..." />;
+  }
+
+  if (state === "error") {
+    return <ErrorMessage error={error} />;
+  }
+
+  return (
+    <Box flexDirection="column">
+      {data && <JsonOutput data={data} />}
+    </Box>
+  );
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Help Components
 // ─────────────────────────────────────────────────────────────────────────────
 
-type HelpContext = "root" | "auth" | "dataset" | "dataset-analyze" | "dataset-edit" | "job" | "model" | "chat" | "eval" | "benchmark" | "competition";
+type HelpContext =
+  | "root"
+  | "auth"
+  | "dataset"
+  | "dataset-analyze"
+  | "dataset-edit"
+  | "job"
+  | "model"
+  | "eval"
+  | "benchmark"
+  | "inference"
+  | "agent";
 
 interface HelpProps {
   context?: HelpContext;
@@ -1778,6 +2883,7 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <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> </Text>
         <Text bold>  Generate:</Text>
         <Text>  dataset generate ner</Text>
@@ -1802,11 +2908,59 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <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>
@@ -1828,6 +2982,8 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <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>
       </Box>
     );
@@ -1846,6 +3002,8 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <Text>  dataset edit scan-phd {"<name[:version]>"}  Scan for prompt injection</Text>
         <Text>    --columns {"<col1,col2>"}            Columns to scan (optional, scans all if omitted)</Text>
         <Text>    --threshold {"<n>"}                  Detection threshold (default: 0.5)</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>    --n {"<count>"}                      Target sample count (required)</Text>
         <Text>    --method {"<type>"}                  Method: random, balanced, stratified</Text>
@@ -1873,9 +3031,13 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <Text>                              Options: ner, classification, generative</Text>
         <Text>    --analyses {"<a1,a2,...>"}    Analyses to run (required, comma-separated)</Text>
         <Text>                              Options: distribution, duplicates, outliers, splits, diversity</Text>
+        <Text>    </Text>
+        <Text>    LLM-only analysis:</Text>
+        <Text>      dataset analyze-llm {"<id>"} --task-type {"<type>"} --description {"<text>"} --labels {"<l1,l2>"} </Text>
         <Text> </Text>
         <Text bold>  Example:</Text>
         <Text>    dataset analyze abc123 --task-type ner --analyses distribution,duplicates</Text>
+        <Text>    dataset analyze-llm abc123 --task-type ner --description "NER quality analysis"</Text>
       </Box>
     );
   }
@@ -1901,89 +3063,139 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
     );
   }
 
-  // Model help
-  if (context === "model") {
+  // Model endpoints help
+  if (context === "model-endpoints") {
     return (
       <Box flexDirection="column">
-        <Text bold>Model Commands:</Text>
-        <Text>  model list             List all models (trained + deployed)</Text>
-        <Text>  model list trained     List trained models only</Text>
-        <Text>  model list deployed    List deployed models only</Text>
-        <Text>  model delete {"<job-id>"}  Undeploy a model by training job ID</Text>
-        <Text>  model download {"<job-id>"}  Get model download URL by job ID</Text>
-        <Text> </Text>
-        <Text bold>  Upload:</Text>
-        <Text>  model upload {"<job-id>"} --to hf   Upload trained model to Hugging Face</Text>
-        <Text>    --repo {"<repo>"}              HF repo (required, e.g., username/model)</Text>
-        <Text>    --private                  Make repo private</Text>
-        <Text dimColor>    Note: Set HF token with 'pioneer auth hf' first</Text>
-        <Text dimColor>    Note: Use full job ID (not partial ID shown in list)</Text>
+        <Text bold>Model Endpoint Commands:</Text>
+        <Text>  Aliases: model_endpoints ...</Text>
+        <Text>  model endpoints list</Text>
+        <Text>  model endpoints create</Text>
+        <Text>    --name {"<name>"}                           Optional (defaults to model id)</Text>
+        <Text>    --icon {"<icon>"}                           Optional</Text>
+        <Text>    --repo {"<repo-url>"}                       Optional</Text>
+        <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 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 rollback {"<model-id>"} {"<deployment-id>"}  Rollback endpoint to previous deployment</Text>
       </Box>
     );
   }
 
-  // Chat help
-  if (context === "chat") {
+  // Model artifacts help
+  if (context === "model-artifacts") {
     return (
       <Box flexDirection="column">
-        <Text bold>Chat Commands:</Text>
-        <Text>  chat                   Start interactive chat agent</Text>
-        <Text>    --message {"<msg>"}      Initial message to process</Text>
-        <Text> </Text>
-        <Text dimColor>  Note: Model selection available in chat via /model command</Text>
+        <Text bold>Model Artifact Commands:</Text>
+        <Text>  Aliases: model_artifacts ...</Text>
+        <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 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>
+        <Text>    --private                                     Make repo private</Text>
+        <Text dimColor>    Note: Set HF token with 'pioneer auth hf' first</Text>
+        <Text dimColor>    Note: Use full job ID (not partial ID shown in list)</Text>
       </Box>
     );
   }
 
-  // Eval help
-  if (context === "eval") {
+  // Model help
+  if (context === "model") {
     return (
       <Box flexDirection="column">
-        <Text bold>Evaluation Commands:</Text>
-        <Text dimColor>  Dataset format: name[:version] (version defaults to "latest")</Text>
+        <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> </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 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> </Text>
-        <Text>  eval list {"<name[:version]>"}      List evaluations for a dataset</Text>
-        <Text>  eval get {"<id>"}                 Get evaluation details</Text>
-        <Text>  eval create                   Create a new evaluation</Text>
-        <Text>    --model-id {"<id>"}            Model to evaluate (required)</Text>
-        <Text>    --dataset {"<name[:version]>"}   Dataset to evaluate on (required)</Text>
-        <Text>    --task-type {"<type>"}         Task type: ner, classification</Text>
-        <Text>    --text-column {"<col>"}        Text column name</Text>
-        <Text>    --label-column {"<col>"}       Label column name</Text>
       </Box>
     );
   }
 
-  // Benchmark help
-  if (context === "benchmark") {
+  // Inference help
+  if (context === "inference") {
     return (
       <Box flexDirection="column">
-        <Text bold>Benchmark Commands:</Text>
-        <Text>  benchmark list                List available benchmarks</Text>
-        <Text>  benchmark run                 Start a benchmark evaluation</Text>
-        <Text>    --model-id {"<id>"}            Model to evaluate (required)</Text>
-        <Text>    --task {"<type>"}              Task: ner, text_classification (required)</Text>
-        <Text>    --benchmark {"<name>"}         Benchmark name (required)</Text>
-        <Text>    --max-samples {"<n>"}          Max samples (default: 100)</Text>
-        <Text>    --split {"<name>"}             Dataset split (default: test)</Text>
-        <Text>  benchmark get {"<id>"}             Get evaluation status/results</Text>
-        <Text>  benchmark cancel {"<id>"}          Cancel running evaluation</Text>
+        <Text bold>Inference Commands:</Text>
+        <Text>  inference base-models</Text>
+        <Text>    List base models from /base-models</Text>
+        <Text> </Text>
+        <Text>  inference encoder {"<model-id>"} --text {"<text>"} --labels {"<labels>"}</Text>
+        <Text>    Run encoder inference via /inference</Text>
+        <Text>    --task {"<task>"}         extract_entities | classify_text | extract_json | schema</Text>
+        <Text>    --labels {"<labels>"}     Comma-separated labels (or use --schema JSON)</Text>
+        <Text>    --schema {"<json>"}        JSON schema object for advanced tasks</Text>
+        <Text>    --threshold {"<n>"}       Confidence threshold (0-1, default: 0.5)</Text>
+        <Text>    --project-id {"<id>"}      Associate inference with a project</Text>
+        <Text> </Text>
+        <Text>  inference decoder {"<model-id>"} --prompt {"<text>"}</Text>
+        <Text>    Run decoder generation via /inference</Text>
+        <Text>    --system {"<text>"}       System message (optional)</Text>
+        <Text>    --max-tokens {"<n>"}      Max tokens (default: 256)</Text>
+        <Text>    --temperature {"<n>"}     Sampling temperature (default: 0.7)</Text>
+        <Text>    --top-p {"<n>"}           Top-p sampling (0-1)</Text>
+        <Text>    --reasoning-trace         Include reasoning trace when supported</Text>
+        <Text>    --project-id {"<id>"}      Associate inference with a project</Text>
+        <Text>    Example model IDs: Qwen/Qwen3-8B, meta-llama/Llama-3.1-8B-Instruct</Text>
+        <Text> </Text>
+        <Text>  inference completions {"<model-id>"} --prompt {"<text>"}</Text>
+        <Text>    Run raw text completion via /v1/completions</Text>
+        <Text>    --max-tokens {"<n>"}      Max tokens (default: 256)</Text>
+        <Text>    --temperature {"<n>"}     Sampling temperature (default: 0.7)</Text>
+        <Text>    --top-p {"<n>"}           Top-p (sent via extra_body)</Text>
+        <Text>    --stop {"<a,b,c>"}        Stop sequences (comma-separated)</Text>
+        <Text>    --echo true               Echo prompt in output</Text>
+        <Text>    --provider {"<name>"}      Provider override (optional)</Text>
       </Box>
     );
   }
 
-  // Competition help
-  if (context === "competition") {
+  // Eval help
+  if (context === "eval") {
+    return <ErrorMessage error="The 'eval' command group is temporarily hidden for this version." />;
+  }
+
+  // Benchmark help
+  if (context === "benchmark") {
+    return <ErrorMessage error="The 'benchmark' command group is temporarily hidden for this version." />;
+  }
+
+  // Agent help
+  if (context === "agent") {
     return (
       <Box flexDirection="column">
-        <Text bold>Competition Commands:</Text>
-        <Text>  competition list                     List active competitions</Text>
-        <Text>  competition show {"<dataset-id>"}         View sample data for a competition</Text>
-        <Text>  competition leaderboard {"<dataset-id>"}  View leaderboard rankings</Text>
-        <Text>    --limit {"<n>"}                        Number of entries (default: 10)</Text>
-        <Text>  competition submit {"<dataset-id>"}       Submit evaluation to leaderboard</Text>
-        <Text>    --eval-id {"<id>"}                     Evaluation ID (required)</Text>
-        <Text>    --name {"<name>"}                      Display name (required)</Text>
+        <Text bold>Agent Commands:</Text>
+        <Text>  agent                            Start interactive agent chat</Text>
+        <Text>    --mode {"<research>"}                       --mode research uses Pro workflow</Text>
+        <Text>  </Text>
+        <Text>    Omit --mode to use the default standard interactive mode.</Text>
+        <Text>    --conversation-id {"<id>"}           Continue an existing conversation</Text>
+        <Text>    --filters {"<json>"}                 Reserved for future query filters</Text>
+        <Text>    --history {"<json>"}                 Optional message history JSON</Text>
+        <Text> </Text>
+        <Text dimColor>Example: pioneer agent</Text>
+        <Text dimColor>Example: pioneer agent --mode research</Text>
+        <Text dimColor>Then type: Analyze failures and propose retraining plan</Text>
+        <Text dimColor>Then type: Draft a short status summary</Text>
       </Box>
     );
   }
@@ -1997,14 +3209,10 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
       <Text>  pioneer {"<command>"} {"[options]"}</Text>
       <Text> </Text>
       <Text bold>Commands:</Text>
-      <Text>  chat       Start interactive chat agent</Text>
       <Text>  auth       Authentication (login, logout, status)</Text>
-      <Text>  dataset    Manage datasets (list, generate, edit, analyze)</Text>
+      <Text>  model      Manage model endpoints and artifacts</Text>
       <Text>  job        Manage training jobs</Text>
-      <Text>  model      Manage models</Text>
-      <Text>  eval       Model evaluations on datasets</Text>
-      <Text>  benchmark  Run benchmark evaluations</Text>
-      <Text>  competition Competitions and leaderboards</Text>
+        <Text>  agent      Run agent chat (research is the only explicit alternate mode)</Text>
       <Text>  telemetry  Manage anonymous usage analytics</Text>
       <Text> </Text>
       <Text dimColor>Run 'pioneer {"<command>"} --help' for details on a specific command.</Text>
@@ -2012,24 +3220,12 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
       <Text dimColor>Get started:</Text>
       <Text dimColor>  1. Sign up at https://app.pioneer.ai</Text>
       <Text dimColor>  2. Run: pioneer auth login</Text>
-      <Text dimColor>  3. Start building with: pioneer chat</Text>
+      <Text dimColor>  3. Start building with: pioneer agent</Text>
     </Box>
   );
 };
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Chat Wrapper Component
-// ─────────────────────────────────────────────────────────────────────────────
-
-interface ChatWrapperProps {
-  flags: Record<string, string>;
-}
-
-const ChatWrapper: React.FC<ChatWrapperProps> = ({ flags }) => {
-  const initialMessage = flags.message;
-  return <ChatApp initialMessage={initialMessage} />;
-};
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Main Router
 // ─────────────────────────────────────────────────────────────────────────────
@@ -2037,13 +3233,75 @@ const ChatWrapper: React.FC<ChatWrapperProps> = ({ flags }) => {
 interface AppProps {
   command: string[];
   flags: Record<string, string>;
+  parseErrors: string[];
 }
 
-const App: React.FC<AppProps> = ({ command, flags }) => {
+const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
   // Check if raw mode is supported for interactive prompts
   const { isRawModeSupported } = useStdin();
   const [showTelemetryPrompt, setShowTelemetryPrompt] = useState(!hasChosenTelemetry());
   const [group, action, ...rest] = command;
+  const normalizedAction =
+    action === "model_endpoints"
+      ? "endpoints"
+      : action === "model_artifacts"
+        ? "artifacts"
+        : action;
+  const hasParseErrors = parseErrors.length > 0;
+  const isModelCreateMissingModel =
+    group === "model" &&
+    normalizedAction === "endpoints" &&
+    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") {
+    return (
+      <ErrorMessage
+        error={`The '${group}' command group is temporarily hidden for this version. Use 'pioneer --help' to see available commands.`}
+      />
+    );
+  }
+
+  if (hasParseErrors && !isModelCreateMissingModel) {
+    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: " />
+        {parseErrors.map((flag) => (
+          <Text dimColor key={flag}>
+            - {flag} {"<value>"}
+          </Text>
+        ))}
+      </Box>
+    );
+  }
 
   // In non-interactive mode, skip telemetry prompt and default to disabled
   useEffect(() => {
@@ -2056,9 +3314,11 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
   // Track command usage (must be before any conditional returns)
   useEffect(() => {
     if (group && !showTelemetryPrompt) {
-      trackCommand(group, action);
+      const actionForTracking =
+        group === "model" && normalizedAction !== action ? action || normalizedAction : normalizedAction;
+      trackCommand(group, actionForTracking);
     }
-  }, [group, action, showTelemetryPrompt]);
+  }, [group, action, normalizedAction, showTelemetryPrompt]);
 
   // Show telemetry consent prompt on first run (but not for --help or --version, and only if interactive)
   if (showTelemetryPrompt && isRawModeSupported && !flags.help && flags.version !== "true" && flags.v !== "true") {
@@ -2070,14 +3330,6 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
     return <Help />;
   }
 
-  // Chat command - Interactive agent
-  if (group === "chat") {
-    if (flags.help === "true" || action === "help") {
-      return <Help context="chat" />;
-    }
-    return <ChatWrapper flags={flags} />;
-  }
-
   // Auth commands
   if (group === "auth") {
     if (flags.help === "true" || !action || action === "help") {
@@ -2217,6 +3469,31 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
         );
       }
 
+      if (subAction === "dismiss-outlier" && rest[1]) {
+        const dataset = parseDatasetRef(rest[1]);
+        const fingerprint = flags["fingerprint"];
+        if (!dataset) {
+          return <ErrorMessage error={`Invalid dataset format: ${rest[1]}. Use name[:version] format (e.g., my-dataset or my-dataset:v1).`} />;
+        }
+        if (!fingerprint) {
+          return (
+            <ErrorMessage error="--fingerprint is required (from dataset analysis output)" />
+          );
+        }
+
+        return (
+          <ApiCommand
+            action={() =>
+              api.dismissOutlier({
+                dataset,
+                fingerprint,
+              })
+            }
+            successMessage={`Outlier dismissed for dataset ${rest[1]}`}
+          />
+        );
+      }
+
       return <Help context="dataset-edit" />;
     }
 
@@ -2398,6 +3675,41 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
         />
       );
     }
+    if (action === "analyze-llm") {
+      const datasetStr = rest[0];
+      const taskType = flags["task-type"];
+      const taskDescription = flags["description"] || flags["task-description"];
+      const labels = parseCommaSeparated(flags["labels"]);
+
+      if (!datasetStr || !taskType) {
+        return <Help context="dataset-analyze" />;
+      }
+
+      if (!["ner", "classification", "generative"].includes(taskType)) {
+        return (
+          <ErrorMessage error="--task-type must be one of: ner, classification, generative" />
+        );
+      }
+
+      const dataset = parseDatasetRef(datasetStr);
+      if (!dataset) {
+        return <ErrorMessage error={`Invalid dataset format: ${datasetStr}. Use name:version format.`} />;
+      }
+
+      return (
+        <ApiCommand
+          action={() =>
+            api.analyzeDatasetLLM({
+              task_type: taskType as "ner" | "classification" | "generative",
+              dataset_name: dataset.name,
+              dataset_version: dataset.version,
+              ...(taskDescription ? { task_description: taskDescription } : {}),
+              ...(labels.length ? { labels } : {}),
+            })
+          }
+        />
+      );
+    }
     if (action === "analyze") {
       const datasetStr = rest[0];
       const taskType = flags["task-type"];
@@ -2427,6 +3739,131 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
       const domainDescription = flags["domain"];
       const saveDataset = flags["save"]?.toLowerCase() === "true";
       const datasetName = flags["name"];
+      const quality = flags["quality"] as "light" | "medium" | "heavy" | undefined;
+      const generationProfile = flags["generation-profile"] as
+        | "auto"
+        | "fast"
+        | "balanced"
+        | "quality"
+        | undefined;
+      const includeReasoningTrace =
+        flags["reasoning-trace"] === undefined
+          ? undefined
+          : flags["reasoning-trace"].toLowerCase() !== "false";
+      const reasoningEffort = flags["reasoning-effort"] as
+        | "low"
+        | "medium"
+        | "high"
+        | undefined;
+      const validGenerationProfiles = ["auto", "fast", "balanced", "quality"];
+      if (generationProfile && !validGenerationProfiles.includes(generationProfile)) {
+        return <ErrorMessage error="--generation-profile must be one of: auto, fast, balanced, quality" />;
+      }
+      const validReasoningEfforts = ["low", "medium", "high"];
+      if (reasoningEffort && !validReasoningEfforts.includes(reasoningEffort)) {
+        return <ErrorMessage error="--reasoning-effort must be one of: low, medium, high" />;
+      }
+      const multiplicatorArg = flags["multiplicator"];
+      const useMetaFelix = flags["use-meta-felix"]
+        ? flags["use-meta-felix"].toLowerCase() !== "false"
+        : undefined;
+      const minCriteria = flags["min-criteria"] ? parseInt(flags["min-criteria"], 10) : undefined;
+      if (flags["min-criteria"] && Number.isNaN(minCriteria)) {
+        return <ErrorMessage error="--min-criteria must be a number" />;
+      }
+      const targetChoices = flags["target-choices"]
+        ? parseInt(flags["target-choices"], 10)
+        : undefined;
+      if (flags["target-choices"] && Number.isNaN(targetChoices)) {
+        return <ErrorMessage error="--target-choices must be a number" />;
+      }
+      const projectId = flags["project-id"];
+      const generationType = flags["type"] as "training" | "evaluation" | "split" | undefined;
+      if (generationType && !["training", "evaluation", "split"].includes(generationType)) {
+        return <ErrorMessage error="--type must be one of: training, evaluation, split" />;
+      }
+      const visibility = flags["visibility"] as "private" | "public" | undefined;
+      if (visibility && !["private", "public"].includes(visibility)) {
+        return <ErrorMessage error="--visibility must be private or public" />;
+      }
+      const splitRatioArg = flags["split-ratio"];
+      const splitRatio =
+        splitRatioArg && splitRatioArg.includes(":")
+          ? (() => {
+              const [training, evaluation] = splitRatioArg.split(":").map((v) => parseFloat(v));
+              if (Number.isNaN(training) || Number.isNaN(evaluation)) {
+                return undefined;
+              }
+              return { training, evaluation };
+            })()
+          : splitRatioArg
+          ? (() => {
+              try {
+                const parsed = JSON.parse(splitRatioArg);
+                return parsed;
+              } catch {
+                return undefined;
+              }
+            })()
+          : undefined;
+      const negativeRatio = flags["negative-ratio"]
+        ? parseFloat(flags["negative-ratio"])
+        : undefined;
+      if (flags["negative-ratio"] && Number.isNaN(negativeRatio)) {
+        return <ErrorMessage error="--negative-ratio must be a number" />;
+      }
+      const classifiedExamplesArg = flags["classified-examples"];
+      const qualityArg = flags["quality"];
+      if (qualityArg && !["light", "medium", "heavy"].includes(qualityArg)) {
+        return <ErrorMessage error="--quality must be light, medium, or heavy" />;
+      }
+      if (splitRatioArg && splitRatio === undefined) {
+        return <ErrorMessage error="--split-ratio must be training:evaluation or a JSON object" />;
+      }
+      let parsedMultiplicator: Record<string, unknown> | undefined;
+      if (multiplicatorArg) {
+        try {
+          const parsed = JSON.parse(multiplicatorArg);
+          if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            return <ErrorMessage error="--multiplicator must be a valid JSON object" />;
+          }
+          parsedMultiplicator = parsed;
+        } catch {
+          return <ErrorMessage error="--multiplicator must be valid JSON" />;
+        }
+      }
+      let classifiedExamples: Record<string, unknown>[] | undefined;
+      if (classifiedExamplesArg) {
+        try {
+          const parsed = JSON.parse(classifiedExamplesArg);
+          if (!Array.isArray(parsed)) {
+            return <ErrorMessage error="--classified-examples must be a JSON array" />;
+          }
+          classifiedExamples = parsed as Record<string, unknown>[];
+        } catch {
+          return <ErrorMessage error="--classified-examples must be valid JSON" />;
+        }
+      }
+      if (multiplicatorArg && parsedMultiplicator === undefined) {
+        return <ErrorMessage error="--multiplicator must be a valid JSON object" />;
+      }
+
+      const commonGenerationOptions = {
+        quality,
+        generation_profile: generationProfile,
+        ...(includeReasoningTrace !== undefined ? { include_reasoning_trace: includeReasoningTrace } : {}),
+        ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
+        ...(multiplicatorArg ? { multiplicator: parsedMultiplicator } : {}),
+        ...(useMetaFelix !== undefined ? { use_meta_felix: useMetaFelix } : {}),
+        ...(minCriteria !== undefined ? { min_criteria: minCriteria } : {}),
+        ...(targetChoices !== undefined ? { target_choices: targetChoices } : {}),
+        ...(projectId ? { project_id: projectId } : {}),
+        ...(generationType ? { type: generationType } : {}),
+        ...(visibility ? { visibility } : {}),
+        ...(splitRatio ? { split_ratio: splitRatio } : {}),
+        ...(negativeRatio !== undefined ? { negative_ratio: negativeRatio } : {}),
+        ...(classifiedExamplesArg ? { classified_examples: classifiedExamples } : {}),
+      };
 
       if (subAction === "ner") {
         const labels = flags["labels"]?.split(",");
@@ -2442,6 +3879,7 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
                 domain_description: domainDescription,
                 save_dataset: saveDataset,
                 dataset_name: datasetName,
+                ...commonGenerationOptions,
               })
             }
             datasetName={datasetName || "ner-dataset"}
@@ -2467,6 +3905,7 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
                 multi_label: multiLabel,
                 save_dataset: saveDataset,
                 dataset_name: datasetName,
+                ...commonGenerationOptions,
               })
             }
             datasetName={datasetName || "classification-dataset"}
@@ -2497,6 +3936,7 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
                 num_examples: numExamples,
                 save_dataset: saveDataset,
                 dataset_name: datasetName,
+                ...commonGenerationOptions,
               })
             }
             datasetName={datasetName || "custom-dataset"}
@@ -2506,12 +3946,74 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
         );
       }
 
+      if (subAction === "decoder") {
+        const instruction = flags["instruction"];
+        if (!domainDescription) {
+          return <ErrorMessage error="--domain is required for decoder generation" />;
+        }
+        return (
+          <GenerateCommand
+            action={() =>
+              api.generateDecoder({
+                domain_description: domainDescription!,
+                instruction,
+                num_examples: numExamples,
+                save_dataset: saveDataset,
+                dataset_name: datasetName,
+                ...commonGenerationOptions,
+              })
+            }
+            datasetName={datasetName || "decoder-dataset"}
+            datasetType="custom"
+            saveToRemote={saveDataset}
+          />
+        );
+      }
+
       return <Help context="dataset" />;
     }
 
     // Infer labels commands
     if (action === "infer") {
       const subAction = rest[0];
+      if (subAction === "improve-prompt") {
+        const prompt = flags["prompt"] || flags["domain"];
+        if (!prompt) {
+          return <ErrorMessage error="--prompt is required for infer improve-prompt" />;
+        }
+        const dataType = flags["data-type"];
+        return (
+          <ApiCommand
+            action={() =>
+              api.improvePrompt({
+                prompt,
+                ...(dataType ? { data_type: dataType } : {}),
+              })
+            }
+          />
+        );
+      }
+
+      if (subAction === "infer-advanced" || subAction === "advanced") {
+        const prompt = flags["prompt"] || flags["domain"];
+        const dataType = flags["data-type"];
+        const labels = parseCommaSeparated(flags["labels"]);
+        if (!prompt) {
+          return <ErrorMessage error="--prompt is required for dataset infer infer-advanced" />;
+        }
+        return (
+          <ApiCommand
+            action={() =>
+              api.inferAdvanced({
+                prompt,
+                ...(dataType ? { data_type: dataType } : {}),
+                ...(labels.length > 0 ? { labels } : {}),
+              })
+            }
+          />
+        );
+      }
+
       const domainDescription = flags["domain"];
 
       if (!domainDescription) {
@@ -2545,6 +4047,128 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
       return <Help context="dataset" />;
     }
 
+    if (action === "label-existing") {
+      const subAction = rest[0];
+      const labels = parseCommaSeparated(flags["labels"]);
+      const inputsArg = flags["inputs"];
+      const datasetName = flags["name"];
+      const saveDataset = flags["save"]?.toLowerCase() === "true";
+      const domainDescription = flags["domain"];
+      const projectId = flags["project-id"];
+      if (!inputsArg) {
+        return <ErrorMessage error="--inputs is required for label-existing commands" />;
+      }
+      if (saveDataset && !datasetName) {
+        return <ErrorMessage error="--name is required when --save=true for label-existing" />;
+      }
+
+      let inputs: unknown;
+      try {
+        inputs = JSON.parse(inputsArg);
+      } catch {
+        return <ErrorMessage error="--inputs must be valid JSON" />;
+      }
+
+      if (subAction === "ner" || subAction === "classification") {
+        if (!labels || labels.length === 0) {
+          return <ErrorMessage error="--labels is required for label-existing ner|classification" />;
+        }
+        if (
+          !Array.isArray(inputs) ||
+          inputs.length === 0 ||
+          !inputs.every((item) => typeof item === "string")
+        ) {
+          return <ErrorMessage error="--inputs must be a JSON array of strings for ner/classification" />;
+        }
+        const common = { labels, inputs: inputs as string[], dataset_name: datasetName };
+        if (subAction === "ner") {
+          return (
+            <ApiCommand
+              action={() =>
+                api.labelExistingNER({
+                  ...common,
+                  domain_description: domainDescription,
+                  save_dataset: saveDataset,
+                  project_id: projectId,
+                })
+              }
+            />
+          );
+        }
+        return (
+          <ApiCommand
+            action={() =>
+              api.labelExistingClassification({
+                ...common,
+                domain_description: domainDescription,
+                save_dataset: saveDataset,
+                project_id: projectId,
+              })
+            }
+          />
+        );
+      }
+
+      if (subAction === "fields") {
+        const inputFieldsArg = flags["input-fields"];
+        const outputFieldsArg = flags["output-fields"];
+        if (!inputFieldsArg || !outputFieldsArg) {
+          return <ErrorMessage error="--input-fields and --output-fields are required for fields labeling" />;
+        }
+        let inputFields: unknown;
+        let outputFields: unknown;
+        try {
+          inputFields = JSON.parse(inputFieldsArg);
+          outputFields = JSON.parse(outputFieldsArg);
+        } catch {
+          return <ErrorMessage error="--input-fields and --output-fields must be valid JSON" />;
+        }
+        if (
+          !Array.isArray(inputFields) ||
+          !Array.isArray(outputFields) ||
+          inputFields.length === 0 ||
+          outputFields.length === 0
+        ) {
+          return (
+            <ErrorMessage error="--input-fields and --output-fields must be non-empty arrays" />
+          );
+        }
+        const validInputFields = inputFields.every(
+          (field) => field && typeof field === "object" && !Array.isArray(field)
+        );
+        const validOutputFields = outputFields.every(
+          (field) => field && typeof field === "object" && !Array.isArray(field)
+        );
+        if (!validInputFields || !validOutputFields) {
+          return <ErrorMessage error="--input-fields and --output-fields must be arrays of objects" />;
+        }
+        if (
+          !Array.isArray(inputs) ||
+          inputs.length === 0 ||
+          !inputs.every((item) => item && typeof item === "object" && !Array.isArray(item))
+        ) {
+          return <ErrorMessage error="--inputs must be a JSON array of objects for fields" />;
+        }
+        return (
+          <ApiCommand
+            action={() =>
+              api.labelExistingFields({
+                input_fields: inputFields as api.RecordField[],
+                output_fields: outputFields as api.RecordField[],
+                inputs: inputs as Record<string, unknown>[],
+                dataset_name: datasetName,
+                save_dataset: saveDataset,
+                domain_description: domainDescription,
+                project_id: projectId,
+              })
+            }
+          />
+        );
+      }
+
+      return <Help context="dataset" />;
+    }
+
     return <Help context="dataset" />;
   }
 
@@ -2602,125 +4226,558 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
     return <Help context="job" />;
   }
 
-  // Model commands
-  if (group === "model") {
+  // Inference commands
+  if (group === "inference") {
     if (flags.help === "true" || !action || action === "help") {
-      return <Help context="model" />;
+      return <Help context="inference" />;
     }
-    if (action === "list") {
-      const subAction = rest[0];
-      if (subAction === "help") {
-        return <Help context="model" />;
+
+    if (action === "base-models" || action === "models" || action === "list") {
+      return <ApiCommand action={api.listBaseModels} />;
+    }
+
+    if (action === "encoder") {
+      const rawModelId = rest[0];
+      if (!rawModelId) {
+        return (
+          <ErrorMessage error="Model ID required. Usage: inference encoder <model-id> --text <text> --labels <labels>" />
+        );
       }
-      if (subAction === "trained") {
-        return <ModelListCommand filter="trained" />;
+      const modelId = normalizeModelId(rawModelId);
+      const text = flags["text"];
+      if (!text) {
+        return <ErrorMessage error="--text is required for encoder inference" />;
       }
-      if (subAction === "deployed") {
-        return <ModelListCommand filter="deployed" />;
+
+      const task = (flags["task"] || "extract_entities") as
+        | "extract_entities"
+        | "classify_text"
+        | "extract_json"
+        | "schema";
+      if (!["extract_entities", "classify_text", "extract_json", "schema"].includes(task)) {
+        return (
+          <ErrorMessage error="--task must be one of: extract_entities, classify_text, extract_json, schema" />
+        );
       }
-      // Default: show all models
-      return <ModelListCommand filter="all" />;
+
+      const labels = parseCommaSeparated(flags["labels"]);
+      const schemaStr = flags["schema"];
+      let schema: string[] | Record<string, unknown> | null = null;
+
+      if (schemaStr) {
+        try {
+          const parsed = JSON.parse(schemaStr) as unknown;
+          if (Array.isArray(parsed)) {
+            if (!parsed.every((item) => typeof item === "string")) {
+              return (
+                <ErrorMessage error="--schema JSON array must contain only strings" />
+              );
+            }
+            schema = parsed;
+          } else if (parsed && typeof parsed === "object") {
+            schema = parsed as Record<string, unknown>;
+          } else {
+            return (
+              <ErrorMessage error="--schema must be a JSON object or array of strings" />
+            );
+          }
+        } catch {
+          return <ErrorMessage error="--schema must be valid JSON" />;
+        }
+      } else if (labels.length > 0) {
+        schema = labels;
+      }
+
+      if (!schema) {
+        return <ErrorMessage error="Provide --labels or --schema for encoder inference" />;
+      }
+
+      const threshold = flags["threshold"] ? parseFloat(flags["threshold"]) : 0.5;
+      if (Number.isNaN(threshold) || threshold < 0 || threshold > 1) {
+        return <ErrorMessage error="--threshold must be a number between 0 and 1" />;
+      }
+
+      const includeConfidence =
+        flags["include-confidence"] === undefined ||
+        flags["include-confidence"].toLowerCase() !== "false";
+      const includeSpans = flags["include-spans"]?.toLowerCase() === "true";
+      const formatResults =
+        flags["format-results"] === undefined ||
+        flags["format-results"].toLowerCase() !== "false";
+      const projectId = flags["project-id"];
+
+      return (
+        <ApiCommand
+          action={() =>
+            api.runInference({
+              model_id: modelId,
+              task,
+              text,
+              schema,
+              threshold,
+              include_confidence: includeConfidence,
+              include_spans: includeSpans,
+              format_results: formatResults,
+              ...(projectId ? { project_id: projectId } : {}),
+            })
+          }
+        />
+      );
     }
-    if (action === "delete") {
-      if (!rest[0]) {
-        return <ErrorMessage error="Job ID required. Usage: model delete <job-id>" />;
+
+    if (action === "decoder") {
+      const modelId = rest[0];
+      if (!modelId) {
+        return (
+          <ErrorMessage error="Model ID required. Usage: inference decoder <model-id> --prompt <text>" />
+        );
+      }
+      const normalizedModelId = normalizeModelId(modelId);
+      const prompt = flags["prompt"];
+      if (!prompt) {
+        return <ErrorMessage error="--prompt is required for decoder inference" />;
+      }
+      const systemMsg = flags["system"];
+      const maxTokens = flags["max-tokens"] ? parseInt(flags["max-tokens"], 10) : 256;
+      if (Number.isNaN(maxTokens) || maxTokens < 1) {
+        return <ErrorMessage error="--max-tokens must be a positive integer" />;
       }
-      const jobId = rest[0];
-      if (jobId.length !== 36) {
+      const temperature = flags["temperature"] ? parseFloat(flags["temperature"]) : 0.7;
+      if (Number.isNaN(temperature) || temperature < 0 || temperature > 2) {
+        return <ErrorMessage error="--temperature must be a number between 0 and 2" />;
+      }
+      const topP = flags["top-p"] ? parseFloat(flags["top-p"]) : undefined;
+      if (topP !== undefined && (Number.isNaN(topP) || topP < 0 || topP > 1)) {
+        return <ErrorMessage error="--top-p must be a number between 0 and 1" />;
+      }
+      const includeReasoningTrace =
+        flags["reasoning-trace"] !== undefined &&
+        flags["reasoning-trace"].toLowerCase() !== "false";
+      const projectId = flags["project-id"];
+
+      return (
+        <ModelGenerateCommand
+          modelId={normalizedModelId}
+          prompt={prompt}
+          systemMsg={systemMsg}
+          maxTokens={maxTokens}
+          temperature={temperature}
+          topP={topP}
+          includeReasoningTrace={includeReasoningTrace}
+          projectId={projectId}
+        />
+      );
+    }
+
+    if (action === "completions") {
+      const rawModelId = rest[0];
+      if (!rawModelId) {
         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 list' to see full job IDs</Text>
-          </Box>
+          <ErrorMessage error="Model ID required. Usage: inference completions <model-id> --prompt <text>" />
         );
       }
+      const modelId = normalizeModelId(rawModelId);
+      const prompt = flags["prompt"];
+      if (!prompt) {
+        return <ErrorMessage error="--prompt is required for text completions" />;
+      }
+
+      const systemMsg = flags["system"];
+      const maxTokens = flags["max-tokens"] ? parseInt(flags["max-tokens"], 10) : 256;
+      if (Number.isNaN(maxTokens) || maxTokens < 1) {
+        return <ErrorMessage error="--max-tokens must be a positive integer" />;
+      }
+      const temperature = flags["temperature"] ? parseFloat(flags["temperature"]) : 0.7;
+      if (Number.isNaN(temperature) || temperature < 0 || temperature > 2) {
+        return <ErrorMessage error="--temperature must be a number between 0 and 2" />;
+      }
+      const topP = flags["top-p"] ? parseFloat(flags["top-p"]) : undefined;
+      if (topP !== undefined && (Number.isNaN(topP) || topP < 0 || topP > 1)) {
+        return <ErrorMessage error="--top-p must be a number between 0 and 1" />;
+      }
+      const stopValues = parseCommaSeparated(flags["stop"]);
+      const stop =
+        stopValues.length === 0 ? undefined : stopValues.length === 1 ? stopValues[0] : stopValues;
+      const echo = flags["echo"]?.toLowerCase() === "true";
+      const provider = flags["provider"];
+
+      const extraBody: Record<string, unknown> = {};
+      if (topP !== undefined) extraBody.top_p = topP;
+      if (provider) extraBody.provider = provider;
+
       return (
         <ApiCommand
-          action={() => api.deleteModel(jobId)}
-          successMessage={`Model ${jobId} deleted`}
+          action={() =>
+            api.runTextCompletion({
+              model: modelId,
+              prompt: buildTextCompletionPrompt(prompt, systemMsg),
+              max_tokens: maxTokens,
+              temperature,
+              ...(stop !== undefined ? { stop } : {}),
+              ...(echo ? { echo: true } : {}),
+              ...(Object.keys(extraBody).length > 0 ? { extra_body: extraBody } : {}),
+            })
+          }
         />
       );
     }
-    if (action === "download") {
-      if (!rest[0]) {
-        return <ErrorMessage error="Job ID required. Usage: model download <job-id>" />;
+
+    return <Help context="inference" />;
+  }
+
+  // Model commands
+  if (group === "model") {
+    if (flags.help === "true" || !action || action === "help") {
+      return <Help context="model" />;
+    }
+
+    if (normalizedAction === "endpoints") {
+      const endpointAction = rest[0];
+      const endpointArgs = rest.slice(1);
+
+      if (flags.help === "true" || !endpointAction || endpointAction === "help") {
+        return <Help context="model-endpoints" />;
       }
-      const jobId = rest[0];
-      if (jobId.length !== 36) {
+
+      if (endpointAction === "create") {
+        const name = flags["name"];
+        const icon = flags["icon"];
+        const repo = flags["repo"];
+        const description = flags["description"];
+        const modelId = flags["model"] || "";
+        const exampleStr = flags["example"];
+
+        if (flags["model-id"]) {
+          return (
+            <ErrorMessage error="Use --model to specify the base model reference. --model-id is deprecated." />
+          );
+        }
+
+        if (flags["base-model"] || flags["active-model-id"]) {
+          return (
+            <ErrorMessage error="Use --model to specify the model reference. --base-model and --active-model-id are no longer supported." />
+          );
+        }
+
+        if (!modelId) {
+          const parsedExample = parseProjectExample(exampleStr);
+          if (parsedExample.error) {
+            return <ErrorMessage error={parsedExample.error} />;
+          }
+          return (
+            <ModelCreateInteractive
+              name={name}
+              icon={icon}
+              repo={repo}
+              description={description}
+              example={parsedExample.value}
+            />
+          );
+        }
+
+        const parsedExample = parseProjectExample(exampleStr);
+        if (parsedExample.error) {
+          return <ErrorMessage error={parsedExample.error} />;
+        }
+
         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 list' to see full job IDs</Text>
-          </Box>
+          <ApiCommand
+            action={() =>
+              api.createProject({
+                name: name ?? modelId,
+                ...(icon ? { icon } : {}),
+                ...(repo ? { repo } : {}),
+                ...(description ? { description } : {}),
+                ...(modelId ? { active_model_id: modelId } : {}),
+                ...(modelId ? { selected_model_id: modelId } : {}),
+                ...(parsedExample.value ? { example: parsedExample.value } : {}),
+              })
+            }
+            successMessage="Model entry created"
+          />
         );
       }
-      return <ApiCommand action={() => api.downloadModel(jobId)} />;
-    }
-    // Model upload command
-    if (action === "upload") {
-      const destination = flags["to"];
 
-      // Show help if no arguments provided
-      if (!rest[0] && !destination) {
+      if (endpointAction === "list") {
+        return <ModelListCommand filter="registered" />;
+      }
+
+      if (endpointAction === "get") {
+        const modelId = endpointArgs[0];
+        if (!modelId) {
+          return <ErrorMessage error="Model ID required: model endpoints get <model-id>" />;
+        }
+        return <ApiCommand action={() => api.getProject(modelId)} />;
+      }
+
+      if (endpointAction === "update") {
+        const modelId = endpointArgs[0];
+        if (!modelId) {
+          return <ErrorMessage error="Model ID required: model endpoints update <model-id>" />;
+        }
+
+        const name = flags["name"];
+        const icon = flags["icon"];
+        const repo = flags["repo"];
+        const description = flags["description"];
+        const selectedModelId = flags["model-id"];
+
+        if (!name && !icon && !repo && !description && !selectedModelId) {
+          return (
+            <ErrorMessage error="Provide at least one field to update: --name, --icon, --repo, --description, or --model-id" />
+          );
+        }
+
         return (
-          <Box flexDirection="column">
-            <Text bold>Model Upload:</Text>
-            <Text> </Text>
-            <Text>  Upload to Hugging Face:</Text>
-            <Text>    model upload {"<job-id>"} --to hf --repo {"<repo>"} [--hf-token {"<token>"}] [--private]</Text>
-            <Text> </Text>
-            <Text dimColor>  Supported destinations: hf (more coming soon)</Text>
-          </Box>
+          <ApiCommand
+            action={() =>
+              api.updateProject(modelId, {
+                ...(name ? { name } : {}),
+                ...(icon ? { icon } : {}),
+                ...(repo ? { repo } : {}),
+                ...(description ? { description } : {}),
+                ...(selectedModelId ? { selected_model_id: selectedModelId } : {}),
+              })
+            }
+            successMessage="Model updated"
+          />
         );
       }
 
-      // Upload to Hugging Face
-      if (destination === "hf") {
-        if (!rest[0]) {
-          return <ErrorMessage error="Job ID required: model upload <job-id> --to hf --repo <repo>" />;
+      if (endpointAction === "delete") {
+        const modelId = endpointArgs[0];
+        if (!modelId) {
+          return <ErrorMessage error="Model ID required: model endpoints delete <model-id>" />;
         }
-        const jobId = rest[0];
-        const repo = flags["repo"];
-        const hfTokenFlag = flags["hf-token"];
-        const isPrivate = flags["private"]?.toLowerCase() === "true";
+        return (
+          <ApiCommand
+            action={() => api.deleteProject(modelId)}
+            successMessage={`Model ${modelId} deleted`}
+          />
+        );
+      }
 
-        if (!repo) {
-          return <ErrorMessage error="--repo is required (e.g., username/model-name)" />;
+      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)} />;
+      }
 
-        const hfToken = getHfToken(hfTokenFlag);
-        if (!hfToken) {
+      if (endpointAction === "quality-metrics" || endpointAction === "quality") {
+        const modelId = endpointArgs[0];
+        if (!modelId) {
+          return <ErrorMessage error="Model ID required: model endpoints quality-metrics <model-id>" />;
+        }
+        return <ApiCommand action={() => api.getProjectQualityMetrics(modelId)} />;
+      }
+
+      if (endpointAction === "deploy") {
+        const modelId = endpointArgs[0];
+        const jobId = 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="Hugging Face token required." />
-              <Text> </Text>
-              <Text>Set your token with:</Text>
-              <Text color="cyan">  pioneer auth hf</Text>
-              <Text> </Text>
-              <Text dimColor>Get a token at: https://huggingface.co/settings/tokens</Text>
+              <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>
           );
         }
 
+        const reason = flags["reason"];
+
         return (
           <ApiCommand
             action={() =>
-              api.pushModelToHub(jobId, {
-                hf_token: hfToken,
-                repo_id: repo,
-                private: isPrivate,
+              api.deployTrainingJobToProject(modelId, {
+                training_job_id: jobId,
+                ...(reason ? { reason } : {}),
               })
             }
-            successMessage={`Model uploaded to Hugging Face: ${repo}`}
+            successMessage={`Deployment initiated for project ${modelId} from job ${jobId}`}
           />
         );
       }
 
-      return <ErrorMessage error="--to is required. Supported destinations: hf" />;
+      if (endpointAction === "rollback") {
+        const modelId = endpointArgs[0];
+        const deploymentId = endpointArgs[1];
+
+        if (!modelId) {
+          return <ErrorMessage error="Model ID required: model endpoints rollback <model-id> <deployment-id>" />;
+        }
+        if (!deploymentId) {
+          return (
+            <ErrorMessage error="Deployment ID required: model endpoints rollback <model-id> <deployment-id>" />
+          );
+        }
+        if (deploymentId.length !== 36) {
+          return (
+            <Box flexDirection="column">
+              <ErrorMessage error="Invalid deployment ID: must be full UUID (36 characters)" />
+              <Text dimColor>  Provided: {deploymentId} ({deploymentId.length} characters)</Text>
+            </Box>
+          );
+        }
+
+        return (
+          <ApiCommand
+            action={() => api.rollbackProjectDeployment(modelId, deploymentId)}
+            successMessage={`Rollback initiated for endpoint ${modelId} using deployment ${deploymentId}`}
+          />
+        );
+      }
+
+      return <Help context="model-endpoints" />;
+    }
+
+    if (normalizedAction === "artifacts") {
+      const artifactsAction = rest[0];
+      const artifactArgs = rest.slice(1);
+
+      if (flags.help === "true" || !artifactsAction || artifactsAction === "help") {
+        return <Help context="model-artifacts" />;
+      }
+
+      if (artifactsAction === "list") {
+        return <ModelListCommand filter="artifacts" />;
+      }
+
+      if (artifactsAction === "trained") {
+        return <ModelListCommand filter="trained" />;
+      }
+
+      if (artifactsAction === "deployed") {
+        return <ModelListCommand filter="deployed" />;
+      }
+
+      if (artifactsAction === "download") {
+        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)} />;
+      }
+
+      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`}
+          />
+        );
+      }
+
+      // Model upload command
+      if (artifactsAction === "upload") {
+        const destination = flags["to"];
+
+        if (!artifactArgs[0] && !destination) {
+          return (
+            <Box flexDirection="column">
+              <Text bold>Model Upload:</Text>
+              <Text> </Text>
+              <Text>  Upload to Hugging Face:</Text>
+              <Text>    model artifacts upload {"<job-id>"} --to hf --repo {"<repo>"} [--hf-token {"<token>"}] [--private]</Text>
+              <Text> </Text>
+              <Text dimColor>  Supported destinations: hf (more coming soon)</Text>
+            </Box>
+          );
+        }
+
+        if (destination === "hf") {
+          if (!artifactArgs[0]) {
+            return <ErrorMessage error="Job ID required: model artifacts upload <job-id> --to hf --repo <repo>" />;
+          }
+          const jobId = artifactArgs[0];
+          const repo = flags["repo"];
+          const hfTokenFlag = flags["hf-token"];
+          const isPrivate = flags["private"]?.toLowerCase() === "true";
+
+          if (!repo) {
+            return <ErrorMessage error="--repo is required (e.g., username/model-name)" />;
+          }
+
+          const hfToken = getHfToken(hfTokenFlag);
+          if (!hfToken) {
+            return (
+              <Box flexDirection="column">
+                <ErrorMessage error="Hugging Face token required." />
+                <Text> </Text>
+                <Text>Set your token with:</Text>
+                <Text color="cyan">  pioneer auth hf</Text>
+                <Text> </Text>
+                <Text dimColor>Get a token at: https://huggingface.co/settings/tokens</Text>
+              </Box>
+            );
+          }
+
+          return (
+            <ApiCommand
+              action={() =>
+                api.pushModelToHub(jobId, {
+                  hf_token: hfToken,
+                  repo_id: repo,
+                  private: isPrivate,
+                })
+              }
+              successMessage={`Model uploaded to Hugging Face: ${repo}`}
+            />
+          );
+        }
+
+        return <ErrorMessage error="--to is required. Supported destinations: hf" />;
+      }
+
+      return <Help context="model-artifacts" />;
     }
-    return <Help context="model" />;
+
+    if (action === "predict" || action === "generate") {
+      return (
+        <ErrorMessage
+          error={
+            "model predict and model generate are no longer supported. Use model endpoints/... and model artifacts/... instead."
+          }
+        />
+      );
+    }
+
+    return (
+      <ErrorMessage
+        error={`Unknown model command: model ${action}. Use 'pioneer model_endpoints ...', 'pioneer model endpoints ...', 'pioneer model_artifacts ...', or 'pioneer model artifacts ...'.`}
+      />
+    );
   }
 
   // Eval commands
@@ -2738,9 +4795,60 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
     if (action === "list" && !rest[0]) {
       return <ErrorMessage error="Dataset required: eval list <name[:version]>" />;
     }
+    if (action === "baseline-models") {
+      return <ApiCommand action={api.listBaselineModels} />;
+    }
     if (action === "get" && rest[0]) {
       return <ApiCommand action={() => api.getEvaluation(rest[0])} />;
     }
+    if (action === "delete" && rest[0]) {
+      const evaluationId = rest[0];
+      return (
+        <ApiCommand
+          action={async () => {
+            const result = await api.deleteEvaluation(evaluationId);
+            if (!result.ok && (result.status === 401 || result.status === 403) && result.error) {
+              const lower = result.error.toLowerCase();
+              const indicatesJwt = lower.includes("jwt") ||
+                lower.includes("api key access") ||
+                lower.includes("table") ||
+                lower.includes("requires authentication");
+              if (indicatesJwt) {
+                return {
+                  ok: false,
+                  status: result.status,
+                  error:
+                    "Evaluation deletion requires a JWT-authenticated session. Run 'pioneer auth login' to sign in with your account credentials.",
+                };
+              }
+            }
+            return result;
+          }}
+        />
+      );
+    }
+    if (action === "update") {
+      const mode = rest[0];
+      const evaluationId = mode === "project" ? rest[1] : rest[0];
+      if (!evaluationId) {
+        return <Help context="eval" />;
+      }
+      const projectId = flags["project-id"];
+      if (!projectId) {
+        return <ErrorMessage error="--project-id is required" />;
+      }
+      return (
+        <ApiCommand
+          action={() =>
+            api.updateEvaluationProject({
+              evaluation_id: evaluationId,
+              project_id: projectId,
+            })
+          }
+          successMessage={`Evaluation ${evaluationId} reassigned`}
+        />
+      );
+    }
     if (action === "create") {
       const modelId = flags["model-id"];
       const datasetStr = flags["dataset"];
@@ -2784,21 +4892,35 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
       return <ApiCommand action={api.listBenchmarks} />;
     }
     if (action === "run") {
-      const modelId = flags["model-id"];
+      const rawModelId = flags["model-id"];
       const task = flags["task"] as "ner" | "text_classification";
       const benchmark = flags["benchmark"];
       const maxSamples = flags["max-samples"] ? parseInt(flags["max-samples"], 10) : undefined;
       const split = flags["split"];
 
-      if (!modelId || !task || !benchmark) {
+      if (!rawModelId || !task || !benchmark) {
         return <ErrorMessage error="--model-id, --task, and --benchmark are required" />;
       }
+      const normalizedModelId = normalizeModelId(rawModelId);
+      if (!isUuid(normalizedModelId)) {
+        return (
+          <ErrorMessage
+            error="Benchmark model-id must be a training job UUID (example: 72c1ac92-3a89-439d-afe3-687d8a935c06)."
+          />
+        );
+      }
+      if (task !== "ner" && task !== "text_classification") {
+        return <ErrorMessage error="--task must be either ner or text_classification" />;
+      }
+      if (maxSamples !== undefined && (Number.isNaN(maxSamples) || maxSamples < 1)) {
+        return <ErrorMessage error="--max-samples must be a positive integer" />;
+      }
 
       return (
         <ApiCommand
           action={() =>
             api.startBenchmarkEvaluation({
-              model_id: modelId,
+              model_id: normalizedModelId,
               task,
               benchmark,
               max_samples: maxSamples,
@@ -2823,42 +4945,64 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
     return <Help context="benchmark" />;
   }
 
-  // Competition commands
-  if (group === "competition") {
-    if (flags.help === "true" || !action || action === "help") {
-      return <Help context="competition" />;
-    }
-    if (action === "list") {
-      return <CompetitionListCommand />;
-    }
-    if (action === "show" && rest[0]) {
-      return <ApiCommand action={() => api.getCompetitionSamples(rest[0])} />;
-    }
-    if (action === "leaderboard" && rest[0]) {
-      const limit = flags["limit"] ? parseInt(flags["limit"], 10) : undefined;
-      return <LeaderboardCommand datasetId={rest[0]} limit={limit} />;
+  // Adaptive agent commands (new short command)
+  if (group === "agent") {
+    if (flags.help === "true" || action === "help") {
+      return <Help context="agent" />;
     }
-    if (action === "submit" && rest[0]) {
-      const evalId = flags["eval-id"];
-      const displayName = flags["name"];
-
-      if (!evalId || !displayName) {
-        return <ErrorMessage error="--eval-id and --name are required" />;
-      }
 
+    if (action && !action.startsWith("-")) {
       return (
-        <ApiCommand
-          action={() =>
-            api.submitToLeaderboard(rest[0], {
-              evaluation_id: evalId,
-              display_name: displayName,
-            })
+        <ErrorMessage
+          error={
+            'Invalid agent command syntax. Use one of:\n' +
+            "pioneer agent\n" +
+            "pioneer agent --mode research"
           }
-          successMessage="Submitted to leaderboard"
         />
       );
     }
-    return <Help context="competition" />;
+
+    if (flags.message) {
+      return <ErrorMessage error="The --message flag has been removed for agent. Run `pioneer agent` or `pioneer agent --mode research` and provide input interactively." />;
+    }
+
+    const rawMode = flags.mode;
+    const validModes = ["research"];
+    const normalizedMode = rawMode ? rawMode.toLowerCase() : undefined;
+    if (normalizedMode && !validModes.includes(normalizedMode)) {
+      return <ErrorMessage error="--mode must be one of: research" />;
+    }
+    const mode = (normalizedMode === "research" ? "research" : "standard") as "standard" | "research";
+
+    let history: api.AgentChatHistoryItem[] | undefined;
+    if (flags.history) {
+      try {
+        const parsed = JSON.parse(flags.history) as unknown;
+        if (!Array.isArray(parsed)) {
+          return <ErrorMessage error="--history must be a JSON array" />;
+        }
+        history = parsed as api.AgentChatHistoryItem[];
+      } catch {
+        return <ErrorMessage error="--history must be valid JSON" />;
+      }
+    }
+
+    if (flags.filters) {
+      return <ErrorMessage error='--filters is not supported for /auto-agent/clarify. Omit this flag for now.' />;
+    }
+
+    return (
+      <AgentInteractivePrompt
+        conversationId={flags["conversation-id"]}
+        history={history}
+        mode={mode}
+      />
+    );
+  }
+
+  if (group === "notebook") {
+    return <ErrorMessage error="The notebook command is deprecated and has been removed from this CLI." />;
   }
 
   return <Help />;
@@ -2872,7 +5016,7 @@ import packageJson from "../package.json";
 
 async function main() {
   const argv = process.argv.slice(2);
-  const { command, flags } = parseArgs(argv);
+  const { command, flags, parseErrors } = parseArgs(argv);
 
   // Handle version flag early (before React render)
   if (flags.version === "true" || flags.v === "true") {
@@ -2880,7 +5024,7 @@ async function main() {
     process.exit(0);
   }
 
-  await render(<App command={command} flags={flags} />).waitUntilExit();
+  await render(<App command={command} flags={flags} parseErrors={parseErrors} />).waitUntilExit();
 }
 
 main();