@fastino-ai/pioneer-cli 0.2.7 → 0.2.9

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,9 @@ import * as path from "path";
 import {
   getApiKey,
   getBaseUrl,
+  getMleModel,
+  getLastAgentConversationId,
+  setLastAgentConversationId,
   saveConfig,
   clearApiKey,
   getHfToken,
@@ -21,7 +24,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,
@@ -150,9 +153,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];
@@ -163,7 +187,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
@@ -173,14 +202,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" };
+  }
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -224,24 +276,28 @@ interface TelemetryPromptProps {
 
 const TelemetryPrompt: React.FC<TelemetryPromptProps> = ({ onComplete }) => {
   const [selected, setSelected] = useState<"yes" | "no">("yes");
+  const { isRawModeSupported } = useStdin();
 
-  useInput((input, key) => {
-    if (key.leftArrow || key.rightArrow) {
-      setSelected((s) => (s === "yes" ? "no" : "yes"));
-    }
-    if (key.return) {
-      setTelemetryEnabled(selected === "yes");
-      onComplete();
-    }
-    if (input === "y" || input === "Y") {
-      setTelemetryEnabled(true);
-      onComplete();
-    }
-    if (input === "n" || input === "N") {
-      setTelemetryEnabled(false);
-      onComplete();
-    }
-  });
+  useInput(
+    (input, key) => {
+      if (key.leftArrow || key.rightArrow) {
+        setSelected((s) => (s === "yes" ? "no" : "yes"));
+      }
+      if (key.return) {
+        setTelemetryEnabled(selected === "yes");
+        onComplete();
+      }
+      if (input === "y" || input === "Y") {
+        setTelemetryEnabled(true);
+        onComplete();
+      }
+      if (input === "n" || input === "N") {
+        setTelemetryEnabled(false);
+        onComplete();
+      }
+    },
+    { isActive: isRawModeSupported }
+  );
 
   return (
     <Box flexDirection="column" paddingX={1}>
@@ -663,138 +719,1530 @@ 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 role =
+        item.role === "user" || item.role === "assistant" || item.role === "tool"
+          ? item.role
+          : "assistant";
+      const message: HistoryMessage = {
+        role,
+        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): call is { id: string; name: string; args: Record<string, unknown> } =>
+              Boolean(call) &&
+              typeof call.id === "string" &&
+              typeof call.name === "string" &&
+              typeof call.args === "object" &&
+              call.args !== null
+          )
+          .map((call) => ({
+            id: call.id,
+            name: call.name,
+            args: call.args,
+          }));
+      }
+
+      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 persistConversation = (nextConversationId?: string) => {
+      if (nextConversationId) {
+        setLastAgentConversationId(nextConversationId);
+      }
+    };
+    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?.conversation_id) {
+          persistConversation(result.data.conversation_id);
+        }
+        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);
+      };
 
