@fastino-ai/pioneer-cli 0.2.8 → 0.2.10

package/src/index.tsx

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