@fastino-ai/pioneer-cli 0.2.5 → 0.2.7

package/src/index.tsx

@@ -78,6 +78,53 @@ function formatJson(data: unknown): string {
   return JSON.stringify(filterInternalFields(data), null, 2);
 }
 
+function extractDetailMessage(payload: unknown): string | undefined {
+  if (payload === null || payload === undefined) return undefined;
+  if (typeof payload === "string") return payload;
+
+  if (Array.isArray(payload)) {
+    const parts = payload
+      .map((item) => extractDetailMessage(item))
+      .filter((item): item is string => Boolean(item && item.trim()));
+    return parts.length > 0 ? parts.join("; ") : undefined;
+  }
+
+  if (typeof payload === "object") {
+    const record = payload as Record<string, unknown>;
+    if (typeof record.detail === "string") return record.detail;
+    if (record.detail !== undefined) {
+      const detail = extractDetailMessage(record.detail);
+      if (detail) return detail;
+    }
+    if (typeof record.message === "string") return record.message;
+    if (typeof record.error === "string") return record.error;
+    if (typeof record.msg === "string") return record.msg;
+    if (Array.isArray(record.loc) && typeof record.msg === "string") {
+      return `${record.loc.join(".")}: ${record.msg}`;
+    }
+  }
+
+  return undefined;
+}
+
+function formatApiError(error: string): string {
+  const trimmed = error.trim();
+  if (!trimmed) return error;
+
+  const likelyJson =
+    (trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+    (trimmed.startsWith("[") && trimmed.endsWith("]"));
+
+  if (!likelyJson) return error;
+
+  try {
+    const parsed = JSON.parse(trimmed) as unknown;
+    return extractDetailMessage(parsed) || error;
+  } catch {
+    return error;
+  }
+}
+
 /**
  * Parse a dataset string in "name[:version]" format into a DatasetRef object.
  * If version is omitted, defaults to "latest".
@@ -151,7 +198,7 @@ const Loading: React.FC<{ message?: string }> = ({ message }) => (
 
 const ErrorMessage: React.FC<{ error: string }> = ({ error }) => (
   <Box>
-    <Text color="red">Error: {error}</Text>
+    <Text color="red">Error: {formatApiError(error)}</Text>
   </Box>
 );
 
@@ -470,18 +517,103 @@ const AuthStatus: React.FC = () => {
   const { exit } = useApp();
   const apiKey = getApiKey();
   const baseUrl = getBaseUrl();
+  const keyFromEnv = Boolean(process.env.PIONEER_API_KEY);
+  const [validationState, setValidationState] = useState<
+    "no-key" | "checking" | "valid" | "invalid" | "error"
+  >(apiKey ? "checking" : "no-key");
+  const [validationError, setValidationError] = useState<string | null>(null);
 
   useEffect(() => {
-    setTimeout(() => exit(), 500);
-  }, [exit]);
+    let cancelled = false;
+
+    if (!apiKey) {
+      setValidationState("no-key");
+      setValidationError(null);
+      return () => {
+        cancelled = true;
+      };
+    }
+
+    setValidationState("checking");
+    setValidationError(null);
+
+    (async () => {
+      const result = await api.validateApiKey(apiKey);
+      if (cancelled) return;
+
+      if (result.ok) {
+        setValidationState("valid");
+        return;
+      }
+
+      if (result.status === 401 || result.status === 403) {
+        setValidationState("invalid");
+        setValidationError(result.error ? formatApiError(result.error) : null);
+        return;
+      }
+
+      setValidationState("error");
+      setValidationError(
+        result.error ? formatApiError(result.error) : `HTTP ${result.status}`
+      );
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [apiKey]);
+
+  useEffect(() => {
+    if (validationState === "checking") return;
+    const timeout = setTimeout(() => exit(), validationState === "error" ? 2000 : 1200);
+    return () => clearTimeout(timeout);
+  }, [validationState, exit]);
 
   return (
     <Box flexDirection="column">
       <Text>Base URL: {baseUrl}</Text>
       <Text>
-        Logged in:{" "}
+        Logged in (key configured):{" "}
         <Text color={apiKey ? "green" : "red"}>{apiKey ? "Yes" : "No"}</Text>
       </Text>
+      {apiKey && (
+        <Text dimColor>
+          Key source: {keyFromEnv ? "PIONEER_API_KEY environment variable" : "saved config"}
+        </Text>
+      )}
+      {apiKey && (
+        <Text>
+          Key valid for current backend:{" "}
+          <Text
+            color={
+              validationState === "valid"
+                ? "green"
+                : validationState === "invalid"
+                  ? "red"
+                  : validationState === "error"
+                    ? "yellow"
+                    : "cyan"
+            }
+          >
+            {validationState === "valid"
+              ? "Yes"
+              : validationState === "invalid"
+                ? "No"
+                : validationState === "error"
+                  ? "Unable to verify"
+                  : "Checking..."}
+          </Text>
+        </Text>
+      )}
+      {validationState === "invalid" && (
+        <Text dimColor>
+          This API key is not valid for this backend. Dev and prod/local keys are different.
+        </Text>
+      )}
+      {validationError && validationState !== "checking" && (
+        <Text dimColor>Details: {validationError}</Text>
+      )}
+      {!apiKey && <Text dimColor>Run 'pioneer auth login' to configure an API key.</Text>}
     </Box>
   );
 };
@@ -563,17 +695,9 @@ function JobLogsCommand({ jobId }: { jobId: string }) {
     return <ErrorMessage error={error} />;
   }
 
-  const getLogColor = (level: string): string => {
-    switch (level) {
-      case "ERROR":
-        return "red";
-      case "WARNING":
-        return "yellow";
-      case "DEBUG":
-        return "gray";
-      default:
-        return "white";
-    }
+  const formatLogEntry = (log: api.TrainingLog): string => {
+    const ts = new Date(log.timestamp).toLocaleTimeString();
+    return `[${ts}] [${log.level}] ${log.message}`;
   };
 
   return (
@@ -582,8 +706,8 @@ function JobLogsCommand({ jobId }: { jobId: string }) {
         <Text dimColor>No logs available</Text>
       ) : (
         logs.map((log) => (
-          <Text key={log.id} color={getLogColor(log.level)}>
-            {log.message}
+          <Text key={log.id} color={log.level === "ERROR" ? "red" : log.level === "WARNING" ? "yellow" : undefined}>
+            {formatLogEntry(log)}
           </Text>
         ))
       )}
@@ -743,6 +867,271 @@ function GenerateCommand<T extends GenerateResult>({
   );
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Notebook Run Command
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface NotebookCell {
+  cell_type: "code" | "markdown" | "raw";
+  source: string[];
+  metadata?: Record<string, unknown>;
+}
+
+interface NotebookFile {
+  cells: NotebookCell[];
+  metadata?: Record<string, unknown>;
+  nbformat: number;
+  nbformat_minor: number;
+}
+
+function readNotebookFile(filePath: string): NotebookFile {
+  const absPath = path.resolve(filePath);
+  if (!fs.existsSync(absPath)) {
+    throw new Error(`File not found: ${absPath}`);
+  }
+  const content = fs.readFileSync(absPath, "utf-8");
+  return JSON.parse(content) as NotebookFile;
+}
+
+interface NotebookRunCommandProps {
+  filePath: string;
+  gpu: string;
+  loadFelixHelpers: boolean;
+}
+
+function NotebookRunCommand({ filePath, gpu, loadFelixHelpers }: NotebookRunCommandProps) {
+  const { exit } = useApp();
+  const [phase, setPhase] = useState<"reading" | "session" | "running" | "done" | "error">("reading");
+  const [sessionId, setSessionId] = useState<string | null>(null);
+  const [currentCell, setCurrentCell] = useState(0);
+  const [totalCells, setTotalCells] = useState(0);
+  const [outputs, setOutputs] = useState<Array<{ cell: number; source: string; result: api.ExecuteCodeResponse | null; error?: string }>>([]);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    (async () => {
+      // 1. Read notebook
+      let notebook: NotebookFile;
+      try {
+        notebook = readNotebookFile(filePath);
+      } catch (e) {
+        setError(e instanceof Error ? e.message : String(e));
+        setPhase("error");
+        setTimeout(() => exit(), 500);
+        return;
+      }
+
+      const codeCells = notebook.cells.filter((c) => c.cell_type === "code");
+      setTotalCells(codeCells.length);
+
+      if (codeCells.length === 0) {
+        setError("No code cells found in notebook");
+        setPhase("error");
+        setTimeout(() => exit(), 500);
+        return;
+      }
+
+      // 2. Create session
+      setPhase("session");
+      const sessionResult = await api.createNotebookSession({
+        gpu,
+        load_felix_helpers: loadFelixHelpers,
+      });
+
+      if (!sessionResult.ok || !sessionResult.data) {
+        setError(sessionResult.error ?? "Failed to create notebook session");
+        setPhase("error");
+        setTimeout(() => exit(), 500);
+        return;
+      }
+
+      let sid = sessionResult.data.session_id;
+      setSessionId(sid);
+
+      // Poll until session is ready (if status is 'creating')
+      if (sessionResult.data.status === "creating") {
+        let ready = false;
+        for (let attempt = 0; attempt < 60; attempt++) {
+          await new Promise((r) => setTimeout(r, 2000));
+          const status = await api.getNotebookSessionStatus(sid);
+          if (status.ok && status.data?.status === "ready") {
+            // Status response returns the real session_id when ready
+            sid = status.data.session_id;
+            setSessionId(sid);
+            ready = true;
+            break;
+          }
+          if (status.ok && status.data?.status === "failed") {
+            setError(status.data.error ?? "Session creation failed");
+            setPhase("error");
+            setTimeout(() => exit(), 500);
+            return;
+          }
+        }
+        if (!ready) {
+          setError("Session creation timed out after 2 minutes");
+          setPhase("error");
+          setTimeout(() => exit(), 500);
+          return;
+        }
+      }
+
+      // 3. Execute cells sequentially
+      setPhase("running");
+      const cellOutputs: typeof outputs = [];
+
+      for (let i = 0; i < codeCells.length; i++) {
+        setCurrentCell(i + 1);
+        const cell = codeCells[i];
+        const code = Array.isArray(cell.source) ? cell.source.join("") : String(cell.source);
+
+        if (!code.trim()) {
+          cellOutputs.push({ cell: i + 1, source: code, result: null });
+          continue;
+        }
+
+        const execResult = await api.executeNotebookCode({
+          code,
+          session_id: sid,
+          cell_id: `cell-${i}`,
+        });
+
+        if (!execResult.ok) {
+          cellOutputs.push({ cell: i + 1, source: code, result: null, error: execResult.error ?? "Execution failed" });
+          // Continue running remaining cells despite errors
+        } else {
+          cellOutputs.push({ cell: i + 1, source: code, result: execResult.data ?? null });
+        }
+
+        setOutputs([...cellOutputs]);
+      }
+
+      setPhase("done");
+      setTimeout(() => exit(), 1000);
+    })();
+  }, [filePath, gpu, loadFelixHelpers, exit]);
+
+  if (phase === "error") {
+    return <ErrorMessage error={error} />;
+  }
+
+  if (phase === "reading") {
+    return <Loading message="Reading notebook..." />;
+  }
+
+  if (phase === "session") {
+    return <Loading message={`Creating ${gpu} session...`} />;
+  }
+
+  // Render outputs
+  const renderCellOutput = (entry: (typeof outputs)[0]) => {
+    const lines: string[] = [];
+
+    if (entry.error) {
+      lines.push(`  Error: ${entry.error}`);
+      return lines.join("\n");
+    }
+
+    if (!entry.result) {
+      lines.push("  (empty cell)");
+      return lines.join("\n");
+    }
+
+    for (const out of entry.result.outputs) {
+      if (out.type === "stream" && out.text) {
+        // Truncate long stream output
+        const text = out.text.length > 2000 ? out.text.slice(0, 2000) + "\n  ... (truncated)" : out.text;
+        lines.push(text);
+      } else if (out.type === "execute_result" || out.type === "display_data") {
+        if (out.data?.["text/plain"]) {
+          lines.push(out.data["text/plain"]);
+        } else if (out.text) {
+          lines.push(out.text);
+        }
+        if (out.data?.["image/png"]) {
+          lines.push("  [image output]");
+        }
+      } else if (out.type === "error") {
+        lines.push(`  ${out.ename}: ${out.evalue}`);
+        if (out.traceback) {
+          // Strip ANSI codes for cleaner terminal output
+          lines.push(out.traceback.map((l) => l.replace(/\x1b\[[0-9;]*m/g, "")).join("\n"));
+        }
+      }
+    }
+
+    if (entry.result.execution_time_ms) {
+      lines.push(`  (${(entry.result.execution_time_ms / 1000).toFixed(1)}s)`);
+    }
+
+    return lines.join("\n") || "  (no output)";
+  };
+
+  return (
+    <Box flexDirection="column">
+      {phase === "running" && (
+        <Box>
+          <Text color="yellow"><Spinner type="dots" /></Text>
+          <Text> Running cell {currentCell}/{totalCells}...</Text>
+        </Box>
+      )}
+
+      <Static items={outputs}>
+        {(entry) => (
+          <Box key={entry.cell} flexDirection="column" marginBottom={1}>
+            <Text bold color="cyan">── Cell {entry.cell}/{totalCells} ──</Text>
+            <Text dimColor>{entry.source.split("\n").slice(0, 3).join("\n")}{entry.source.split("\n").length > 3 ? "\n  ..." : ""}</Text>
+            <Text color={entry.error || (entry.result && !entry.result.success) ? "red" : undefined}>
+              {renderCellOutput(entry)}
+            </Text>
+          </Box>
+        )}
+      </Static>
+
+      {phase === "done" && (
+        <Box flexDirection="column" marginTop={1}>
+          <Success message={`Notebook complete: ${outputs.length} cells executed`} />
+          {sessionId && <Text dimColor>Session: {sessionId}</Text>}
+          {outputs.some((o) => o.error || (o.result && !o.result.success)) && (
+            <Text color="yellow">Some cells had errors — check output above</Text>
+          )}
+        </Box>
+      )}
+    </Box>
+  );
+}
+
+function createBlankNotebook(name: string): string {
+  const notebook: NotebookFile = {
+    cells: [
+      {
+        cell_type: "markdown",
+        source: [`# ${name}\n`],
+        metadata: {},
+      },
+      {
+        cell_type: "code",
+        source: [],
+        metadata: {},
+      },
+    ],
+    metadata: {
+      kernelspec: { display_name: "Python 3", language: "python", name: "python3" },
+      language_info: { name: "python", version: "3.12.0" },
+    },
+    nbformat: 4,
+    nbformat_minor: 4,
+  };
+
+  const filename = name.endsWith(".ipynb") ? name : `${name}.ipynb`;
+  const filePath = path.resolve(filename);
+  if (fs.existsSync(filePath)) {
+    throw new Error(`File already exists: ${filePath}`);
+  }
+  fs.writeFileSync(filePath, JSON.stringify(notebook, null, 1));
+  return filePath;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Helper: Infer format from file extension
 // ─────────────────────────────────────────────────────────────────────────────
@@ -830,6 +1219,164 @@ function DatasetListCommand() {
   );
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Competition List Command
+// ─────────────────────────────────────────────────────────────────────────────
+
+function CompetitionListCommand() {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done" | "error">("loading");
+  const [competitions, setCompetitions] = useState<api.CompetitionInfo[]>([]);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    (async () => {
+      const result = await api.listCompetitions();
+      if (result.ok && result.data) {
+        setCompetitions(result.data.competitions || []);
+        setState("done");
+      } else {
+        setError(result.error ?? "Unknown error");
+        setState("error");
+      }
+      setTimeout(() => exit(), 500);
+    })();
+  }, [exit]);
+
+  if (state === "loading") {
+    return <Loading message="Loading competitions..." />;
+  }
+
+  if (state === "error") {
+    return <ErrorMessage error={error} />;
+  }
+
+  if (competitions.length === 0) {
+    return <Text dimColor>No active competitions found.</Text>;
+  }
+
+  return (
+    <Box flexDirection="column">
+      <Text bold color="cyan">Active Competitions ({competitions.length})</Text>
+      <Text> </Text>
+      {competitions.map((comp, idx) => (
+        <Box key={comp.dataset_id} flexDirection="column" marginBottom={1}>
+          <Text bold color="yellow">
+            {idx + 1}. {comp.dataset_name}
+          </Text>
+          <Text>
+            {"  "}Type: <Text color="magenta">{comp.dataset_type}</Text>
+            {"  "}Samples: <Text color="blue">{comp.sample_count ?? "N/A"}</Text>
+            {"  "}Entries: <Text color="green">{comp.total_entries}</Text>
+          </Text>
+          {comp.description && (
+            <Text dimColor>{"  "}{comp.description}</Text>
+          )}
+          {comp.labels && comp.labels.length > 0 && (
+            <Text>{"  "}Labels: <Text color="cyan">{comp.labels.join(", ")}</Text></Text>
+          )}
+          {comp.winner && (
+            <Text>
+              {"  "}Winner: <Text color="green" bold>{comp.winner.display_name}</Text>
+              {" "}(F1: <Text color="yellow">{comp.winner.f1_score.toFixed(4)}</Text>)
+            </Text>
+          )}
+          <Text dimColor>{"  "}ID: {comp.dataset_id}</Text>
+        </Box>
+      ))}
+    </Box>
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Leaderboard Command
+// ─────────────────────────────────────────────────────────────────────────────
+
+function LeaderboardCommand({ datasetId, limit }: { datasetId: string; limit?: number }) {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done" | "error">("loading");
+  const [data, setData] = useState<api.LeaderboardEntriesResponse | null>(null);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    (async () => {
+      const result = await api.getLeaderboardEntries(datasetId, limit);
+      if (result.ok && result.data) {
+        setData(result.data);
+        setState("done");
+      } else {
+        setError(result.error ?? "Unknown error");
+        setState("error");
+      }
+      setTimeout(() => exit(), 500);
+    })();
+  }, [datasetId, limit, exit]);
+
+  if (state === "loading") {
+    return <Loading message="Loading leaderboard..." />;
+  }
+
+  if (state === "error") {
+    return <ErrorMessage error={error} />;
+  }
+
+  if (!data || data.entries.length === 0) {
+    return (
+      <Box flexDirection="column">
+        <Text bold color="cyan">Leaderboard: {data?.dataset_name ?? datasetId}</Text>
+        <Text dimColor>  No entries yet. Be the first to submit!</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column">
+      <Text bold color="cyan">Leaderboard: {data.dataset_name} ({data.total_entries} entries)</Text>
+      <Text> </Text>
+      {/* Header */}
+      <Box>
+        <Box width={6}><Text bold dimColor>Rank</Text></Box>
+        <Box width={22}><Text bold dimColor>Name</Text></Box>
+        <Box width={22}><Text bold dimColor>Model</Text></Box>
+        <Box width={10}><Text bold dimColor>F1</Text></Box>
+        <Box width={10}><Text bold dimColor>Precision</Text></Box>
+        <Box width={10}><Text bold dimColor>Recall</Text></Box>
+      </Box>
+      {/* Entries */}
+      {data.entries.map((entry, idx) => {
+        const rank = entry.rank ?? idx + 1;
+        const isFirst = rank === 1;
+        return (
+          <Box key={entry.id}>
+            <Box width={6}>
+              <Text color={isFirst ? "yellow" : undefined} bold={isFirst}>
+                {isFirst ? `#${rank}` : `#${rank}`}
+              </Text>
+            </Box>
+            <Box width={22}>
+              <Text color={isFirst ? "yellow" : undefined} bold={isFirst}>
+                {entry.display_name.substring(0, 20)}
+              </Text>
+            </Box>
+            <Box width={22}>
+              <Text color="cyan">{entry.model_name.substring(0, 20)}</Text>
+            </Box>
+            <Box width={10}>
+              <Text color="green" bold>{entry.f1_score.toFixed(4)}</Text>
+            </Box>
+            <Box width={10}>
+              <Text>{entry.precision_score?.toFixed(4) ?? "N/A"}</Text>
+            </Box>
+            <Box width={10}>
+              <Text>{entry.recall_score?.toFixed(4) ?? "N/A"}</Text>
+            </Box>
+          </Box>
+        );
+      })}
+    </Box>
+  );
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Job Create Command (with auto-upload for local datasets)
 // ─────────────────────────────────────────────────────────────────────────────