-  if (state === "loading") {
-    return <Loading />;
-  }
+      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.`
+            );
+          }
+
+          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;
+            persistConversation(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 [];
-  }
+export function AutoAgentInteractiveSession({
+  conversationId: initialConversationId,
+  history,
+  mode,
+  firstMessage,
+  allowSessionCreation = true,
+}: {
+  conversationId?: string;
+  history?: api.AgentChatHistoryItem[];
+  mode: "standard" | "research";
+  firstMessage?: string;
+  allowSessionCreation?: boolean;
+}) {
+  const { isRawModeSupported } = useStdin();
+  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 normalizeTurnRole = (role: string): AutoAgentTurnRole => {
+    const normalized = role?.trim().toLowerCase();
+    return normalized === "user" || normalized === "human" ? "user" : "assistant";
+  };
+  const [isHistoryLoading, setIsHistoryLoading] = useState(
+    Boolean(initialConversationId) && history === undefined
+  );
+  const [isResumeSessionUsable, setIsResumeSessionUsable] = useState(true);
+  const [turns, setTurns] = useState<AutoAgentTurn[]>(
+    (history ?? []).map((entry) => ({
+      role: normalizeTurnRole(entry.role),
+      content: entry.content,
+    }))
+  );
+  const [inputHistory, setInputHistory] = useState<string[]>([]);
+  const [inputHistoryIndex, setInputHistoryIndex] = useState(-1);
+  const didSeedFirstMessage = useRef(false);
+  const setInputValue = (nextValue: string) => {
+    setInput(nextValue);
+    setInputHistoryIndex(-1);
+  };
+  const normalizeSessionUserHistory = (items: api.AgentChatHistoryItem[]) =>
+    items
+      .filter((message) => {
+        const normalizedRole = message.role?.trim().toLowerCase();
+        return (
+          (normalizedRole === "user" || normalizedRole === "human") &&
+          typeof message.content === "string"
+        );
+      })
+      .map((message) => message.content.trim())
+      .filter((content): content is string => content.length > 0);
+  const mapHistoryToTurns = (items: api.AgentChatHistoryItem[]) =>
+    items.map((entry) => ({
+      role: normalizeTurnRole(entry.role),
+      content: entry.content,
+    }));
+
+  const commitInputToHistory = (message: string) => {
+    const normalized = message.trim();
+    if (!normalized) {
+      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";
+    setInputHistory((previous) => {
+      if (previous.length > 0 && previous[previous.length - 1] === normalized) {
+        return previous;
+      }
+      return [...previous, normalized];
+    });
+  };
 
-    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
+  useEffect(() => {
+    const restoredHistory = history ?? [];
+    setHistoryState(restoredHistory);
+    setTurns(mapHistoryToTurns(restoredHistory));
+    setInputHistory(normalizeSessionUserHistory(restoredHistory));
+    if (history !== undefined || !initialConversationId) {
+      setIsHistoryLoading(false);
     }
+  }, [history]);
 
-    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,
-    };
-  });
-}
+  useEffect(() => {
+    setTurns(mapHistoryToTurns(historyState));
+  }, [historyState]);
 
-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;
-}
+  useEffect(() => {
+    if (!initialConversationId || history !== undefined) {
+      setIsHistoryLoading(false);
+      return;
+    }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Generate Command (saves to local file when --save is false)
-// ─────────────────────────────────────────────────────────────────────────────
+    let isActive = true;
+    const hydrateSessionHistory = async () => {
+      const result = await api.getAgentSession(initialConversationId);
+      if (!isActive) {
+        return;
+      }
 
-interface GenerateCommandProps<T> {
-  action: () => Promise<api.ApiResult<T>>;
-  datasetName: string;
-  datasetType: string;
-  saveToRemote: boolean;
-}
+      if (!result.ok) {
+        const lowerError = (result.error || "").toLowerCase();
+        const notFound =
+          result.status === 404 ||
+          lowerError.includes("session not found") ||
+          lowerError.includes("not found") ||
+          lowerError.includes("does not exist");
+        if (notFound) {
+          setHistoryState([]);
+          setTurns([]);
+          setError("Could not load session history. This session could not be found on the backend. Resume is not available.");
+          setIsResumeSessionUsable(false);
+          setIsHistoryLoading(false);
+          return;
+        }
+        setError(
+          `Could not load session history for ${initialConversationId}: ${result.error || "Unable to load conversation history."}` +
+            " Proceeding without preloaded history."
+        );
+        setIsResumeSessionUsable(true);
+        setIsHistoryLoading(false);
+        return;
+      }
 
-interface GenerateResult {
-  data?: unknown[];
-  success?: boolean;
-  dataset?: { id?: string; dataset_name?: string };
+      const restoredMessages = (result.data?.messages ?? [])
+        .map((message) => {
+          if (
+            typeof message.role !== "string" ||
+            typeof message.content !== "string"
+          ) {
+            return undefined;
+          }
+
+          return {
+            role: message.role,
+            content: message.content,
+          } as api.AgentChatHistoryItem;
+        })
+        .filter((message): message is api.AgentChatHistoryItem => message !== undefined);
+
+      setHistoryState(restoredMessages);
+      setTurns(mapHistoryToTurns(restoredMessages));
+      setInputHistory(normalizeSessionUserHistory(restoredMessages));
+
+      setIsHistoryLoading(false);
+    };
+
+    void hydrateSessionHistory();
+
+    return () => {
+      isActive = false;
+    };
+  }, [initialConversationId, history]);
+
+  const runAutoTurn = async (rawMessage: string) => {
+    if (isHistoryLoading) {
+      return;
+    }
+    const trimmed = rawMessage.trim();
+    if (!trimmed || isLoading) {
+      return;
+    }
+    commitInputToHistory(trimmed);
+    if (!isResumeSessionUsable && !allowSessionCreation) {
+      setError("Unable to resume this session because the conversation record is unavailable.");
+      setIsLoading(false);
+      setStatusHint("Ready for next message.");
+      return;
+    }
+
+    const nextHistory: api.AgentChatHistoryItem[] = [
+      ...historyState,
+      { role: "user", content: trimmed },
+    ];
+    setHistoryState(nextHistory);
+    setInputValue("");
+    setError("");
+    setIsLoading(true);
+    setStatusHint("Thinking...");
+
+    let activeConversationId = conversationId;
+
+    if (!activeConversationId && !allowSessionCreation) {
+      setError("Unable to resume this session because no valid conversation id is available.");
+      setIsLoading(false);
+      setStatusHint("Ready for next message.");
+      return;
+    }
+
+    if (!activeConversationId) {
+      setStatusHint("Creating conversation...");
+      const createdSession = await api.createAgentSession({
+        first_message: trimmed,
+        title: trimmed.slice(0, 80) || "New agent session",
+      });
+      if (!createdSession.ok) {
+        setError(`Failed to create conversation: ${createdSession.error || "Unknown error."}`);
+        setIsLoading(false);
+        setStatusHint("Ready for next message.");
+        return;
+      }
+      const createdSessionId = createdSession.data?.id;
+      if (!createdSessionId) {
+        setError("Failed to create conversation: Missing conversation id from server response.");
+        setIsLoading(false);
+        setStatusHint("Ready for next message.");
+        return;
+      }
+      activeConversationId = createdSessionId;
+      setConversationId(activeConversationId);
+      persistConversation(activeConversationId);
+    }
+
+    const sendTurn = async (requestConversationId: string | undefined) =>
+      api.agentChat({
+        message: trimmed,
+        ...(requestConversationId ? { conversation_id: requestConversationId } : {}),
+        ...(nextHistory.length ? { history: nextHistory } : {}),
+      });
+
+    let result = await sendTurn(activeConversationId);
+    const lowerError = (result.error || "").toLowerCase();
+    const notFound =
+      result.status === 404 ||
+      lowerError.includes("session not found") ||
+      lowerError.includes("not found") ||
+      lowerError.includes("does not exist");
+
+    if (!result.ok) {
+      if (lowerError.includes("failed to get session") && notFound) {
+        if (!allowSessionCreation) {
+          setError("Unable to resume this session. It is not available on the backend.");
+          setIsResumeSessionUsable(false);
+        } else {
+          setError("Failed to resume session on the backend. Please start a new message to create a new session.");
+        }
+      } else if (
+        result.status === 403 &&
+        lowerError.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;
+    }
+
+    const data = result.data;
+    if (!data) {
+      setError("Agent request did not return a usable response.");
+      setIsLoading(false);
+      setStatusHint("Ready for next message.");
+      return;
+    }
+
+    const answer = data.answer?.trim() || "No response content yet.";
+    setError("");
+    const persistedConversationId = activeConversationId ?? data.conversation_id;
+    if (persistedConversationId) {
+      setConversationId(persistedConversationId);
+      persistConversation(persistedConversationId);
+    }
+
+    const assistantTurn: api.AgentChatHistoryItem = { role: "assistant", content: answer };
+    if (persistedConversationId) {
+      void api.appendSessionMessages(persistedConversationId, {
+        messages: [
+          { role: "user", content: trimmed },
+          { role: "assistant", content: answer },
+        ],
+      });
+    }
+    setHistoryState((current) => [...current, assistantTurn]);
+    setStatusHint("Ready for next message.");
+    setIsLoading(false);
+  };
+
+  useInput(
+    (character, key) => {
+      if (key.return) {
+        void runAutoTurn(input);
+        return;
+      }
+
+      if (key.backspace || key.delete) {
+        setInputValue(input.slice(0, -1));
+        return;
+      }
+
+      if (key.upArrow) {
+        if (!inputHistory.length) {
+          return;
+        }
+        const nextIndex =
+          inputHistoryIndex === -1 ? inputHistory.length - 1 : Math.max(0, inputHistoryIndex - 1);
+        setInputHistoryIndex(nextIndex);
+        setInput(inputHistory[nextIndex] ?? "");
+        return;
+      }
+
+      if (key.downArrow) {
+        if (inputHistoryIndex === -1) {
+          return;
+        }
+        const nextIndex = inputHistoryIndex + 1;
+        if (nextIndex >= inputHistory.length) {
+          setInputHistoryIndex(-1);
+          setInput("");
+          return;
+        }
+        setInputHistoryIndex(nextIndex);
+        setInput(inputHistory[nextIndex] ?? "");
+        return;
+      }
+
+      if (
+        key.tab ||
+        key.leftArrow ||
+        key.rightArrow ||
+        key.escape ||
+        key.ctrl ||
+        key.meta
+      ) {
+        return;
+      }
+
+      if (character) {
+        setInputValue(input + character);
+      }
+    },
+    { isActive: isRawModeSupported && !isLoading }
+  );
+
+  const persistConversation = (nextConversationId?: string) => {
+    if (nextConversationId) {
+      setLastAgentConversationId(nextConversationId);
+    }
+  };
+
+  useEffect(() => {
+    return () => {
+      persistConversation(conversationId);
+    };
+  }, [conversationId]);
+
+  useEffect(() => {
+    if (!firstMessage || didSeedFirstMessage.current) {
+      return;
+    }
+    if (isHistoryLoading) {
+      return;
+    }
+
+    didSeedFirstMessage.current = true;
+    void runAutoTurn(firstMessage);
+  }, [firstMessage, isHistoryLoading]);
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>Agent mode selected.</Text>
+      <Text>
+        Mode: {mode === "research" ? "research" : "standard"}{" "}
+        {conversationId ? `(conversation ${conversationId})` : "(new conversation)"}
+      </Text>
+      {isHistoryLoading ? <Loading message="Loading conversation history..." /> : null}
+      <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}
+            focus={false}
+            onChange={() => {}}
+            onSubmit={() => {}}
+          />
+        )}
+      </Box>
+      {error && (
+        <Box marginTop={1}>
+          <ErrorMessage error={error} />
+        </Box>
+      )}
+      <Text dimColor>Type Ctrl+C to exit.</Text>
+    </Box>
+  );
+}
+
+export function AgentResumeCommand({
+  mode,
+}: {
+  mode?: "standard" | "research";
+}) {
+  const { isRawModeSupported } = useStdin();
+  const [isReady, setReady] = useState(false);
+  const [selectedSession, setSelectedSession] = useState<
+    {
+      id: string;
+    } | undefined
+  >();
+  const [defaultSessionId] = useState(() => getLastAgentConversationId());
+  const [searchQuery, setSearchQuery] = useState("");
+  const [highlightIndex, setHighlightIndex] = useState(0);
+  const [sessions, setSessions] = useState<
+    Array<{
+      id: string;
+      title: string;
+      updated_at: string;
+      is_archived: boolean;
+    }>
+  >([]);
+  const [error, setError] = useState("");
+  const [statusHint, setStatusHint] = useState("Loading sessions...");
+  const [isSessionLoading, setSessionLoading] = useState(false);
+  const [sessionError, setSessionError] = useState("");
+  const [selectedSessionHistory, setSelectedSessionHistory] = useState<
+    api.AgentChatHistoryItem[] | undefined
+  >(undefined);
+
+  useEffect(() => {
+    if (!selectedSession?.id) {
+      setSelectedSessionHistory(undefined);
+      setSessionError("");
+      return;
+    }
+
+    let isActive = true;
+    const loadSessionHistory = async () => {
+      setSessionLoading(true);
+      setSessionError("");
+
+      const result = await api.getAgentSession(selectedSession.id);
+      if (!isActive) {
+        return;
+      }
+
+      if (!result.ok) {
+        setSessionError(
+          `Could not load selected session ${selectedSession.id}: ${result.error || "Unknown error."}`
+        );
+        setSelectedSessionHistory(undefined);
+        setSessionLoading(false);
+        return;
+      }
+
+      const restoredMessages = (result.data?.messages ?? [])
+        .map((message) => {
+          if (typeof message?.role !== "string" || typeof message?.content !== "string") {
+            return undefined;
+          }
+          return {
+            role: message.role,
+            content: message.content,
+          } as api.AgentChatHistoryItem;
+        })
+        .filter((message): message is api.AgentChatHistoryItem => message !== undefined);
+
+      setSelectedSessionHistory(restoredMessages);
+      setSessionLoading(false);
+    };
+
+    void loadSessionHistory();
+
+    return () => {
+      isActive = false;
+      setSessionLoading(false);
+    };
+  }, [selectedSession?.id]);
+
+  useEffect(() => {
+    let isActive = true;
+    const loadSessions = async () => {
+      try {
+        const result = await api.listAgentSessions();
+        if (!isActive) {
+          return;
+        }
+        if (!result.ok) {
+          setError(result.error || "Could not load agent sessions.");
+          setStatusHint("");
+          setReady(true);
+          setSessions([]);
+          return;
+        }
+        const remoteSessions = (result.data?.sessions ?? []).map((session) => ({
+          id: session.id,
+          title: session.title || "(untitled)",
+          updated_at: session.updated_at || new Date().toISOString(),
+          is_archived: session.is_archived,
+        }));
+        remoteSessions.sort((a, b) => {
+          const aTime = Date.parse(a.updated_at);
+          const bTime = Date.parse(b.updated_at);
+          if (Number.isNaN(aTime) || Number.isNaN(bTime)) {
+            return 0;
+          }
+          return bTime - aTime;
+        });
+        if (defaultSessionId) {
+          const lastIndex = remoteSessions.findIndex((session) => session.id === defaultSessionId);
+          if (lastIndex >= 0) {
+            setHighlightIndex(lastIndex);
+          }
+        }
+        setSessions(remoteSessions);
+        setStatusHint("");
+        setReady(true);
+        return;
+      } catch (err) {
+        if (!isActive) {
+          return;
+        }
+        const message = err instanceof Error ? err.message : "Could not load agent sessions.";
+        setError(message);
+        setStatusHint("");
+        setSessions([]);
+        setReady(true);
+      }
+    };
+    void loadSessions();
+
+    return () => {
+      isActive = false;
+    };
+  }, []);
+
+  const normalizeSessionLabel = (session: {
+    id: string;
+    title: string;
+    is_archived: boolean;
+    updated_at: string;
+  }) => `${session.title || "(untitled)"} ${session.is_archived ? "[archived] " : ""}(updated ${session.updated_at})`;
+
+  const matchingSessions = sessions.filter((session) => {
+    const searchable = `${session.title} ${session.id}`.toLowerCase();
+    const normalizedQuery = searchQuery.trim().toLowerCase();
+    return normalizedQuery.length === 0 || searchable.includes(normalizedQuery);
+  });
+
+  useInput((_, key) => {
+    if (!matchingSessions.length) return;
+    if (key.upArrow) {
+      setHighlightIndex((idx) => (idx === 0 ? matchingSessions.length - 1 : idx - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setHighlightIndex((idx) => (idx === matchingSessions.length - 1 ? 0 : idx + 1));
+      return;
+    }
+    if (key.return) {
+      const selected = matchingSessions[highlightIndex];
+      if (!selected) {
+        setError("No matching sessions found.");
+        return;
+      }
+      setError("");
+      setSelectedSession({ id: selected.id });
+    }
+  }, { isActive: isRawModeSupported });
+
+  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 --help</Text>
+      </Box>
+    );
+  }
+
+  if (error && !sessions.length) {
+    return <ErrorMessage error={error} />;
+  }
+
+  if (!isReady) {
+    return <Loading message={statusHint || "Loading sessions..."} />;
+  }
+
+  if (!sessions.length) {
+    return (
+      <ErrorMessage
+        error="No agent sessions found. Start a new conversation with `pioneer agent` and try again."
+      />
+    );
+  }
+
+  if (selectedSession?.id) {
+    if (isSessionLoading) {
+      return <Loading message={`Loading conversation ${selectedSession.id}...`} />;
+    }
+    if (sessionError) {
+      return <ErrorMessage error={sessionError} />;
+    }
+
+    return (
+      <AutoAgentInteractiveSession
+        conversationId={selectedSession.id}
+        mode={mode ?? "standard"}
+        history={selectedSessionHistory}
+        allowSessionCreation={false}
+      />
+    );
+  }
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>Agent sessions:</Text>
+      <Text>
+        {defaultSessionId ? `Last session: ${defaultSessionId}. ` : ""}
+        Type to filter. Use ↑/↓ to navigate and Enter to select.
+      </Text>
+      <Text dimColor>Search title or session ID.</Text>
+      <Text> </Text>
+      {matchingSessions.length === 0 ? (
+        <Text color="yellow">No sessions match "{searchQuery}".</Text>
+      ) : (
+        matchingSessions.slice(0, 12).map((session, index) => {
+          const isSelected = index === highlightIndex;
+          return (
+            <Text key={session.id} color={isSelected ? "cyan" : undefined}>
+              {`${isSelected ? ">" : " "} ${normalizeSessionLabel(session)} (${session.id})`}
+            </Text>
+          );
+        })
+      )}
+      <Box marginTop={1}>
+        <Text color="cyan">&gt; </Text>
+        <TextInput
+          value={searchQuery}
+          onChange={setSearchQuery}
+          onSubmit={(rawValue) => {
+            const trimmed = rawValue.trim().toLowerCase();
+            if (!trimmed && !matchingSessions.length) {
+              return;
+            }
+            const exactMatch = matchingSessions.find(
+              (session) =>
+                session.id.toLowerCase() === trimmed ||
+                session.title.toLowerCase() === trimmed
+            );
+            const selected = exactMatch ?? matchingSessions[highlightIndex];
+            if (!selected?.id) {
+              setError("No matching session found.");
+              return;
+            }
+            setError("");
+            setSelectedSession({ id: selected.id });
+          }}
+        />
+      </Box>
+      {error && <ErrorMessage error={error} />}
+    </Box>
+  );
+}
+
+function AgentInteractivePrompt({
+  conversationId,
+  history,
+  mode,
+  allowSessionCreation = true,
+}: {
+  conversationId?: string;
+  history?: api.AgentChatHistoryItem[];
+  mode?: "standard" | "research";
+  allowSessionCreation?: boolean;
+}) {
+  const [input, setInput] = useState("");
+  const [inputHistory, setInputHistory] = useState<string[]>([]);
+  const [inputHistoryIndex, setInputHistoryIndex] = useState(-1);
+  const [isReady, setReady] = useState(false);
+  const [message, setMessage] = useState("");
+  const { isRawModeSupported } = useStdin();
+  const shouldExitImmediately = !isRawModeSupported;
+
+  const commitInputToHistory = (value: string) => {
+    const normalized = value.trim();
+    if (!normalized) {
+      return;
+    }
+    setInputHistory((previous) => {
+      if (previous.length > 0 && previous[previous.length - 1] === normalized) {
+        return previous;
+      }
+      return [...previous, normalized];
+    });
+  };
+
+  const setInputValue = (nextValue: string) => {
+    setInput(nextValue);
+    setInputHistoryIndex(-1);
+  };
+
+  useInput(
+    (character, key) => {
+      if (key.return) {
+        const trimmed = input.trim();
+        if (!trimmed) {
+          return;
+        }
+        commitInputToHistory(trimmed);
+        setMessage(trimmed);
+        setReady(true);
+        return;
+      }
+
+      if (key.backspace || key.delete) {
+        setInputValue(input.slice(0, -1));
+        return;
+      }
+
+      if (key.upArrow) {
+        if (!inputHistory.length) {
+          return;
+        }
+        const nextIndex =
+          inputHistoryIndex === -1 ? inputHistory.length - 1 : Math.max(0, inputHistoryIndex - 1);
+        setInputHistoryIndex(nextIndex);
+        setInput(inputHistory[nextIndex] ?? "");
+        return;
+      }
+
+      if (key.downArrow) {
+        if (inputHistoryIndex === -1) {
+          return;
+        }
+        const nextIndex = inputHistoryIndex + 1;
+        if (nextIndex >= inputHistory.length) {
+          setInputHistoryIndex(-1);
+          setInput("");
+          return;
+        }
+        setInputHistoryIndex(nextIndex);
+        setInput(inputHistory[nextIndex] ?? "");
+        return;
+      }
+
+      if (
+        key.tab ||
+        key.leftArrow ||
+        key.rightArrow ||
+        key.escape ||
+        key.ctrl ||
+        key.meta
+      ) {
+        return;
+      }
+
+      if (character) {
+        setInputValue(input + character);
+      }
+    },
+    { isActive: isRawModeSupported && !isReady }
+  );
+
+  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}
+            focus={false}
+            onChange={() => {}}
+            onSubmit={() => {}}
+          />
+        </Box>
+        <Text dimColor>Type Ctrl+C to cancel.</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <AutoAgentInteractiveSession
+      conversationId={conversationId}
+      history={history}
+      mode={mode === "research" ? "research" : "standard"}
+      firstMessage={message}
+      allowSessionCreation={allowSessionCreation}
+    />
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 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 { isRawModeSupported } = useStdin();
+  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);
+      }
+    },
+    { isActive: isRawModeSupported }
+  );
+
+  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[];
+  success?: boolean;
+  dataset?: { id?: string; dataset_name?: string };
 }
 
 function GenerateCommand<T extends GenerateResult>({
@@ -867,271 +2315,6 @@ function GenerateCommand<T extends GenerateResult>({
   );
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Notebook Run Command
-// ─────────────────────────────────────────────────────────────────────────────
-
-interface NotebookCell {
-  cell_type: "code" | "markdown" | "raw";
-  source: string[];
-  metadata?: Record<string, unknown>;
-}
-
-interface NotebookFile {
-  cells: NotebookCell[];
-  metadata?: Record<string, unknown>;
-  nbformat: number;
-  nbformat_minor: number;
-}
-
-function readNotebookFile(filePath: string): NotebookFile {
-  const absPath = path.resolve(filePath);
-  if (!fs.existsSync(absPath)) {
-    throw new Error(`File not found: ${absPath}`);
-  }
-  const content = fs.readFileSync(absPath, "utf-8");
-  return JSON.parse(content) as NotebookFile;
-}
-
-interface NotebookRunCommandProps {
-  filePath: string;
-  gpu: string;
-  loadFelixHelpers: boolean;
-}
-
-function NotebookRunCommand({ filePath, gpu, loadFelixHelpers }: NotebookRunCommandProps) {
-  const { exit } = useApp();
-  const [phase, setPhase] = useState<"reading" | "session" | "running" | "done" | "error">("reading");
-  const [sessionId, setSessionId] = useState<string | null>(null);
-  const [currentCell, setCurrentCell] = useState(0);
-  const [totalCells, setTotalCells] = useState(0);
-  const [outputs, setOutputs] = useState<Array<{ cell: number; source: string; result: api.ExecuteCodeResponse | null; error?: string }>>([]);
-  const [error, setError] = useState("");
-
-  useEffect(() => {
-    (async () => {
-      // 1. Read notebook
-      let notebook: NotebookFile;
-      try {
-        notebook = readNotebookFile(filePath);
-      } catch (e) {
-        setError(e instanceof Error ? e.message : String(e));
-        setPhase("error");
-        setTimeout(() => exit(), 500);
-        return;
-      }
-
-      const codeCells = notebook.cells.filter((c) => c.cell_type === "code");
-      setTotalCells(codeCells.length);
-
-      if (codeCells.length === 0) {
-        setError("No code cells found in notebook");
-        setPhase("error");
-        setTimeout(() => exit(), 500);
-        return;
-      }
-
-      // 2. Create session
-      setPhase("session");
-      const sessionResult = await api.createNotebookSession({
-        gpu,
-        load_felix_helpers: loadFelixHelpers,
-      });
-
-      if (!sessionResult.ok || !sessionResult.data) {
-        setError(sessionResult.error ?? "Failed to create notebook session");
-        setPhase("error");
-        setTimeout(() => exit(), 500);
-        return;
-      }
-
-      let sid = sessionResult.data.session_id;
-      setSessionId(sid);
-
-      // Poll until session is ready (if status is 'creating')
-      if (sessionResult.data.status === "creating") {
-        let ready = false;
-        for (let attempt = 0; attempt < 60; attempt++) {
-          await new Promise((r) => setTimeout(r, 2000));
-          const status = await api.getNotebookSessionStatus(sid);
-          if (status.ok && status.data?.status === "ready") {
-            // Status response returns the real session_id when ready
-            sid = status.data.session_id;
-            setSessionId(sid);
-            ready = true;
-            break;
-          }
-          if (status.ok && status.data?.status === "failed") {
-            setError(status.data.error ?? "Session creation failed");
-            setPhase("error");
-            setTimeout(() => exit(), 500);
-            return;
-          }
-        }
-        if (!ready) {
-          setError("Session creation timed out after 2 minutes");
-          setPhase("error");
-          setTimeout(() => exit(), 500);
-          return;
-        }
-      }
-
-      // 3. Execute cells sequentially
-      setPhase("running");
-      const cellOutputs: typeof outputs = [];
-
-      for (let i = 0; i < codeCells.length; i++) {
-        setCurrentCell(i + 1);
-        const cell = codeCells[i];
-        const code = Array.isArray(cell.source) ? cell.source.join("") : String(cell.source);
-
-        if (!code.trim()) {
-          cellOutputs.push({ cell: i + 1, source: code, result: null });
-          continue;
-        }
-
-        const execResult = await api.executeNotebookCode({
-          code,
-          session_id: sid,
-          cell_id: `cell-${i}`,
-        });
-
-        if (!execResult.ok) {
-          cellOutputs.push({ cell: i + 1, source: code, result: null, error: execResult.error ?? "Execution failed" });
-          // Continue running remaining cells despite errors
-        } else {
-          cellOutputs.push({ cell: i + 1, source: code, result: execResult.data ?? null });
-        }
-
-        setOutputs([...cellOutputs]);
-      }
-
-      setPhase("done");
-      setTimeout(() => exit(), 1000);
-    })();
-  }, [filePath, gpu, loadFelixHelpers, exit]);
-
-  if (phase === "error") {
-    return <ErrorMessage error={error} />;
-  }
-
-  if (phase === "reading") {
-    return <Loading message="Reading notebook..." />;
-  }
-
-  if (phase === "session") {
-    return <Loading message={`Creating ${gpu} session...`} />;
-  }
-
-  // Render outputs
-  const renderCellOutput = (entry: (typeof outputs)[0]) => {
-    const lines: string[] = [];
-
-    if (entry.error) {
-      lines.push(`  Error: ${entry.error}`);
-      return lines.join("\n");
-    }
-
-    if (!entry.result) {
-      lines.push("  (empty cell)");
-      return lines.join("\n");
-    }
-
-    for (const out of entry.result.outputs) {
-      if (out.type === "stream" && out.text) {
-        // Truncate long stream output
-        const text = out.text.length > 2000 ? out.text.slice(0, 2000) + "\n  ... (truncated)" : out.text;
-        lines.push(text);
-      } else if (out.type === "execute_result" || out.type === "display_data") {
-        if (out.data?.["text/plain"]) {
-          lines.push(out.data["text/plain"]);
-        } else if (out.text) {
-          lines.push(out.text);
-        }
-        if (out.data?.["image/png"]) {
-          lines.push("  [image output]");
-        }
-      } else if (out.type === "error") {
-        lines.push(`  ${out.ename}: ${out.evalue}`);
-        if (out.traceback) {
-          // Strip ANSI codes for cleaner terminal output
-          lines.push(out.traceback.map((l) => l.replace(/\x1b\[[0-9;]*m/g, "")).join("\n"));
-        }
-      }
-    }
-
-    if (entry.result.execution_time_ms) {
-      lines.push(`  (${(entry.result.execution_time_ms / 1000).toFixed(1)}s)`);
-    }
-
-    return lines.join("\n") || "  (no output)";
-  };
-
-  return (
-    <Box flexDirection="column">
-      {phase === "running" && (
-        <Box>
-          <Text color="yellow"><Spinner type="dots" /></Text>
-          <Text> Running cell {currentCell}/{totalCells}...</Text>
-        </Box>
-      )}
-
-      <Static items={outputs}>
-        {(entry) => (
-          <Box key={entry.cell} flexDirection="column" marginBottom={1}>
-            <Text bold color="cyan">── Cell {entry.cell}/{totalCells} ──</Text>
-            <Text dimColor>{entry.source.split("\n").slice(0, 3).join("\n")}{entry.source.split("\n").length > 3 ? "\n  ..." : ""}</Text>
-            <Text color={entry.error || (entry.result && !entry.result.success) ? "red" : undefined}>
-              {renderCellOutput(entry)}
-            </Text>
-          </Box>
-        )}
-      </Static>
-
-      {phase === "done" && (
-        <Box flexDirection="column" marginTop={1}>
-          <Success message={`Notebook complete: ${outputs.length} cells executed`} />
-          {sessionId && <Text dimColor>Session: {sessionId}</Text>}
-          {outputs.some((o) => o.error || (o.result && !o.result.success)) && (
-            <Text color="yellow">Some cells had errors — check output above</Text>
-          )}
-        </Box>
-      )}
-    </Box>
-  );
-}
-
-function createBlankNotebook(name: string): string {
-  const notebook: NotebookFile = {
-    cells: [
-      {
-        cell_type: "markdown",
-        source: [`# ${name}\n`],
-        metadata: {},
-      },
-      {
-        cell_type: "code",
-        source: [],
-        metadata: {},
-      },
-    ],
-    metadata: {
-      kernelspec: { display_name: "Python 3", language: "python", name: "python3" },
-      language_info: { name: "python", version: "3.12.0" },
-    },
-    nbformat: 4,
-    nbformat_minor: 4,
-  };
-
-  const filename = name.endsWith(".ipynb") ? name : `${name}.ipynb`;
-  const filePath = path.resolve(filename);
-  if (fs.existsSync(filePath)) {
-    throw new Error(`File already exists: ${filePath}`);
-  }
-  fs.writeFileSync(filePath, JSON.stringify(notebook, null, 1));
-  return filePath;
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Helper: Infer format from file extension
 // ─────────────────────────────────────────────────────────────────────────────
