@fastino-ai/pioneer-cli 0.2.8 → 0.2.9

package/README.md

@@ -88,6 +88,8 @@ pioneer model_artifacts list
 
 `agent` starts in interactive mode by default (standard workflow). For the only explicit alternate mode:
 - `--mode research`: Pro mode with deeper research response style.
+- `agent resume`: list recent conversations and resume a selected session.
+- `agent sessions`: explicit alias for listing sessions and resuming one.
 
 ```bash
 # Interactive (default)
@@ -98,6 +100,15 @@ pioneer agent
 
 # Research mode (Pro subscription required)
 pioneer agent --mode research
+
+# Open a session list and pick one to continue
+pioneer agent resume
+
+# Equivalent: explicit sessions command
+pioneer agent sessions
+
+# Resume a specific conversation id
+pioneer agent resume 4f2a...
 ```
 
 When you start any of these commands, the CLI opens a conversational prompt and keeps accepting follow-up messages in the same session.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastino-ai/pioneer-cli",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Pioneer CLI - AI training platform with chat agent",
   "type": "module",
   "files": [
@@ -36,6 +36,7 @@
     "@types/react": "^18.3.0",
     "@types/ws": "^8.18.1",
     "bun-types": "^1.1.0",
+    "ink-testing-library": "^4.0.0",
     "typescript": "^5.6.3"
   },
   "engines": {

package/src/chat/ChatApp.tsx

@@ -855,7 +855,8 @@ File references:
   }, [client, state.isProcessing]);
 
   // Handle keyboard shortcuts