@@ -1579,20 +2126,201 @@ function ModelListCommand({ filter }: ModelListCommandProps) {
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Help Components
+// Model Generate Command (decoder pre-check + better errors)
 // ─────────────────────────────────────────────────────────────────────────────
 
-type HelpContext = "root" | "auth" | "dataset" | "dataset-analyze" | "dataset-edit" | "job" | "model" | "chat" | "eval" | "benchmark";
+interface ModelGenerateCommandProps {
+  modelId: string;
+  prompt: string;
+  systemMsg?: string;
+  maxTokens: number;
+  temperature: number;
+}
 
-interface HelpProps {
-  context?: HelpContext;
+function normalizeBaseModels(
+  data: api.BaseModelsResponse | api.BaseModelInfo[] | null | undefined
+): api.BaseModelInfo[] {
+  if (!data) return [];
+  if (Array.isArray(data)) return data;
+  if (Array.isArray(data.models)) return data.models;
+  return [];
 }
 
-const Help: React.FC<HelpProps> = ({ context = "root" }) => {
-  const { exit } = useApp();
+function isUuid(value: string): boolean {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+    value
+  );
+}
 
-  useEffect(() => {
-    setTimeout(() => exit(), 500);
+function formatDecoderSuggestions(decoderIds: string[]): string {
+  if (decoderIds.length === 0) return "";
+  return `\nTry one of these decoder models: ${decoderIds.slice(0, 4).join(", ")}`;
+}
+
+function ModelGenerateCommand({
+  modelId,
+  prompt,
+  systemMsg,
+  maxTokens,
+  temperature,
+}: ModelGenerateCommandProps) {
+  const { exit } = useApp();
+  const [state, setState] = useState<"checking" | "running" | "done" | "error">(
+    "checking"
+  );
+  const [data, setData] = useState<api.InferenceResponse | null>(null);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    let active = true;
+
+    (async () => {
+      const baseModelsResult = await api.listBaseModels();
+      const baseModels =
+        baseModelsResult.ok && baseModelsResult.data
+          ? normalizeBaseModels(baseModelsResult.data)
+          : [];
+      const decoderModelIds = baseModels
+        .filter((model) => model.type === "decoder")
+        .map((model) => model.id);
+
+      const fail = (message: string) => {
+        if (!active) return;
+        setError(message);
+        setState("error");
+        setTimeout(() => exit(), 500);
+      };
+
+      if (modelId === "base") {
+        fail(
+          "Model 'base' is encoder-only and cannot run decoder generation. Use 'model predict' for encoder tasks." +
+            formatDecoderSuggestions(decoderModelIds)
+        );
+        return;
+      }
+
+      const matchedBaseModel = baseModels.find((model) => model.id === modelId);
+      if (matchedBaseModel && matchedBaseModel.type !== "decoder") {
+        const modelName = matchedBaseModel.label || matchedBaseModel.name || matchedBaseModel.id;
+        fail(
+          `Model '${modelName}' is type '${matchedBaseModel.type}' and is not decoder-compatible.` +
+            formatDecoderSuggestions(decoderModelIds)
+        );
+        return;
+      }
+
+      if (modelId.startsWith("base:") && baseModels.length > 0 && !matchedBaseModel) {
+        fail(
+          `Unknown base model '${modelId}'.` + formatDecoderSuggestions(decoderModelIds)
+        );
+        return;
+      }
+
+      if (isUuid(modelId)) {
+        const jobResult = await api.getJob(modelId);
+        if (jobResult.ok && jobResult.data) {
+          const taskType = jobResult.data.task_type?.toLowerCase();
+          if (taskType && taskType !== "decoder") {
+            fail(
+              `Training job '${modelId}' has task_type '${taskType}', so it is not decoder-compatible.` +
+                formatDecoderSuggestions(decoderModelIds)
+            );
+            return;
+          }
+        }
+      }
+
+      if (!active) return;
+      setState("running");
+
+      const messages: Array<{ role: "system" | "user" | "assistant"; content: string }> = [];
+      if (systemMsg) {
+        messages.push({ role: "system", content: systemMsg });
+      }
+      messages.push({ role: "user", content: prompt });
+
+      const result = await api.runInference({
+        model_id: modelId,
+        task: "generate",
+        messages,
+        max_tokens: maxTokens,
+        temperature,
+      });
+
+      if (!active) return;
+
+      if (result.ok && result.data) {
+        setData(result.data);
+        setState("done");
+      } else {
+        let message = result.error ?? "Unknown error";
+        const normalizedError = formatApiError(message);
+        if (normalizedError.toLowerCase().includes("inference failed")) {
+          message =
+            `${normalizedError}\nDecoder inference request reached the backend but failed to execute.` +
+            formatDecoderSuggestions(decoderModelIds);
+        }
+        setError(message);
+        setState("error");
+      }
+
+      setTimeout(() => exit(), 500);
+    })();
+
+    return () => {
+      active = false;
+    };
+  }, [modelId, prompt, systemMsg, maxTokens, temperature, exit]);
+
+  if (state === "checking") {
+    return <Loading message="Checking decoder model compatibility..." />;
+  }
+
+  if (state === "running") {
+    return <Loading message="Running decoder inference..." />;
+  }
+
+  if (state === "error") {
+    return <ErrorMessage error={error} />;
+  }
+
+  return (
+    <Box flexDirection="column">
+      {data && <JsonOutput data={data} />}
+    </Box>
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Help Components
+// ─────────────────────────────────────────────────────────────────────────────
+
+type HelpContext =
+  | "root"
+  | "auth"
+  | "dataset"
+  | "dataset-analyze"
+  | "dataset-edit"
+  | "project"
+  | "job"
+  | "model"
+  | "chat"
+  | "eval"
+  | "benchmark"
+  | "competition"
+  | "notebook"
+  | "inference"
+  | "adaptive-finetuning";
+
+interface HelpProps {
+  context?: HelpContext;
+}
+
+const Help: React.FC<HelpProps> = ({ context = "root" }) => {
+  const { exit } = useApp();
+
+  useEffect(() => {
+    setTimeout(() => exit(), 500);
   }, [exit]);
 
   // Auth help
@@ -1652,6 +2380,13 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <Text>    --save true               Save to database</Text>
         <Text>    --name {"<name>"}             Dataset name (required if --save)</Text>
         <Text> </Text>
+        <Text>  dataset generate decoder</Text>
+        <Text>    --domain {"<desc>"}           Domain/task description (required)</Text>
+        <Text>    --instruction {"<text>"}      System instruction (optional, auto-inferred)</Text>
+        <Text>    --num {"<n>"}                 Number of examples (default: 10)</Text>
+        <Text>    --save true               Save to database</Text>
+        <Text>    --name {"<name>"}             Dataset name (required if --save)</Text>
+        <Text> </Text>
         <Text bold>  Infer Labels:</Text>
         <Text>  dataset infer ner              Infer NER labels from description</Text>
         <Text>  dataset infer classification   Infer classification labels</Text>
@@ -1730,6 +2465,29 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
     );
   }
 
+  // Project help
+  if (context === "project") {
+    return (
+      <Box flexDirection="column">
+        <Text bold>Project Commands:</Text>
+        <Text>  project list                         List all projects</Text>
+        <Text>  project get {"<project-id>"}                 Get project details</Text>
+        <Text>  project create                       Create a project</Text>
+        <Text>    --name {"<name>"}                    Project name (required)</Text>
+        <Text>    --icon {"<icon>"}                    Icon name (optional, default: folder)</Text>
+        <Text>    --repo {"<repo-url>"}                Repository URL/reference (optional)</Text>
+        <Text>    --description {"<text>"}             Description (optional)</Text>
+        <Text>    --model-id {"<id>"}                  Selected model ID (optional)</Text>
+        <Text>    --example {"<json>"}                 JSON example payload (optional)</Text>
+        <Text>  project update {"<project-id>"}              Update project fields</Text>
+        <Text>    --name {"<name>"} --icon {"<icon>"} --repo {"<repo-url>"} --description {"<text>"} --model-id {"<id>"}</Text>
+        <Text>  project delete {"<project-id>"}              Delete a project</Text>
+        <Text>  project dataset-count {"<project-id>"}       Show attached dataset count</Text>
+        <Text>  project quality-metrics {"<project-id>"}     Show LLMAJ pass/fail metrics</Text>
+      </Box>
+    );
+  }
+
   // Job help
   if (context === "job") {
     return (
@@ -1762,6 +2520,16 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <Text>  model delete {"<job-id>"}  Undeploy a model by training job ID</Text>
         <Text>  model download {"<job-id>"}  Get model download URL by job ID</Text>
         <Text> </Text>
+        <Text bold>  Inference:</Text>
+        <Text>  model predict {"<job-id>"} --text {"<text>"} --labels {"<labels>"}  Run NER inference</Text>
+        <Text>    --task {"<task>"}            Task: extract_entities, classify_text, extract_json (default: extract_entities)</Text>
+        <Text>    --threshold {"<n>"}          Confidence threshold 0-1 (default: 0.5)</Text>
+        <Text>  model generate {"<model-id>"} --prompt {"<text>"}  Run decoder generation</Text>
+        <Text>    --system {"<text>"}          System message (optional)</Text>
+        <Text>    --max-tokens {"<n>"}         Max tokens to generate (default: 256)</Text>
+        <Text>    --temperature {"<n>"}        Sampling temperature (default: 0.7)</Text>
+        <Text dimColor>    model-id can be a decoder training job UUID or base:{"<provider/model>"}</Text>
+        <Text> </Text>
         <Text bold>  Upload:</Text>
         <Text>  model upload {"<job-id>"} --to hf   Upload trained model to Hugging Face</Text>
         <Text>    --repo {"<repo>"}              HF repo (required, e.g., username/model)</Text>
@@ -1772,6 +2540,30 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
     );
   }
 
+  // Inference help
+  if (context === "inference") {
+    return (
+      <Box flexDirection="column">
+        <Text bold>Inference Commands:</Text>
+        <Text>  model predict {"<model-id>"} --text {"<text>"} --labels {"<labels>"}</Text>
+        <Text>    Run encoder inference (NER, classification, JSON extraction)</Text>
+        <Text>    Use "base" as model-id for the base GLiNER2 model</Text>
+        <Text> </Text>
+        <Text>  model generate {"<model-id>"} --prompt {"<text>"}</Text>
+        <Text>    Run decoder text generation on a decoder model</Text>
+        <Text>    Example base IDs: base:Qwen/Qwen3-8B, base:meta-llama/Llama-3.1-8B-Instruct</Text>
+        <Text> </Text>
+        <Text bold>  Options:</Text>
+        <Text>    --task {"<task>"}         extract_entities | classify_text | extract_json | schema</Text>
+        <Text>    --labels {"<labels>"}    Comma-separated labels for extraction/classification</Text>
+        <Text>    --threshold {"<n>"}      Confidence threshold (0-1, default: 0.5)</Text>
+        <Text>    --system {"<text>"}      System message for decoder generation</Text>
+        <Text>    --max-tokens {"<n>"}     Max tokens for generation (default: 256)</Text>
+        <Text>    --temperature {"<n>"}    Sampling temperature (default: 0.7)</Text>
+      </Box>
+    );
+  }
+
   // Chat help
   if (context === "chat") {
     return (
@@ -1822,6 +2614,55 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
     );
   }
 
+  // Adaptive fine-tuning help
+  if (context === "adaptive-finetuning") {
+    return (
+      <Box flexDirection="column">
+        <Text bold>Adaptive Fine-tuning Commands:</Text>
+        <Text>  adaptive-finetuning chat             Send a request to the adaptive FT agent</Text>
+        <Text>    --message {"<text>"}                 Instruction (required)</Text>
+        <Text>    --conversation-id {"<id>"}           Continue an existing conversation</Text>
+        <Text>    --filters {"<json>"}                 Optional query filters JSON</Text>
+        <Text>    --history {"<json>"}                 Optional message history JSON</Text>
+        <Text> </Text>
+        <Text dimColor>  Alias: aft</Text>
+        <Text dimColor>  Example: pioneer adaptive-finetuning chat --message "Analyze failures from last 24h and propose retraining plan"</Text>
+      </Box>
+    );
+  }
+
+  // Competition help
+  if (context === "competition") {
+    return (
+      <Box flexDirection="column">
+        <Text bold>Competition Commands:</Text>
+        <Text>  competition list                     List active competitions</Text>
+        <Text>  competition show {"<dataset-id>"}         View sample data for a competition</Text>
+        <Text>  competition leaderboard {"<dataset-id>"}  View leaderboard rankings</Text>
+        <Text>    --limit {"<n>"}                        Number of entries (default: 10)</Text>
+        <Text>  competition submit {"<dataset-id>"}       Submit evaluation to leaderboard</Text>
+        <Text>    --eval-id {"<id>"}                     Evaluation ID (required)</Text>
+        <Text>    --name {"<name>"}                      Display name (required)</Text>
+      </Box>
+    );
+  }
+
+  // Notebook help
+  if (context === "notebook") {
+    return (
+      <Box flexDirection="column">
+        <Text bold>Notebook Commands:</Text>
+        <Text> </Text>
+        <Text>  notebook run {"<file>"}              Run all cells in a .ipynb notebook</Text>
+        <Text>    --gpu {"<type>"}                   GPU type: cpu, t4, a10g, a100, h100 (default: cpu)</Text>
+        <Text>    --no-felix                       Don't inject Felix helper functions</Text>
+        <Text>  notebook create {"<name>"}           Create a blank notebook</Text>
+        <Text>  notebook sessions                  List active notebook sessions</Text>
+        <Text>  notebook stop {"<session-id>"}       Terminate a notebook session</Text>
+      </Box>
+    );
+  }
+
   // Root help - overview only
   return (
     <Box flexDirection="column">
@@ -1834,10 +2675,14 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
       <Text>  chat       Start interactive chat agent</Text>
       <Text>  auth       Authentication (login, logout, status)</Text>
       <Text>  dataset    Manage datasets (list, generate, edit, analyze)</Text>
+      <Text>  project    Manage projects</Text>
       <Text>  job        Manage training jobs</Text>
       <Text>  model      Manage models</Text>
       <Text>  eval       Model evaluations on datasets</Text>
       <Text>  benchmark  Run benchmark evaluations</Text>
+      <Text>  notebook   Run and manage Jupyter notebooks</Text>
+      <Text>  competition Competitions and leaderboards</Text>
+      <Text>  adaptive-finetuning  Adaptive fine-tuning agent</Text>
       <Text>  telemetry  Manage anonymous usage analytics</Text>
       <Text> </Text>
       <Text dimColor>Run 'pioneer {"<command>"} --help' for details on a specific command.</Text>
@@ -2179,6 +3024,9 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
         }
 
         const hfToken = getHfToken(hfTokenFlag);
+        if (!hfToken) {
+          return <ErrorMessage error="HuggingFace token is required. Set HF_TOKEN env var or use --hf-token flag." />;
+        }
 
         return (
           <ApiCommand
@@ -2186,7 +3034,7 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
               api.pullDatasetFromHub({
                 repo_id: repo,
                 hf_token: hfToken,
-                dataset_name: datasetName,
+                name: datasetName,
                 revision,
               })
             }
@@ -2336,6 +3184,29 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
         );
       }
 
+      if (subAction === "decoder") {
+        const instruction = flags["instruction"];
+        if (!domainDescription) {
+          return <ErrorMessage error="--domain is required for decoder generation" />;
+        }
+        return (
+          <GenerateCommand
+            action={() =>
+              api.generateDecoder({
+                domain_description: domainDescription!,
+                instruction,
+                num_examples: numExamples,
+                save_dataset: saveDataset,
+                dataset_name: datasetName,
+              })
+            }
+            datasetName={datasetName || "decoder-dataset"}
+            datasetType="custom"
+            saveToRemote={saveDataset}
+          />
+        );
+      }
+
       return <Help context="dataset" />;
     }
 