@@ -1200,179 +2383,21 @@ function DatasetListCommand() {
             <Text>
               {"  "}<Text color="yellow">{ds.dataset_name}:{ds.version_number || "v1"}</Text> <Text dimColor>({ds.dataset_type}, {ds.sample_size} examples)</Text>
             </Text>
-            <Text dimColor>    {ds.id}</Text>
-          </Box>
-        ))
-      )}
-      <Text> </Text>
-      <Text bold color="cyan">Local Datasets ({localDatasets.length})</Text>
-      {localDatasets.length === 0 ? (
-        <Text dimColor>  No local datasets in ./datasets/</Text>
-      ) : (
-        localDatasets.map((ds) => (
-          <Text key={ds.id}>
-            {"  "}<Text color="green">{ds.name}</Text> <Text dimColor>({ds.type}, {ds.sample_size} examples)</Text>
-          </Text>
-        ))
-      )}
-    </Box>
-  );
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Competition List Command
-// ─────────────────────────────────────────────────────────────────────────────
-
-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>
+            <Text dimColor>    {ds.id}</Text>
           </Box>
-        );
-      })}
+        ))
+      )}
+      <Text> </Text>
+      <Text bold color="cyan">Local Datasets ({localDatasets.length})</Text>
+      {localDatasets.length === 0 ? (
+        <Text dimColor>  No local datasets in ./datasets/</Text>
+      ) : (
+        localDatasets.map((ds) => (
+          <Text key={ds.id}>
+            {"  "}<Text color="green">{ds.name}</Text> <Text dimColor>({ds.type}, {ds.sample_size} examples)</Text>
+          </Text>
+        ))
+      )}
     </Box>
   );
 }