-  useInput((char, key) => {
+  useInput(
+    (char, key) => {
     if (key.ctrl && char === "c") {
       exit();
       return;
@@ -920,7 +921,9 @@ File references:
         return;
       }
     }
-  });
+    },
+    { isActive: isRawModeSupported }
+  );
 
   if (!client) {
     return (

package/src/config.ts

@@ -23,8 +23,12 @@ export interface Config {
   // Hugging Face token for pushing datasets/models
   hfToken?: string;
 
+  // Last agent conversation ID used for resuming chats
+  lastAgentConversationId?: string;
+
   // Telemetry (opt-in analytics)
   telemetry?: TelemetryConfig;
+
 }
 
 const CONFIG_DIR = path.join(os.homedir(), ".pioneer");
@@ -169,6 +173,17 @@ export function getBaseUrl(): string {
   return DEFAULT_BASE_URL;
 }
 
+export function getLastAgentConversationId(): string | undefined {
+  return loadConfig().lastAgentConversationId;
+}
+
+export function setLastAgentConversationId(conversationId?: string): void {
+  if (!conversationId) {
+    return;
+  }
+  saveConfig({ lastAgentConversationId: conversationId });
+}
+
 export function getMleModel(): string | undefined {
   return loadConfig().mleModel;
 }

package/src/index.tsx

@@ -15,6 +15,8 @@ import {
   getApiKey,
   getBaseUrl,
   getMleModel,
+  getLastAgentConversationId,
+  setLastAgentConversationId,
   saveConfig,
   clearApiKey,
   getHfToken,
@@ -274,24 +276,28 @@ interface TelemetryPromptProps {
 
 const TelemetryPrompt: React.FC<TelemetryPromptProps> = ({ onComplete }) => {
   const [selected, setSelected] = useState<"yes" | "no">("yes");
+  const { isRawModeSupported } = useStdin();
 
-  useInput((input, key) => {
-    if (key.leftArrow || key.rightArrow) {
-      setSelected((s) => (s === "yes" ? "no" : "yes"));
-    }
-    if (key.return) {
-      setTelemetryEnabled(selected === "yes");
-      onComplete();
-    }
-    if (input === "y" || input === "Y") {
-      setTelemetryEnabled(true);
-      onComplete();
-    }
-    if (input === "n" || input === "N") {
-      setTelemetryEnabled(false);
-      onComplete();
-    }
-  });
+  useInput(
+    (input, key) => {
+      if (key.leftArrow || key.rightArrow) {
+        setSelected((s) => (s === "yes" ? "no" : "yes"));
+      }
+      if (key.return) {
+        setTelemetryEnabled(selected === "yes");
+        onComplete();
+      }
+      if (input === "y" || input === "Y") {
+        setTelemetryEnabled(true);
+        onComplete();
+      }
+      if (input === "n" || input === "N") {
+        setTelemetryEnabled(false);
+        onComplete();
+      }
+    },
+    { isActive: isRawModeSupported }
+  );
 
   return (
     <Box flexDirection="column" paddingX={1}>
@@ -725,8 +731,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 +745,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 +780,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 +866,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 +1013,7 @@ function AgentInteractiveCommand({ message, conversationId, history }: AgentInte
             }
             doneHistory.current = messages;
             wsSessionId = sessionId;
+            persistConversation(sessionId);
           },
         }, {
           history: mergedHistory,
@@ -1089,59 +1121,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 +1368,121 @@ function AutoAgentInteractiveSession({
       } else {
         setError(result.error || "Agent request failed.");
       }
+
       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 data = result.data;
+    if (!data) {
+      setError("Agent request did not return a usable response.");
+      setIsLoading(false);
+      setStatusHint("Ready for next message.");
+      return;
+    }
 
-    setConversationId(nextConversationId);
-    setTurns((current) => [...current, { role: "assistant", content: answer }]);
-    setHistoryState((current) => [...current, { role: "assistant", content: answer }]);
+    const answer = data.answer?.trim() || "No response content yet.";
+    setError("");
+    const persistedConversationId = activeConversationId ?? data.conversation_id;
+    if (persistedConversationId) {
+      setConversationId(persistedConversationId);
+      persistConversation(persistedConversationId);
+    }
+
+    const assistantTurn: api.AgentChatHistoryItem = { role: "assistant", content: answer };
+    if (persistedConversationId) {
+      void api.appendSessionMessages(persistedConversationId, {
+        messages: [
+          { role: "user", content: trimmed },
+          { role: "assistant", content: answer },
+        ],
+      });
+    }
+    setHistoryState((current) => [...current, assistantTurn]);
     setStatusHint("Ready for next message.");
     setIsLoading(false);
   };
 
+  useInput(
+    (character, key) => {
+      if (key.return) {
+        void runAutoTurn(input);
+        return;
+      }
+
+      if (key.backspace || key.delete) {
+        setInputValue(input.slice(0, -1));
+        return;
+      }
+
+      if (key.upArrow) {
+        if (!inputHistory.length) {
+          return;
+        }
+        const nextIndex =
+          inputHistoryIndex === -1 ? inputHistory.length - 1 : Math.max(0, inputHistoryIndex - 1);
+        setInputHistoryIndex(nextIndex);
+        setInput(inputHistory[nextIndex] ?? "");
+        return;
+      }
+
+      if (key.downArrow) {
+        if (inputHistoryIndex === -1) {
+          return;
+        }
+        const nextIndex = inputHistoryIndex + 1;
+        if (nextIndex >= inputHistory.length) {
+          setInputHistoryIndex(-1);
+          setInput("");
+          return;
+        }
+        setInputHistoryIndex(nextIndex);
+        setInput(inputHistory[nextIndex] ?? "");
+        return;
+      }
+
+      if (
+        key.tab ||
+        key.leftArrow ||
+        key.rightArrow ||
+        key.escape ||
+        key.ctrl ||
+        key.meta
+      ) {
+        return;
+      }
+
+      if (character) {
+        setInputValue(input + character);
+      }
+    },
+    { isActive: isRawModeSupported && !isLoading }
+  );
+
+  const persistConversation = (nextConversationId?: string) => {
+    if (nextConversationId) {
+      setLastAgentConversationId(nextConversationId);
+    }
+  };
+
+  useEffect(() => {
+    return () => {
+      persistConversation(conversationId);
+    };
+  }, [conversationId]);
+
   useEffect(() => {
     if (!firstMessage || didSeedFirstMessage.current) {
       return;
     }
+    if (isHistoryLoading) {
+      return;
+    }
 
     didSeedFirstMessage.current = true;
     void runAutoTurn(firstMessage);
-  }, [firstMessage]);
+  }, [firstMessage, isHistoryLoading]);
 
   return (
     <Box flexDirection="column">
@@ -1182,6 +1491,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 +1504,9 @@ function AutoAgentInteractiveSession({
         {isLoading ? null : (
           <TextInput
             value={input}
-            onChange={setInput}
-            onSubmit={runAutoTurn}
+            focus={false}
+            onChange={() => {}}
+            onSubmit={() => {}}
           />
         )}
       </Box>
@@ -1209,21 +1520,372 @@ function AutoAgentInteractiveSession({
   );
 }
 
+export function AgentResumeCommand({
+  mode,
+}: {
+  mode?: "standard" | "research";
+}) {
+  const { isRawModeSupported } = useStdin();
+  const [isReady, setReady] = useState(false);
+  const [selectedSession, setSelectedSession] = useState<
+    {
+      id: string;
+    } | undefined
+  >();
+  const [defaultSessionId] = useState(() => getLastAgentConversationId());
+  const [searchQuery, setSearchQuery] = useState("");
+  const [highlightIndex, setHighlightIndex] = useState(0);
+  const [sessions, setSessions] = useState<
+    Array<{
+      id: string;
+      title: string;
+      updated_at: string;
+      is_archived: boolean;
+    }>
+  >([]);
+  const [error, setError] = useState("");
+  const [statusHint, setStatusHint] = useState("Loading sessions...");
+  const [isSessionLoading, setSessionLoading] = useState(false);
+  const [sessionError, setSessionError] = useState("");
+  const [selectedSessionHistory, setSelectedSessionHistory] = useState<
+    api.AgentChatHistoryItem[] | undefined
+  >(undefined);
+
+  useEffect(() => {
+    if (!selectedSession?.id) {
+      setSelectedSessionHistory(undefined);
+      setSessionError("");
+      return;
+    }
+
+    let isActive = true;
+    const loadSessionHistory = async () => {
+      setSessionLoading(true);
+      setSessionError("");
+
+      const result = await api.getAgentSession(selectedSession.id);
+      if (!isActive) {
+        return;
+      }
+
+      if (!result.ok) {
+        setSessionError(
+          `Could not load selected session ${selectedSession.id}: ${result.error || "Unknown error."}`
+        );
+        setSelectedSessionHistory(undefined);
+        setSessionLoading(false);
+        return;
+      }
+
+      const restoredMessages = (result.data?.messages ?? [])
+        .map((message) => {
+          if (typeof message?.role !== "string" || typeof message?.content !== "string") {
+            return undefined;
+          }
+          return {
+            role: message.role,
+            content: message.content,
+          } as api.AgentChatHistoryItem;
+        })
+        .filter((message): message is api.AgentChatHistoryItem => message !== undefined);
+
+      setSelectedSessionHistory(restoredMessages);
+      setSessionLoading(false);
+    };
+
+    void loadSessionHistory();
+
+    return () => {
+      isActive = false;
+      setSessionLoading(false);
+    };
+  }, [selectedSession?.id]);
+
+  useEffect(() => {
+    let isActive = true;
+    const loadSessions = async () => {
+      try {
+        const result = await api.listAgentSessions();
+        if (!isActive) {
+          return;
+        }
+        if (!result.ok) {
+          setError(result.error || "Could not load agent sessions.");
+          setStatusHint("");
+          setReady(true);
+          setSessions([]);
+          return;
+        }
+        const remoteSessions = (result.data?.sessions ?? []).map((session) => ({
+          id: session.id,
+          title: session.title || "(untitled)",
+          updated_at: session.updated_at || new Date().toISOString(),
+          is_archived: session.is_archived,
+        }));
+        remoteSessions.sort((a, b) => {
+          const aTime = Date.parse(a.updated_at);
+          const bTime = Date.parse(b.updated_at);
+          if (Number.isNaN(aTime) || Number.isNaN(bTime)) {
+            return 0;
+          }
+          return bTime - aTime;
+        });
+        if (defaultSessionId) {
+          const lastIndex = remoteSessions.findIndex((session) => session.id === defaultSessionId);
+          if (lastIndex >= 0) {
+            setHighlightIndex(lastIndex);
+          }
+        }
+        setSessions(remoteSessions);
+        setStatusHint("");
+        setReady(true);
+        return;
+      } catch (err) {
+        if (!isActive) {
+          return;
+        }
+        const message = err instanceof Error ? err.message : "Could not load agent sessions.";
+        setError(message);
+        setStatusHint("");
+        setSessions([]);
+        setReady(true);
+      }
+    };
+    void loadSessions();
+
+    return () => {
+      isActive = false;
+    };
+  }, []);
+
+  const normalizeSessionLabel = (session: {
+    id: string;
+    title: string;
+    is_archived: boolean;
+    updated_at: string;
+  }) => `${session.title || "(untitled)"} ${session.is_archived ? "[archived] " : ""}(updated ${session.updated_at})`;
+
+  const matchingSessions = sessions.filter((session) => {
+    const searchable = `${session.title} ${session.id}`.toLowerCase();
+    const normalizedQuery = searchQuery.trim().toLowerCase();
+    return normalizedQuery.length === 0 || searchable.includes(normalizedQuery);
+  });
+
+  useInput((_, key) => {
+    if (!matchingSessions.length) return;
+    if (key.upArrow) {
+      setHighlightIndex((idx) => (idx === 0 ? matchingSessions.length - 1 : idx - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setHighlightIndex((idx) => (idx === matchingSessions.length - 1 ? 0 : idx + 1));
+      return;
+    }
+    if (key.return) {
+      const selected = matchingSessions[highlightIndex];
+      if (!selected) {
+        setError("No matching sessions found.");
+        return;
+      }
+      setError("");
+      setSelectedSession({ id: selected.id });
+    }
+  }, { isActive: isRawModeSupported });
+
+  if (!isRawModeSupported) {
+    return (
+      <Box flexDirection="column">
+        <ErrorMessage error="Interactive input is not supported in this terminal." />
+        <Text>Use interactive mode for this environment:</Text>
+        <Text dimColor>  agent --help</Text>
+      </Box>
+    );
+  }
+
+  if (error && !sessions.length) {
+    return <ErrorMessage error={error} />;
+  }
+
+  if (!isReady) {
+    return <Loading message={statusHint || "Loading sessions..."} />;
+  }
+
+  if (!sessions.length) {
+    return (
+      <ErrorMessage
+        error="No agent sessions found. Start a new conversation with `pioneer agent` and try again."
+      />
+    );
+  }
+
+  if (selectedSession?.id) {
+    if (isSessionLoading) {
+      return <Loading message={`Loading conversation ${selectedSession.id}...`} />;
+    }
+    if (sessionError) {
+      return <ErrorMessage error={sessionError} />;
+    }
+
+    return (
+      <AutoAgentInteractiveSession
+        conversationId={selectedSession.id}
+        mode={mode ?? "standard"}
+        history={selectedSessionHistory}
+        allowSessionCreation={false}
+      />
+    );
+  }
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>Agent sessions:</Text>
+      <Text>
+        {defaultSessionId ? `Last session: ${defaultSessionId}. ` : ""}
+        Type to filter. Use ↑/↓ to navigate and Enter to select.
+      </Text>
+      <Text dimColor>Search title or session ID.</Text>
+      <Text> </Text>
+      {matchingSessions.length === 0 ? (
+        <Text color="yellow">No sessions match "{searchQuery}".</Text>
+      ) : (
+        matchingSessions.slice(0, 12).map((session, index) => {
+          const isSelected = index === highlightIndex;
+          return (
+            <Text key={session.id} color={isSelected ? "cyan" : undefined}>
+              {`${isSelected ? ">" : " "} ${normalizeSessionLabel(session)} (${session.id})`}
+            </Text>
+          );
+        })
+      )}
+      <Box marginTop={1}>
+        <Text color="cyan">&gt; </Text>
+        <TextInput
+          value={searchQuery}
+          onChange={setSearchQuery}
+          onSubmit={(rawValue) => {
+            const trimmed = rawValue.trim().toLowerCase();
+            if (!trimmed && !matchingSessions.length) {
+              return;
+            }
+            const exactMatch = matchingSessions.find(
+              (session) =>
+                session.id.toLowerCase() === trimmed ||
+                session.title.toLowerCase() === trimmed
+            );
+            const selected = exactMatch ?? matchingSessions[highlightIndex];
+            if (!selected?.id) {
+              setError("No matching session found.");
+              return;
+            }
+            setError("");
+            setSelectedSession({ id: selected.id });
+          }}
+        />
+      </Box>
+      {error && <ErrorMessage error={error} />}
+    </Box>
+  );
+}
+
 function AgentInteractivePrompt({
   conversationId,
   history,
   mode,
+  allowSessionCreation = true,
 }: {
   conversationId?: string;
   history?: api.AgentChatHistoryItem[];
   mode?: "standard" | "research";
+  allowSessionCreation?: boolean;
 }) {
   const [input, setInput] = useState("");
+  const [inputHistory, setInputHistory] = useState<string[]>([]);
+  const [inputHistoryIndex, setInputHistoryIndex] = useState(-1);
   const [isReady, setReady] = useState(false);
   const [message, setMessage] = useState("");
   const { isRawModeSupported } = useStdin();
   const shouldExitImmediately = !isRawModeSupported;
 
+  const commitInputToHistory = (value: string) => {
+    const normalized = value.trim();
+    if (!normalized) {
+      return;
+    }
+    setInputHistory((previous) => {
+      if (previous.length > 0 && previous[previous.length - 1] === normalized) {
+        return previous;
+      }
+      return [...previous, normalized];
+    });
+  };
+
+  const setInputValue = (nextValue: string) => {
+    setInput(nextValue);
+    setInputHistoryIndex(-1);
+  };
+
+  useInput(
+    (character, key) => {
+      if (key.return) {
+        const trimmed = input.trim();
+        if (!trimmed) {
+          return;
+        }
+        commitInputToHistory(trimmed);
+        setMessage(trimmed);
+        setReady(true);
+        return;
+      }
+
+      if (key.backspace || key.delete) {
+        setInputValue(input.slice(0, -1));
+        return;
+      }
+
+      if (key.upArrow) {
+        if (!inputHistory.length) {
+          return;
+        }
+        const nextIndex =
+          inputHistoryIndex === -1 ? inputHistory.length - 1 : Math.max(0, inputHistoryIndex - 1);
+        setInputHistoryIndex(nextIndex);
+        setInput(inputHistory[nextIndex] ?? "");
+        return;
+      }
+
+      if (key.downArrow) {
+        if (inputHistoryIndex === -1) {
+          return;
+        }
+        const nextIndex = inputHistoryIndex + 1;
+        if (nextIndex >= inputHistory.length) {
+          setInputHistoryIndex(-1);
+          setInput("");
+          return;
+        }
+        setInputHistoryIndex(nextIndex);
+        setInput(inputHistory[nextIndex] ?? "");
+        return;
+      }
+
+      if (
+        key.tab ||
+        key.leftArrow ||
+        key.rightArrow ||
+        key.escape ||
+        key.ctrl ||
+        key.meta
+      ) {
+        return;
+      }
+
+      if (character) {
+        setInputValue(input + character);
+      }
+    },
+    { isActive: isRawModeSupported && !isReady }
+  );
+
   useEffect(() => {
     if (!shouldExitImmediately) {
       return;
@@ -1256,15 +1918,9 @@ function AgentInteractivePrompt({
           <Text color="cyan">&gt; </Text>
           <TextInput
             value={input}
-            onChange={setInput}
-            onSubmit={(value) => {
-              const trimmed = value.trim();
-              if (!trimmed) {
-                return;
-              }
-              setMessage(trimmed);
-              setReady(true);
-            }}
+            focus={false}
+            onChange={() => {}}
+            onSubmit={() => {}}
           />
         </Box>
         <Text dimColor>Type Ctrl+C to cancel.</Text>
@@ -1278,6 +1934,7 @@ function AgentInteractivePrompt({
       history={history}
       mode={mode === "research" ? "research" : "standard"}
       firstMessage={message}
+      allowSessionCreation={allowSessionCreation}
     />
   );
 }
@@ -1304,6 +1961,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,25 +2010,28 @@ 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));
-      return;
-    }
-    if (key.return) {
-      const resolvedModel = resolveModelId(query);
-      if (!resolvedModel) {
-        setError("No matching models found. Refine your search and try again.");
+  useInput(
+    (_, key) => {
+      if (!topMatches.length) return;
+      if (key.upArrow) {
+        setHighlightIndex((idx) => (idx === 0 ? topMatches.length - 1 : idx - 1));
         return;
       }
-      setSelectedModelId(resolvedModel);
-    }
-  });
+      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 (
@@ -2837,7 +3498,9 @@ type HelpContext =
   | "eval"
   | "benchmark"
   | "inference"
-  | "agent";
+  | "agent"
+  | "model-endpoints"
+  | "model-artifacts";
 
 interface HelpProps {
   context?: HelpContext;
@@ -3188,6 +3851,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 +3861,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>
     );
   }
@@ -3269,6 +3936,45 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
   }
 
   if (hasParseErrors && !isModelCreateMissingModel) {
+    const missingValueHints: Record<string, string> = {
+      "--model": "<base-model-id>",
+      "--mode":
+        group === "agent" || group === "agents"
+          ? "<research>"
+          : "<value>",
+      "--conversation-id": "<session-id>",
+      "--conversation": "<session-id>",
+      "--history": "<json>",
+      "--filters": "<json>",
+      "--format": "<format>",
+      "--text": "<text>",
+      "--prompt": "<text>",
+      "--name": "<name>",
+      "--repo": "<url>",
+      "--icon": "<icon>",
+      "--description": "<text>",
+      "--api-key": "<key>",
+      "--api-url": "<url>",
+      "--message": "<text>",
+      "--inputs": "<json>",
+      "--labels": "<json-array>",
+      "--label-column": "<column>",
+      "--text-column": "<column>",
+      "--dataset-ids": "<comma-separated-ids>",
+      "--output": "<path>",
+      "--format-results": "<true|false>",
+      "--include-confidence": "<true|false>",
+      "--include-spans": "<true|false>",
+      "--reasoning-trace": "<true|false>",
+      "--reasoning-effort": "<low|medium|high>",
+    };
+    const getValueHint = (flag: string) => {
+      if (flag === "--mode" && group === "agent") {
+        return "<research> (default is standard when omitted)";
+      }
+      return missingValueHints[flag] ?? "<value>";
+    };
+
     if (isModelEndpointsDeployMissingJob) {
       const errorMessage = rest[1]
         ? `Training job ID required: model endpoints deploy ${rest[1]} --job <training-job-id>`
@@ -3296,7 +4002,7 @@ const App: React.FC<AppProps> = ({ command, flags, parseErrors }) => {
         <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>
@@ -4951,13 +5657,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 +5700,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 +5758,6 @@ async function main() {
   await render(<App command={command} flags={flags} parseErrors={parseErrors} />).waitUntilExit();
 }
 
-main();
+if (process.env.PIONEER_SKIP_AUTORUN !== "true") {
+  main();
+}