@@ -2378,6 +3249,136 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
     return <Help context="dataset" />;
   }
 
+  // Project commands
+  if (group === "project") {
+    if (flags.help === "true" || !action || action === "help") {
+      return <Help context="project" />;
+    }
+
+    if (action === "list") {
+      return <ApiCommand action={api.listProjects} />;
+    }
+
+    if (action === "get") {
+      const projectId = rest[0];
+      if (!projectId) {
+        return <ErrorMessage error="Project ID required: project get <project-id>" />;
+      }
+      return <ApiCommand action={() => api.getProject(projectId)} />;
+    }
+
+    if (action === "create") {
+      const name = flags["name"];
+      const icon = flags["icon"];
+      const repo = flags["repo"];
+      const description = flags["description"];
+      const modelId = flags["model-id"];
+      const exampleStr = flags["example"];
+
+      if (!name) {
+        return <ErrorMessage error="--name is required for project creation" />;
+      }
+
+      let example: Record<string, unknown> | undefined;
+      if (exampleStr) {
+        try {
+          const parsed = JSON.parse(exampleStr) as unknown;
+          if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") {
+            return <ErrorMessage error="--example must be a JSON object" />;
+          }
+          example = parsed as Record<string, unknown>;
+        } catch {
+          return <ErrorMessage error="--example must be valid JSON" />;
+        }
+      }
+
+      return (
+        <ApiCommand
+          action={() =>
+            api.createProject({
+              name,
+              ...(icon ? { icon } : {}),
+              ...(repo ? { repo } : {}),
+              ...(description ? { description } : {}),
+              ...(modelId ? { selected_model_id: modelId } : {}),
+              ...(example ? { example } : {}),
+            })
+          }
+          successMessage="Project created"
+        />
+      );
+    }
+
+    if (action === "update") {
+      const projectId = rest[0];
+      if (!projectId) {
+        return <ErrorMessage error="Project ID required: project update <project-id>" />;
+      }
+
+      const name = flags["name"];
+      const icon = flags["icon"];
+      const repo = flags["repo"];
+      const description = flags["description"];
+      const modelId = flags["model-id"];
+
+      if (!name && !icon && !repo && !description && !modelId) {
+        return (
+          <ErrorMessage error="Provide at least one field to update: --name, --icon, --repo, --description, or --model-id" />
+        );
+      }
+
+      return (
+        <ApiCommand
+          action={() =>
+            api.updateProject(projectId, {
+              ...(name ? { name } : {}),
+              ...(icon ? { icon } : {}),
+              ...(repo ? { repo } : {}),
+              ...(description ? { description } : {}),
+              ...(modelId ? { selected_model_id: modelId } : {}),
+            })
+          }
+          successMessage="Project updated"
+        />
+      );
+    }
+
+    if (action === "delete") {
+      const projectId = rest[0];
+      if (!projectId) {
+        return <ErrorMessage error="Project ID required: project delete <project-id>" />;
+      }
+      return (
+        <ApiCommand
+          action={() => api.deleteProject(projectId)}
+          successMessage={`Project ${projectId} deleted`}
+        />
+      );
+    }
+
+    if (action === "dataset-count" || action === "count") {
+      const projectId = rest[0];
+      if (!projectId) {
+        return (
+          <ErrorMessage error="Project ID required: project dataset-count <project-id>" />
+        );
+      }
+      return <ApiCommand action={() => api.getProjectDatasetCount(projectId)} />;
+    }
+
+    if (action === "quality-metrics" || action === "quality") {
+      const projectId = rest[0];
+      if (!projectId) {
+        return (
+          <ErrorMessage error="Project ID required: project quality-metrics <project-id>" />
+        );
+      }
+      return <ApiCommand action={() => api.getProjectQualityMetrics(projectId)} />;
+    }
+
+    return <Help context="project" />;
+  }
+
   // Job commands
   if (group === "job") {
     if (flags.help === "true" || !action || action === "help") {
@@ -2550,6 +3551,62 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
 
       return <ErrorMessage error="--to is required. Supported destinations: hf" />;
     }
+    // Model predict command (encoder inference)
+    if (action === "predict") {
+      const modelId = rest[0];
+      if (!modelId) {
+        return <ErrorMessage error="Model ID required. Usage: model predict <model-id> --text <text> --labels <labels>" />;
+      }
+      const text = flags["text"];
+      const labelsStr = flags["labels"];
+      if (!text) {
+        return <ErrorMessage error="--text is required for inference" />;
+      }
+      if (!labelsStr) {
+        return <ErrorMessage error="--labels is required (comma-separated, e.g., PERSON,ORG,LOCATION)" />;
+      }
+      const labels = labelsStr.split(",").map((l: string) => l.trim());
+      const task = (flags["task"] || "extract_entities") as "extract_entities" | "classify_text" | "extract_json" | "schema";
+      const threshold = flags["threshold"] ? parseFloat(flags["threshold"]) : 0.5;
+
+      return (
+        <ApiCommand
+          action={() =>
+            api.runInference({
+              model_id: modelId,
+              task,
+              text,
+              schema: labels,
+              threshold,
+              include_confidence: true,
+            })
+          }
+        />
+      );
+    }
+    // Model generate command (decoder inference)
+    if (action === "generate") {
+      const modelId = rest[0];
+      if (!modelId) {
+        return <ErrorMessage error="Model ID required. Usage: model generate <model-id> --prompt <text>" />;
+      }
+      const prompt = flags["prompt"];
+      if (!prompt) {
+        return <ErrorMessage error="--prompt is required for text generation" />;
+      }
+      const systemMsg = flags["system"];
+      const maxTokens = flags["max-tokens"] ? parseInt(flags["max-tokens"]) : 256;
+      const temperature = flags["temperature"] ? parseFloat(flags["temperature"]) : 0.7;
+      return (
+        <ModelGenerateCommand
+          modelId={modelId}
+          prompt={prompt}
+          systemMsg={systemMsg}
+          maxTokens={maxTokens}
+          temperature={temperature}
+        />
+      );
+    }
     return <Help context="model" />;
   }
 