@@ -2004,11 +3029,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;
@@ -2042,11 +3110,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>
@@ -2135,6 +3234,9 @@ interface ModelGenerateCommandProps {
   systemMsg?: string;
   maxTokens: number;
   temperature: number;
+  topP?: number;
+  includeReasoningTrace?: boolean;
+  projectId?: string;
 }
 
 function normalizeBaseModels(
@@ -2157,18 +3259,74 @@ function formatDecoderSuggestions(decoderIds: string[]): string {
   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 | null>(null);
+  const [data, setData] = useState<api.InferenceResponse | api.TextCompletionResponse | null>(
+    null
+  );
   const [error, setError] = useState("");
 
   useEffect(() => {
@@ -2181,8 +3339,9 @@ function ModelGenerateCommand({
           ? normalizeBaseModels(baseModelsResult.data)
           : [];
       const decoderModelIds = baseModels
-        .filter((model) => model.type === "decoder")
+        .filter((model) => isDecoderModel(model) && modelSupportsDecoderInference(model))
         .map((model) => model.id);
+      const normalizedModelId = normalizeModelId(modelId);
 
       const fail = (message: string) => {
         if (!active) return;
@@ -2191,38 +3350,35 @@ function ModelGenerateCommand({
         setTimeout(() => exit(), 500);
       };
 
-      if (modelId === "base") {
-        fail(
-          "Model 'base' is encoder-only and cannot run decoder generation. Use 'model predict' for encoder tasks." +
-            formatDecoderSuggestions(decoderModelIds)
-        );
-        return;
-      }
-
-      const matchedBaseModel = baseModels.find((model) => model.id === modelId);
-      if (matchedBaseModel && matchedBaseModel.type !== "decoder") {
+      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 '${matchedBaseModel.type}' and is not decoder-compatible.` +
+          `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 (modelId.startsWith("base:") && baseModels.length > 0 && !matchedBaseModel) {
+      if (baseModels.length > 0 && !isUuid(normalizedModelId) && !matchedBaseModel) {
         fail(
-          `Unknown base model '${modelId}'.` + formatDecoderSuggestions(decoderModelIds)
+          `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(modelId)) {
-        const jobResult = await api.getJob(modelId);
+      if (isUuid(normalizedModelId)) {
+        const jobResult = await api.getJob(normalizedModelId);
         if (jobResult.ok && jobResult.data) {
           const taskType = jobResult.data.task_type?.toLowerCase();
-          if (taskType && taskType !== "decoder") {
+          if (taskType && !isDecoderModel({ task_type: taskType } as api.BaseModelInfo)) {
             fail(
-              `Training job '${modelId}' has task_type '${taskType}', so it is not decoder-compatible.` +
+              `Training job '${normalizedModelId}' has task_type '${taskType}', so it is not decoder-compatible.` +
                 formatDecoderSuggestions(decoderModelIds)
             );
             return;
@@ -2233,18 +3389,21 @@ function ModelGenerateCommand({
       if (!active) return;
       setState("running");
 
-      const messages: Array<{ role: "system" | "user" | "assistant"; content: string }> = [];
+      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: modelId,
+        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;
@@ -2253,9 +3412,32 @@ function ModelGenerateCommand({
         setData(result.data);
         setState("done");
       } else {
-        let message = result.error ?? "Unknown error";
-        const normalizedError = formatApiError(message);
-        if (normalizedError.toLowerCase().includes("inference failed")) {
+        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);
@@ -2270,7 +3452,17 @@ function ModelGenerateCommand({
     return () => {
       active = false;
     };
-  }, [modelId, prompt, systemMsg, maxTokens, temperature, exit]);
+  }, [
+    modelId,
+    prompt,
+    systemMsg,
+    maxTokens,
+    temperature,
+    topP,
+    includeReasoningTrace,
+    projectId,
+    exit,
+  ]);
 
   if (state === "checking") {
     return <Loading message="Checking decoder model compatibility..." />;
@@ -2301,16 +3493,14 @@ type HelpContext =
   | "dataset"
   | "dataset-analyze"
   | "dataset-edit"
-  | "project"
   | "job"
   | "model"
-  | "chat"
   | "eval"
   | "benchmark"
-  | "competition"
-  | "notebook"
   | "inference"
-  | "adaptive-finetuning";
+  | "agent"
+  | "model-endpoints"
+  | "model-artifacts";
 
 interface HelpProps {
   context?: HelpContext;
@@ -2356,6 +3546,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>
@@ -2386,12 +3577,53 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <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>
@@ -2413,6 +3645,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>
     );
@@ -2431,6 +3665,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>
@@ -2458,32 +3694,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>
-      </Box>
-    );
-  }
-
-  // Project help
-  if (context === "project") {
-    return (
-      <Box flexDirection="column">
-        <Text bold>Project Commands:</Text>
-        <Text>  project list                         List all projects</Text>
-        <Text>  project get {"<project-id>"}                 Get project details</Text>
-        <Text>  project create                       Create a project</Text>
-        <Text>    --name {"<name>"}                    Project name (required)</Text>
-        <Text>    --icon {"<icon>"}                    Icon name (optional, default: folder)</Text>
-        <Text>    --repo {"<repo-url>"}                Repository URL/reference (optional)</Text>
-        <Text>    --description {"<text>"}             Description (optional)</Text>
-        <Text>    --model-id {"<id>"}                  Selected model ID (optional)</Text>
-        <Text>    --example {"<json>"}                 JSON example payload (optional)</Text>
-        <Text>  project update {"<project-id>"}              Update project fields</Text>
-        <Text>    --name {"<name>"} --icon {"<icon>"} --repo {"<repo-url>"} --description {"<text>"} --model-id {"<id>"}</Text>
-        <Text>  project delete {"<project-id>"}              Delete a project</Text>
-        <Text>  project dataset-count {"<project-id>"}       Show attached dataset count</Text>
-        <Text>  project quality-metrics {"<project-id>"}     Show LLMAJ pass/fail metrics</Text>
+        <Text>    dataset analyze-llm abc123 --task-type ner --description "NER quality analysis"</Text>
       </Box>
     );
   }
@@ -2509,156 +3726,143 @@ 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>  Inference:</Text>
-        <Text>  model predict {"<job-id>"} --text {"<text>"} --labels {"<labels>"}  Run NER inference</Text>
-        <Text>    --task {"<task>"}            Task: extract_entities, classify_text, extract_json (default: extract_entities)</Text>
-        <Text>    --threshold {"<n>"}          Confidence threshold 0-1 (default: 0.5)</Text>
-        <Text>  model generate {"<model-id>"} --prompt {"<text>"}  Run decoder generation</Text>
-        <Text>    --system {"<text>"}          System message (optional)</Text>
-        <Text>    --max-tokens {"<n>"}         Max tokens to generate (default: 256)</Text>
-        <Text>    --temperature {"<n>"}        Sampling temperature (default: 0.7)</Text>
-        <Text dimColor>    model-id can be a decoder training job UUID or base:{"<provider/model>"}</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 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>
+    );
+  }
+
+  // Model artifacts help
+  if (context === "model-artifacts") {
+    return (
+      <Box flexDirection="column">
+        <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>
     );
   }
 
-  // Inference help
-  if (context === "inference") {
+  // Model help
+  if (context === "model") {
     return (
       <Box flexDirection="column">
-        <Text bold>Inference Commands:</Text>
-        <Text>  model predict {"<model-id>"} --text {"<text>"} --labels {"<labels>"}</Text>
-        <Text>    Run encoder inference (NER, classification, JSON extraction)</Text>
-        <Text>    Use "base" as model-id for the base GLiNER2 model</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 generate {"<model-id>"} --prompt {"<text>"}</Text>
-        <Text>    Run decoder text generation on a decoder model</Text>
-        <Text>    Example base IDs: base:Qwen/Qwen3-8B, base:meta-llama/Llama-3.1-8B-Instruct</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 bold>  Options:</Text>
-        <Text>    --task {"<task>"}         extract_entities | classify_text | extract_json | schema</Text>
-        <Text>    --labels {"<labels>"}    Comma-separated labels for extraction/classification</Text>
-        <Text>    --threshold {"<n>"}      Confidence threshold (0-1, default: 0.5)</Text>
-        <Text>    --system {"<text>"}      System message for decoder generation</Text>
-        <Text>    --max-tokens {"<n>"}     Max tokens for generation (default: 256)</Text>
-        <Text>    --temperature {"<n>"}    Sampling temperature (default: 0.7)</Text>
       </Box>
     );
   }
 
-  // Chat help
-  if (context === "chat") {
+  // Inference help
+  if (context === "inference") {
     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 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 dimColor>  Note: Model selection available in chat via /model command</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>
     );
   }
 
   // Eval help
   if (context === "eval") {
-    return (
-      <Box flexDirection="column">
-        <Text bold>Evaluation Commands:</Text>
-        <Text dimColor>  Dataset format: name[:version] (version defaults to "latest")</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>
-    );
+    return <ErrorMessage error="The 'eval' command group is temporarily hidden for this version." />;
   }
 
   // Benchmark help
   if (context === "benchmark") {
-    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>
-      </Box>
-    );
+    return <ErrorMessage error="The 'benchmark' command group is temporarily hidden for this version." />;
   }
 
-  // Adaptive fine-tuning help
-  if (context === "adaptive-finetuning") {
+  // Agent help
+  if (context === "agent") {
     return (
       <Box flexDirection="column">
-        <Text bold>Adaptive Fine-tuning Commands:</Text>
-        <Text>  adaptive-finetuning chat             Send a request to the adaptive FT agent</Text>
-        <Text>    --message {"<text>"}                 Instruction (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>  agent sessions                             List and resume previous sessions</Text>
+        <Text>  agent resume {"[conversation-id]"}          List sessions, then resume a selected conversation</Text>
         <Text>    --conversation-id {"<id>"}           Continue an existing conversation</Text>
-        <Text>    --filters {"<json>"}                 Optional query filters JSON</Text>
+        <Text>    --filters {"<json>"}                 Reserved for future query filters</Text>
         <Text>    --history {"<json>"}                 Optional message history JSON</Text>
         <Text> </Text>
-        <Text dimColor>  Alias: aft</Text>
-        <Text dimColor>  Example: pioneer adaptive-finetuning chat --message "Analyze failures from last 24h and propose retraining plan"</Text>
-      </Box>
-    );
-  }
-
-  // Competition help
-  if (context === "competition") {
-    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>
-      </Box>
-    );
-  }
-
-  // Notebook help
-  if (context === "notebook") {
-    return (
-      <Box flexDirection="column">
-        <Text bold>Notebook Commands:</Text>
-        <Text> </Text>
-        <Text>  notebook run {"<file>"}              Run all cells in a .ipynb notebook</Text>
-        <Text>    --gpu {"<type>"}                   GPU type: cpu, t4, a10g, a100, h100 (default: cpu)</Text>
-        <Text>    --no-felix                       Don't inject Felix helper functions</Text>
-        <Text>  notebook create {"<name>"}           Create a blank notebook</Text>
-        <Text>  notebook sessions                  List active notebook sessions</Text>
-        <Text>  notebook stop {"<session-id>"}       Terminate a notebook session</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>
+        <Text dimColor>Example: pioneer agent resume</Text>
+        <Text dimColor>Example: pioneer agent resume b042f7a1-0e7e-4f78-96df-a1cc2d4afcdf</Text>
       </Box>
     );
   }
@@ -2672,17 +3876,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>  project    Manage projects</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>  notebook   Run and manage Jupyter notebooks</Text>
-      <Text>  competition Competitions and leaderboards</Text>
-      <Text>  adaptive-finetuning  Adaptive fine-tuning agent</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>
@@ -2690,24 +3887,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
 // ─────────────────────────────────────────────────────────────────────────────
@@ -2715,13 +3900,114 @@ 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) {
+    const missingValueHints: Record<string, string> = {
+      "--model": "<base-model-id>",
+      "--mode":
+        group === "agent" || group === "agents"
+          ? "<research>"
+          : "<value>",
+      "--conversation-id": "<session-id>",
+      "--conversation": "<session-id>",
+      "--history": "<json>",
+      "--filters": "<json>",
+      "--format": "<format>",
+      "--text": "<text>",
+      "--prompt": "<text>",
+      "--name": "<name>",
+      "--repo": "<url>",
+      "--icon": "<icon>",
+      "--description": "<text>",
+      "--api-key": "<key>",
+      "--api-url": "<url>",
+      "--message": "<text>",
+      "--inputs": "<json>",
+      "--labels": "<json-array>",
+      "--label-column": "<column>",
+      "--text-column": "<column>",
+      "--dataset-ids": "<comma-separated-ids>",
+      "--output": "<path>",
+      "--format-results": "<true|false>",
+      "--include-confidence": "<true|false>",
+      "--include-spans": "<true|false>",
+      "--reasoning-trace": "<true|false>",
+      "--reasoning-effort": "<low|medium|high>",
+    };
+    const getValueHint = (flag: string) => {
+      if (flag === "--mode" && group === "agent") {
+        return "<research> (default is standard when omitted)";
+      }
+      return missingValueHints[flag] ?? "<value>";
+    };
+
+    if (isModelEndpointsDeployMissingJob) {
+      const errorMessage = rest[1]
+        ? `Training job ID required: model endpoints deploy ${rest[1]} --job <training-job-id>`
+        : "Training job ID required: model endpoints deploy <model-id> --job <training-job-id>";
+
+      return (
+        <ApiCommand
+          action={() =>
+            Promise.resolve<api.ApiResult<{ message: string }>>({
+              ok: false,
+              status: 400,
+              error: errorMessage,
+              data: {
+                message: errorMessage,
+              },
+            })
+          }
+          successMessage="Validation failed"
+        />
+      );
+    }
+
+    return (
+      <Box flexDirection="column">
+        <ErrorMessage error="One or more flags are missing values. Please provide values for: " />
+        {parseErrors.map((flag) => (
+          <Text dimColor key={flag}>
+              - {flag} {getValueHint(flag)}
+          </Text>
+        ))}
+      </Box>
+    );
+  }
 
   // In non-interactive mode, skip telemetry prompt and default to disabled
   useEffect(() => {
@@ -2734,9 +4020,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") {
@@ -2748,14 +4036,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") {
@@ -2895,6 +4175,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" />;
     }
 
@@ -3076,6 +4381,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"];
@@ -3105,6 +4445,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(",");
@@ -3120,6 +4585,7 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
                 domain_description: domainDescription,
                 save_dataset: saveDataset,
                 dataset_name: datasetName,
+                ...commonGenerationOptions,
               })
             }
             datasetName={datasetName || "ner-dataset"}
@@ -3145,6 +4611,7 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
                 multi_label: multiLabel,
                 save_dataset: saveDataset,
                 dataset_name: datasetName,
+                ...commonGenerationOptions,
               })
             }
             datasetName={datasetName || "classification-dataset"}
@@ -3175,6 +4642,7 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
                 num_examples: numExamples,
                 save_dataset: saveDataset,
                 dataset_name: datasetName,
+                ...commonGenerationOptions,
               })
             }
             datasetName={datasetName || "custom-dataset"}
@@ -3198,6 +4666,7 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
                 num_examples: numExamples,
                 save_dataset: saveDataset,
                 dataset_name: datasetName,
+                ...commonGenerationOptions,
               })
             }
             datasetName={datasetName || "decoder-dataset"}
@@ -3213,6 +4682,44 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
     // 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) {
@@ -3246,137 +4753,129 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
       return <Help context="dataset" />;
     }
 
-    return <Help context="dataset" />;
-  }
-
-  // Project commands
-  if (group === "project") {
-    if (flags.help === "true" || !action || action === "help") {
-      return <Help context="project" />;
-    }
-
-    if (action === "list") {
-      return <ApiCommand action={api.listProjects} />;
-    }
-
-    if (action === "get") {
-      const projectId = rest[0];
-      if (!projectId) {
-        return <ErrorMessage error="Project ID required: project get <project-id>" />;
-      }
-      return <ApiCommand action={() => api.getProject(projectId)} />;
-    }
-
-    if (action === "create") {
-      const name = flags["name"];
-      const icon = flags["icon"];
-      const repo = flags["repo"];
-      const description = flags["description"];
-      const modelId = flags["model-id"];
-      const exampleStr = flags["example"];
-
-      if (!name) {
-        return <ErrorMessage error="--name is required for project creation" />;
+    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" />;
       }
-
-      let example: Record<string, unknown> | undefined;
-      if (exampleStr) {
-        try {
-          const parsed = JSON.parse(exampleStr) as unknown;
-          if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") {
-            return <ErrorMessage error="--example must be a JSON object" />;
-          }
-          example = parsed as Record<string, unknown>;
-        } catch {
-          return <ErrorMessage error="--example must be valid JSON" />;
-        }
+      if (saveDataset && !datasetName) {
+        return <ErrorMessage error="--name is required when --save=true for label-existing" />;
       }
 
-      return (
-        <ApiCommand
-          action={() =>
-            api.createProject({
-              name,
-              ...(icon ? { icon } : {}),
-              ...(repo ? { repo } : {}),
-              ...(description ? { description } : {}),
-              ...(modelId ? { selected_model_id: modelId } : {}),
-              ...(example ? { example } : {}),
-            })
-          }
-          successMessage="Project created"
-        />
-      );
-    }
-
-    if (action === "update") {
-      const projectId = rest[0];
-      if (!projectId) {
-        return <ErrorMessage error="Project ID required: project update <project-id>" />;
+      let inputs: unknown;
+      try {
+        inputs = JSON.parse(inputsArg);
+      } catch {
+        return <ErrorMessage error="--inputs must be valid JSON" />;
       }
 
-      const name = flags["name"];
-      const icon = flags["icon"];
-      const repo = flags["repo"];
-      const description = flags["description"];
-      const modelId = flags["model-id"];
-
-      if (!name && !icon && !repo && !description && !modelId) {
+      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 (
-          <ErrorMessage error="Provide at least one field to update: --name, --icon, --repo, --description, or --model-id" />
+          <ApiCommand
+            action={() =>
+              api.labelExistingClassification({
+                ...common,
+                domain_description: domainDescription,
+                save_dataset: saveDataset,
+                project_id: projectId,
+              })
+            }
+          />
         );
       }
 
-      return (
-        <ApiCommand
-          action={() =>
-            api.updateProject(projectId, {
-              ...(name ? { name } : {}),
-              ...(icon ? { icon } : {}),
-              ...(repo ? { repo } : {}),
-              ...(description ? { description } : {}),
-              ...(modelId ? { selected_model_id: modelId } : {}),
-            })
-          }
-          successMessage="Project updated"
-        />
-      );
-    }
-
-    if (action === "delete") {
-      const projectId = rest[0];
-      if (!projectId) {
-        return <ErrorMessage error="Project ID required: project delete <project-id>" />;
-      }
-      return (
-        <ApiCommand
-          action={() => api.deleteProject(projectId)}
-          successMessage={`Project ${projectId} deleted`}
-        />
-      );
-    }
-
-    if (action === "dataset-count" || action === "count") {
-      const projectId = rest[0];
-      if (!projectId) {
-        return (
-          <ErrorMessage error="Project ID required: project dataset-count <project-id>" />
+      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)
         );
-      }
-      return <ApiCommand action={() => api.getProjectDatasetCount(projectId)} />;
-    }
-
-    if (action === "quality-metrics" || action === "quality") {
-      const projectId = rest[0];
-      if (!projectId) {
+        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 (
-          <ErrorMessage error="Project ID required: project quality-metrics <project-id>" />
+          <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 <ApiCommand action={() => api.getProjectQualityMetrics(projectId)} />;
+
+      return <Help context="dataset" />;
     }
 
-    return <Help context="project" />;
+    return <Help context="dataset" />;
   }
 
   // Job commands
@@ -3433,181 +4932,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" />
+        );
+      }
+
+      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 === "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 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 (
+          <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" />;
       }
-      // Default: show all models
-      return <ModelListCommand filter="all" />;
+      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.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 } : {}),
+            })
+          }
+        />
+      );
+    }
+
+    return <Help context="inference" />;
+  }
+
+  // Model commands
+  if (group === "model") {
+    if (flags.help === "true" || !action || action === "help") {
+      return <Help context="model" />;
     }
-    if (action === "delete") {
-      if (!rest[0]) {
-        return <ErrorMessage error="Job ID required. Usage: model delete <job-id>" />;
+
+    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.deleteModel(jobId)}
-          successMessage={`Model ${jobId} deleted`}
-        />
-      );
-    }
-    if (action === "download") {
-      if (!rest[0]) {
-        return <ErrorMessage error="Job ID required. Usage: model download <job-id>" />;
+
+      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)} />;
       }
-      const jobId = rest[0];
-      if (jobId.length !== 36) {
+
+      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">
-            <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.updateProject(modelId, {
+                ...(name ? { name } : {}),
+                ...(icon ? { icon } : {}),
+                ...(repo ? { repo } : {}),
+                ...(description ? { description } : {}),
+                ...(selectedModelId ? { selected_model_id: selectedModelId } : {}),
+              })
+            }
+            successMessage="Model updated"
+          />
         );
       }
-      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 === "delete") {
+        const modelId = endpointArgs[0];
+        if (!modelId) {
+          return <ErrorMessage error="Model ID required: model endpoints delete <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.deleteProject(modelId)}
+            successMessage={`Model ${modelId} deleted`}
+          />
         );
       }
 
-      // 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 === "dataset-count" || endpointAction === "count") {
+        const modelId = endpointArgs[0];
+        if (!modelId) {
+          return <ErrorMessage error="Model ID required: model endpoints dataset-count <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.getProjectDatasetCount(modelId)} />;
+      }
 
-        if (!repo) {
-          return <ErrorMessage error="--repo is required (e.g., username/model-name)" />;
+      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)} />;
+      }
 
-        const hfToken = getHfToken(hfTokenFlag);
-        if (!hfToken) {
+      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}`}
+          />
+        );
+      }
+
+      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 <ErrorMessage error="--to is required. Supported destinations: hf" />;
+      return <Help context="model-endpoints" />;
     }
-    // Model predict command (encoder inference)
-    if (action === "predict") {
-      const modelId = rest[0];
-      if (!modelId) {
-        return <ErrorMessage error="Model ID required. Usage: model predict <model-id> --text <text> --labels <labels>" />;
+
+    if (normalizedAction === "artifacts") {
+      const artifactsAction = rest[0];
+      const artifactArgs = rest.slice(1);
+
+      if (flags.help === "true" || !artifactsAction || artifactsAction === "help") {
+        return <Help context="model-artifacts" />;
       }
-      const text = flags["text"];
-      const labelsStr = flags["labels"];
-      if (!text) {
-        return <ErrorMessage error="--text is required for inference" />;
+
+      if (artifactsAction === "list") {
+        return <ModelListCommand filter="artifacts" />;
       }
-      if (!labelsStr) {
-        return <ErrorMessage error="--labels is required (comma-separated, e.g., PERSON,ORG,LOCATION)" />;
+
+      if (artifactsAction === "trained") {
+        return <ModelListCommand filter="trained" />;
       }
-      const labels = labelsStr.split(",").map((l: string) => l.trim());
-      const task = (flags["task"] || "extract_entities") as "extract_entities" | "classify_text" | "extract_json" | "schema";
-      const threshold = flags["threshold"] ? parseFloat(flags["threshold"]) : 0.5;
 
-      return (
-        <ApiCommand
-          action={() =>
-            api.runInference({
-              model_id: modelId,
-              task,
-              text,
-              schema: labels,
-              threshold,
-              include_confidence: true,
-            })
-          }
-        />
-      );
-    }
-    // Model generate command (decoder inference)
-    if (action === "generate") {
-      const modelId = rest[0];
-      if (!modelId) {
-        return <ErrorMessage error="Model ID required. Usage: model generate <model-id> --prompt <text>" />;
+      if (artifactsAction === "deployed") {
+        return <ModelListCommand filter="deployed" />;
       }
-      const prompt = flags["prompt"];
-      if (!prompt) {
-        return <ErrorMessage error="--prompt is required for text generation" />;
+
+      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)} />;
       }
-      const systemMsg = flags["system"];
-      const maxTokens = flags["max-tokens"] ? parseInt(flags["max-tokens"]) : 256;
-      const temperature = flags["temperature"] ? parseFloat(flags["temperature"]) : 0.7;
+
+      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" />;
+    }
+
+    if (action === "predict" || action === "generate") {
       return (
-        <ModelGenerateCommand
-          modelId={modelId}
-          prompt={prompt}
-          systemMsg={systemMsg}
-          maxTokens={maxTokens}
-          temperature={temperature}
+        <ErrorMessage
+          error={
+            "model predict and model generate are no longer supported. Use model endpoints/... and model artifacts/... instead."
+          }
         />
       );
     }
-    return <Help context="model" />;
+
+    return (
+      <ErrorMessage
+        error={`Unknown model command: model ${action}. Use 'pioneer model_endpoints ...', 'pioneer model endpoints ...', 'pioneer model_artifacts ...', or 'pioneer model artifacts ...'.`}
+      />
+    );
   }
 
   // Eval commands
@@ -3625,9 +5501,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"];
@@ -3671,21 +5598,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,
@@ -3710,152 +5651,89 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
     return <Help context="benchmark" />;
   }
 
-  // Notebook commands
-  if (group === "notebook") {
-    if (flags.help === "true" || !action || action === "help") {
-      return <Help context="notebook" />;
-    }
-
-    if (action === "run") {
-      const file = rest[0];
-      if (!file) {
-        return <ErrorMessage error="File path required: notebook run <file.ipynb>" />;
-      }
-      const gpu = flags.gpu || "cpu";
-      const loadFelixHelpers = flags["no-felix"] !== "true";
-      return <NotebookRunCommand filePath={file} gpu={gpu} loadFelixHelpers={loadFelixHelpers} />;
-    }
-
-    if (action === "create") {
-      const name = rest[0] || flags.name;
-      if (!name) {
-        return <ErrorMessage error="Name required: notebook create <name>" />;
-      }
-      try {
-        const filePath = createBlankNotebook(name);
-        return <Success message={`Created notebook: ${filePath}`} />;
-      } catch (e) {
-        return <ErrorMessage error={e instanceof Error ? e.message : String(e)} />;
-      }
-    }
-
-    if (action === "sessions") {
-      return <ApiCommand action={api.listNotebookSessions} />;
+  // Adaptive agent commands (new short command)
+  if (group === "agent") {
+    if (flags.help === "true" || action === "help") {
+      return <Help context="agent" />;
     }
 
-    if (action === "stop") {
-      const sessionId = rest[0];
-      if (!sessionId) {
-        return <ErrorMessage error="Session ID required: notebook stop <session-id>" />;
-      }
+    if (action && action !== "resume" && action !== "sessions" && !action.startsWith("-")) {
       return (
-        <ApiCommand
-          action={() => api.terminateNotebookSession(sessionId)}
-          successMessage={`Session ${sessionId} terminated`}
+        <ErrorMessage
+          error={
+            'Invalid agent command syntax. Use one of:\n' +
+            "pioneer agent\n" +
+            "pioneer agent --mode research\n" +
+            "pioneer agent sessions\n" +
+            "pioneer agent resume [conversation-id]"
+          }
         />
       );
     }
 
-    return <Help context="notebook" />;
-  }
-
-  // Adaptive fine-tuning commands
-  if (group === "adaptive-finetuning" || group === "aft") {
-    if (flags.help === "true" || action === "help") {
-      return <Help context="adaptive-finetuning" />;
-    }
-
-    let message = flags.message;
-    if (!message) {
-      const rawParts = action === "chat" ? rest : [action, ...rest];
-      message = rawParts.filter(Boolean).join(" ").trim();
+    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." />;
     }
 
-    if (!message) {
-      return (
-        <ErrorMessage
-          error={'Message required. Usage: adaptive-finetuning chat --message "Analyze failures and propose retraining plan"'}
-        />
-      );
+    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.AdaptiveFinetuningHistoryItem[] | undefined;
+    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.AdaptiveFinetuningHistoryItem[];
+        history = parsed as api.AgentChatHistoryItem[];
       } catch {
         return <ErrorMessage error="--history must be valid JSON" />;
       }
     }
 
-    let filters: api.AdaptiveFinetuningQueryFilters | undefined;
     if (flags.filters) {
-      try {
-        const parsed = JSON.parse(flags.filters) as unknown;
-        if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") {
-          return <ErrorMessage error="--filters must be a JSON object" />;
-        }
-        filters = parsed as api.AdaptiveFinetuningQueryFilters;
-      } catch {
-        return <ErrorMessage error="--filters must be valid JSON" />;
+      return <ErrorMessage error='--filters is not supported for /auto-agent/clarify. Omit this flag for now.' />;
+    }
+
+    if (action === "resume" || action === "sessions") {
+      if (!isRawModeSupported) {
+        return (
+          <ErrorMessage
+            error="Interactive input is not supported in this terminal.\nUse interactive mode for this environment: agent --help"
+          />
+        );
+      }
+      if (rest[0] || flags["conversation-id"]) {
+        const resumeId = rest[0] ?? flags["conversation-id"];
+        return (
+          <AutoAgentInteractiveSession
+            conversationId={resumeId}
+            history={history}
+            mode={mode}
+            allowSessionCreation={false}
+          />
+        );
       }
+      return <AgentResumeCommand mode={mode} />;
     }
 
     return (
-      <ApiCommand
-        action={() =>
-          api.adaptiveFinetuningChat({
-            message,
-            ...(flags["conversation-id"] ? { conversation_id: flags["conversation-id"] } : {}),
-            ...(history ? { history } : {}),
-            ...(filters ? { filters } : {}),
-          })
-        }
-        successMessage="Adaptive fine-tuning response received"
+      <AgentInteractivePrompt
+        conversationId={flags["conversation-id"]}
+        history={history}
+        mode={mode}
+        allowSessionCreation={true}
       />
     );
   }
 
-  // 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} />;
-    }
-    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" />;
-      }
-
-      return (
-        <ApiCommand
-          action={() =>
-            api.submitToLeaderboard(rest[0], {
-              evaluation_id: evalId,
-              display_name: displayName,
-            })
-          }
-          successMessage="Submitted to leaderboard"
-        />
-      );
-    }
-    return <Help context="competition" />;
+  if (group === "notebook") {
+    return <ErrorMessage error="The notebook command is deprecated and has been removed from this CLI." />;
   }
 
   return <Help />;
@@ -3869,7 +5747,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") {
@@ -3877,7 +5755,9 @@ 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();
+if (process.env.PIONEER_SKIP_AUTORUN !== "true") {
+  main();
+}