@@ -2593,9 +3650,9 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
             api.createEvaluation({
               model_id: modelId,
               dataset,
-              task_type: taskType,
-              text_column: textColumn,
-              label_column: labelColumn,
+              ...(taskType ? { task_type: taskType } : {}),
+              ...(textColumn ? { text_column: textColumn } : {}),
+              ...(labelColumn ? { label_column: labelColumn } : {}),
             })
           }
           successMessage="Evaluation created"
@@ -2653,6 +3710,154 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
     return <Help context="benchmark" />;
   }
 
+  // Notebook commands
+  if (group === "notebook") {
+    if (flags.help === "true" || !action || action === "help") {
+      return <Help context="notebook" />;
+    }
+
+    if (action === "run") {
+      const file = rest[0];
+      if (!file) {
+        return <ErrorMessage error="File path required: notebook run <file.ipynb>" />;
+      }
+      const gpu = flags.gpu || "cpu";
+      const loadFelixHelpers = flags["no-felix"] !== "true";
+      return <NotebookRunCommand filePath={file} gpu={gpu} loadFelixHelpers={loadFelixHelpers} />;
+    }
+
+    if (action === "create") {
+      const name = rest[0] || flags.name;
+      if (!name) {
+        return <ErrorMessage error="Name required: notebook create <name>" />;
+      }
+      try {
+        const filePath = createBlankNotebook(name);
+        return <Success message={`Created notebook: ${filePath}`} />;
+      } catch (e) {
+        return <ErrorMessage error={e instanceof Error ? e.message : String(e)} />;
+      }
+    }
+
+    if (action === "sessions") {
+      return <ApiCommand action={api.listNotebookSessions} />;
+    }
+
+    if (action === "stop") {
+      const sessionId = rest[0];
+      if (!sessionId) {
+        return <ErrorMessage error="Session ID required: notebook stop <session-id>" />;
+      }
+      return (
+        <ApiCommand
+          action={() => api.terminateNotebookSession(sessionId)}
+          successMessage={`Session ${sessionId} terminated`}
+        />
+      );
+    }
+
+    return <Help context="notebook" />;
+  }
+
+  // Adaptive fine-tuning commands
+  if (group === "adaptive-finetuning" || group === "aft") {
+    if (flags.help === "true" || action === "help") {
+      return <Help context="adaptive-finetuning" />;
+    }
+
+    let message = flags.message;
+    if (!message) {
+      const rawParts = action === "chat" ? rest : [action, ...rest];
+      message = rawParts.filter(Boolean).join(" ").trim();
+    }
+
+    if (!message) {
+      return (
+        <ErrorMessage
+          error={'Message required. Usage: adaptive-finetuning chat --message "Analyze failures and propose retraining plan"'}
+        />
+      );
+    }
+
+    let history: api.AdaptiveFinetuningHistoryItem[] | undefined;
+    if (flags.history) {
+      try {
+        const parsed = JSON.parse(flags.history) as unknown;
+        if (!Array.isArray(parsed)) {
+          return <ErrorMessage error="--history must be a JSON array" />;
+        }
+        history = parsed as api.AdaptiveFinetuningHistoryItem[];
+      } catch {
+        return <ErrorMessage error="--history must be valid JSON" />;
+      }
+    }
+
+    let filters: api.AdaptiveFinetuningQueryFilters | undefined;
+    if (flags.filters) {
+      try {
+        const parsed = JSON.parse(flags.filters) as unknown;
+        if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") {
+          return <ErrorMessage error="--filters must be a JSON object" />;
+        }
+        filters = parsed as api.AdaptiveFinetuningQueryFilters;
+      } catch {
+        return <ErrorMessage error="--filters must be valid JSON" />;
+      }
+    }
+
+    return (
+      <ApiCommand
+        action={() =>
+          api.adaptiveFinetuningChat({
+            message,
+            ...(flags["conversation-id"] ? { conversation_id: flags["conversation-id"] } : {}),
+            ...(history ? { history } : {}),
+            ...(filters ? { filters } : {}),
+          })
+        }
+        successMessage="Adaptive fine-tuning response received"
+      />
+    );
+  }
+
+  // Competition commands
+  if (group === "competition") {
+    if (flags.help === "true" || !action || action === "help") {
+      return <Help context="competition" />;
+    }
+    if (action === "list") {
+      return <CompetitionListCommand />;
+    }
+    if (action === "show" && rest[0]) {
+      return <ApiCommand action={() => api.getCompetitionSamples(rest[0])} />;
+    }
+    if (action === "leaderboard" && rest[0]) {
+      const limit = flags["limit"] ? parseInt(flags["limit"], 10) : undefined;
+      return <LeaderboardCommand datasetId={rest[0]} limit={limit} />;
+    }
+    if (action === "submit" && rest[0]) {
+      const evalId = flags["eval-id"];
+      const displayName = flags["name"];
+
+      if (!evalId || !displayName) {
+        return <ErrorMessage error="--eval-id and --name are required" />;
+      }
+
+      return (
+        <ApiCommand
+          action={() =>
+            api.submitToLeaderboard(rest[0], {
+              evaluation_id: evalId,
+              display_name: displayName,
+            })
+          }
+          successMessage="Submitted to leaderboard"
+        />
+      );
+    }
+    return <Help context="competition" />;
+  }
+
   return <Help />;
 };