opensciencenet-cli 0.1.0

package/bin/os-cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/index.js')

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "opensciencenet-cli",
+  "version": "0.1.0",
+  "description": "Mining CLI for the OpenScienceNet Proof of Useful Work platform",
+  "type": "module",
+  "bin": {
+    "os-cli": "bin/os-cli.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.tsx",
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "ink": "^5.1.0",
+    "ink-text-input": "^6.0.0",
+    "ink-spinner": "^5.0.0",
+    "chalk": "^5.4.1",
+    "@anthropic-ai/sdk": "^0.39.0",
+    "openai": "^4.80.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.0",
+    "typescript": "^5.7.0",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.0",
+    "@types/node": "^22.0.0"
+  }
+}

package/src/api.ts

@@ -0,0 +1,33 @@
+import { loadConfig, getToken } from './config.js'
+
+type RequestOptions = {
+  method?: string
+  body?: unknown
+  auth?: boolean
+}
+
+export async function api<T = unknown>(path: string, opts: RequestOptions = {}): Promise<T> {
+  const config = loadConfig()
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' }
+  if (opts.auth !== false) {
+    headers['Authorization'] = `Bearer ${getToken()}`
+  }
+
+  const resp = await fetch(`${config.server_url}${path}`, {
+    method: opts.method || (opts.body ? 'POST' : 'GET'),
+    headers,
+    body: opts.body ? JSON.stringify(opts.body) : undefined,
+  })
+
+  const data = await resp.json() as T & { detail?: string }
+
+  if (!resp.ok) {
+    throw new Error(data.detail || `HTTP ${resp.status}`)
+  }
+
+  return data
+}
+
+export async function apiNoAuth<T = unknown>(path: string, opts: RequestOptions = {}): Promise<T> {
+  return api<T>(path, { ...opts, auth: false })
+}

package/src/commands/auth.tsx

@@ -0,0 +1,169 @@
+import React, { useState, useEffect } from 'react'
+import { Box, Text, useApp } from 'ink'
+import TextInput from 'ink-text-input'
+import { Header } from '../components/Header.js'
+import { StatusIcon } from '../components/StatusIcon.js'
+import { Table } from '../components/Table.js'
+import { theme } from '../theme.js'
+import { api, apiNoAuth } from '../api.js'
+import { saveConfig, loadConfig } from '../config.js'
+
+// --- Register ---
+
+export function Register() {
+  const { exit } = useApp()
+  const [step, setStep] = useState<'username' | 'email' | 'password' | 'done'>('username')
+  const [username, setUsername] = useState('')
+  const [email, setEmail] = useState('')
+  const [password, setPassword] = useState('')
+  const [result, setResult] = useState<string | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  const handleSubmit = async (val: string) => {
+    if (step === 'username') { setUsername(val); setStep('email') }
+    else if (step === 'email') { setEmail(val); setStep('password') }
+    else if (step === 'password') {
+      setPassword(val)
+      try {
+        const data = await apiNoAuth<any>('/api/auth/register', {
+          body: { username, email, password: val },
+        })
+        setResult(`Account created! You received ${data.balance} OS coins.`)
+      } catch (e: any) {
+        setError(e.message)
+      }
+      setStep('done')
+    }
+  }
+
+  useEffect(() => { if (step === 'done') setTimeout(() => exit(), 100) }, [step])
+
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      <Header title="Register" />
+      {step === 'username' && <Box><Text color={theme.brand}>Username: </Text><TextInput value={username} onChange={setUsername} onSubmit={handleSubmit} /></Box>}
+      {step === 'email' && <Box><Text color={theme.brand}>Email: </Text><TextInput value={email} onChange={setEmail} onSubmit={handleSubmit} /></Box>}
+      {step === 'password' && <Box><Text color={theme.brand}>Password: </Text><TextInput value={password} onChange={setPassword} onSubmit={handleSubmit} mask="*" /></Box>}
+      {result && <Text><StatusIcon status="success" /> <Text color={theme.success}>{result}</Text></Text>}
+      {error && <Text><StatusIcon status="error" /> <Text color={theme.error}>{error}</Text></Text>}
+    </Box>
+  )
+}
+
+// --- Login ---
+
+export function Login() {
+  const { exit } = useApp()
+  const [step, setStep] = useState<'email' | 'password' | 'done'>('email')
+  const [email, setEmail] = useState('')
+  const [password, setPassword] = useState('')
+  const [result, setResult] = useState<string | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  const handleSubmit = async (val: string) => {
+    if (step === 'email') { setEmail(val); setStep('password') }
+    else if (step === 'password') {
+      try {
+        const data = await apiNoAuth<any>('/api/auth/login', {
+          body: { email, password: val },
+        })
+        saveConfig({ auth_token: data.access_token })
+        setResult('Logged in successfully.')
+      } catch (e: any) {
+        setError(e.message)
+      }
+      setStep('done')
+    }
+  }
+
+  useEffect(() => { if (step === 'done') setTimeout(() => exit(), 100) }, [step])
+
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      <Header title="Login" />
+      {step === 'email' && <Box><Text color={theme.brand}>Email: </Text><TextInput value={email} onChange={setEmail} onSubmit={handleSubmit} /></Box>}
+      {step === 'password' && <Box><Text color={theme.brand}>Password: </Text><TextInput value={password} onChange={setPassword} onSubmit={handleSubmit} mask="*" /></Box>}
+      {result && <Text><StatusIcon status="success" /> <Text color={theme.success}>{result}</Text></Text>}
+      {error && <Text><StatusIcon status="error" /> <Text color={theme.error}>{error}</Text></Text>}
+    </Box>
+  )
+}
+
+// --- Balance ---
+
+export function Balance() {
+  const { exit } = useApp()
+  const [data, setData] = useState<any>(null)
+
+  useEffect(() => {
+    api<any>('/api/auth/me').then(setData).finally(() => setTimeout(() => exit(), 100))
+  }, [])
+
+  if (!data) return <Text dimColor>Loading...</Text>
+  return (
+    <Box paddingX={1}>
+      <Text bold>{data.username}</Text>
+      <Text>: </Text>
+      <Text color={theme.success} bold>{data.balance.toLocaleString()} OS</Text>
+    </Box>
+  )
+}
+
+// --- History ---
+
+export function History({ limit = 20 }: { limit?: number }) {
+  const { exit } = useApp()
+  const [txns, setTxns] = useState<any[]>([])
+
+  useEffect(() => {
+    api<any[]>(`/api/transactions?limit=${limit}`).then(setTxns).finally(() => setTimeout(() => exit(), 100))
+  }, [])
+
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      <Header title="Transaction History" />
+      {txns.map((tx, i) => {
+        const sign = tx.amount > 0 ? '+' : ''
+        const color = tx.amount > 0 ? theme.success : theme.error
+        return (
+          <Box key={i} gap={1}>
+            <Text color={color}>{(sign + tx.amount).padStart(8)} OS</Text>
+            <Text dimColor>{tx.type.padEnd(18)}</Text>
+            <Text dimColor>{tx.description || ''}</Text>
+          </Box>
+        )
+      })}
+    </Box>
+  )
+}
+
+// --- Stats ---
+
+export function Stats() {
+  const { exit } = useApp()
+  const [user, setUser] = useState<any>(null)
+  const [txns, setTxns] = useState<any[]>([])
+
+  useEffect(() => {
+    Promise.all([
+      api<any>('/api/auth/me'),
+      api<any[]>('/api/transactions?limit=1000'),
+    ]).then(([u, t]) => { setUser(u); setTxns(t) }).finally(() => setTimeout(() => exit(), 100))
+  }, [])
+
+  if (!user) return <Text dimColor>Loading...</Text>
+
+  const earned = txns.filter(t => t.amount > 0 && t.type !== 'admin_grant').reduce((s, t) => s + t.amount, 0)
+  const burned = txns.filter(t => t.amount < 0).reduce((s, t) => s + Math.abs(t.amount), 0)
+  const improvements = txns.filter(t => ['improvement_reward', 'pool_reward', 'mint_reward'].includes(t.type)).length
+
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      <Header title={user.username} subtitle="Mining Stats" />
+      <Text>Balance:      <Text color={theme.success} bold>{user.balance.toLocaleString()} OS</Text></Text>
+      <Text>Total earned: <Text color={theme.success}>{earned.toLocaleString()} OS</Text></Text>
+      <Text>Total burned: <Text color={theme.burned}>{burned.toLocaleString()} OS</Text></Text>
+      <Text>Improvements: <Text>{improvements}</Text></Text>
+    </Box>
+  )
+}

package/src/commands/mine.tsx

@@ -0,0 +1,229 @@
+import React, { useState, useEffect, useCallback } from 'react'
+import { Box, Text, useApp } from 'ink'
+import { Spinner } from '../components/Spinner.js'
+import { RoundResult } from '../components/RoundResult.js'
+import { Header } from '../components/Header.js'
+import { theme } from '../theme.js'
+import { api } from '../api.js'
+import { buildPrompt, callLLM } from '../llm.js'
+import { loadSession, saveSession, deleteSession } from '../session.js'
+
+interface MineProps {
+  taskId: string
+  model: string
+  maxRounds: number
+  apiBase?: string
+}
+
+interface RoundLog {
+  round: number
+  score: number | null
+  improved: boolean
+  earned: number
+  tokens: number
+  error?: string | null
+  isCompletion?: boolean
+}
+
+type MiningState = 'loading' | 'calling_llm' | 'submitting' | 'done'
+
+export function Mine({ taskId, model, maxRounds, apiBase }: MineProps) {
+  const { exit } = useApp()
+  const [state, setState] = useState<MiningState>('loading')
+  const [task, setTask] = useState<any>(null)
+  const [rounds, setRounds] = useState<RoundLog[]>([])
+  const [roundNum, setRoundNum] = useState(0)
+  const [bestScore, setBestScore] = useState<number | null>(null)
+  const [bestAnswer, setBestAnswer] = useState<string | null>(null)
+  const [platformBest, setPlatformBest] = useState<number | null>(null)
+  const [totalEarned, setTotalEarned] = useState(0)
+  const [totalMinted, setTotalMinted] = useState(0)
+  const [totalTokens, setTotalTokens] = useState(0)
+  const [totalCost, setTotalCost] = useState(0)
+  const [elapsed, setElapsed] = useState(0)
+  const [error, setError] = useState<string | null>(null)
+  const [resumed, setResumed] = useState(false)
+
+  // Timer for elapsed
+  useEffect(() => {
+    if (state !== 'calling_llm' && state !== 'submitting') return
+    const t = setInterval(() => setElapsed(e => e + 100), 100)
+    return () => clearInterval(t)
+  }, [state])
+
+  // Main mining loop
+  const mineLoop = useCallback(async () => {
+    try {
+      // Load task
+      const taskData = await api<any>(`/api/tasks/${taskId}`)
+      setTask(taskData)
+      const bestInfo = await api<any>(`/api/tasks/${taskId}/submissions/best`)
+      setPlatformBest(bestInfo.score)
+
+      // Restore session
+      let myBestAnswer: string | null = null
+      let myBestScore: number | null = null
+      let startRound = 0
+      let earned = 0
+      let minted = 0
+      let tokens = 0
+      let cost = 0
+      const session = loadSession(taskId)
+      if (session) {
+        myBestAnswer = session.my_best_answer
+        myBestScore = session.my_best_score
+        startRound = session.round_num
+        earned = session.total_earned
+        minted = session.total_minted
+        tokens = session.total_tokens
+        cost = session.total_cost
+        setResumed(true)
+        setBestScore(myBestScore)
+        setBestAnswer(myBestAnswer)
+        setTotalEarned(earned)
+        setTotalMinted(minted)
+        setTotalTokens(tokens)
+        setTotalCost(cost)
+      }
+
+      let currentRound = startRound
+      while (true) {
+        currentRound++
+        if (maxRounds > 0 && currentRound > maxRounds + startRound) break
+
+        setRoundNum(currentRound)
+        setState('calling_llm')
+        setElapsed(0)
+
+        // Build prompt & call LLM
+        const prompt = buildPrompt(taskData, myBestAnswer, myBestScore, bestInfo.score)
+        let result: Awaited<ReturnType<typeof callLLM>>
+        try {
+          result = await callLLM(prompt, model, apiBase)
+        } catch (e: any) {
+          setRounds(r => [...r, { round: currentRound, score: null, improved: false, earned: 0, tokens: 0, error: e.message }])
+          await new Promise(r => setTimeout(r, 2000))
+          continue
+        }
+
+        tokens += result.usage.total_tokens
+        cost += result.usage.cost
+        setTotalTokens(tokens)
+        setTotalCost(cost)
+
+        // Submit
+        setState('submitting')
+        const sub = await api<any>(`/api/tasks/${taskId}/submissions`, {
+          body: { answer: result.answer, thinking: result.thinking, llm_model_used: model },
+        })
+
+        const roundEarned = sub.reward_earned || 0
+        earned += roundEarned
+        minted += sub.reward_minted || 0
+        setTotalEarned(earned)
+        setTotalMinted(minted)
+
+        const roundLog: RoundLog = {
+          round: currentRound,
+          score: sub.score,
+          improved: sub.is_improvement || false,
+          earned: roundEarned,
+          tokens: result.usage.total_tokens,
+          error: sub.eval_error,
+          isCompletion: sub.is_completion,
+        }
+        setRounds(r => [...r, roundLog])
+
+        if (sub.is_improvement) {
+          myBestAnswer = result.answer
+          myBestScore = sub.score
+          setBestScore(sub.score)
+          setBestAnswer(result.answer)
+        }
+
+        // Save session
+        saveSession(taskId, {
+          my_best_answer: myBestAnswer,
+          my_best_score: myBestScore,
+          round_num: currentRound,
+          total_earned: earned,
+          total_minted: minted,
+          total_tokens: tokens,
+          total_cost: cost,
+          model,
+        })
+
+        if (sub.is_completion) {
+          deleteSession(taskId)
+          break
+        }
+
+        // Check task status
+        const taskStatus = await api<any>(`/api/tasks/${taskId}`)
+        if (!['open', 'completed'].includes(taskStatus.status)) break
+      }
+    } catch (e: any) {
+      setError(e.message)
+    }
+    setState('done')
+  }, [taskId, model, maxRounds, apiBase])
+
+  useEffect(() => { mineLoop() }, [mineLoop])
+
+  // Exit when done
+  useEffect(() => {
+    if (state === 'done') {
+      const timer = setTimeout(() => exit(), 100)
+      return () => clearTimeout(timer)
+    }
+  }, [state, exit])
+
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      <Header
+        title={task ? `Mining: ${task.title}` : 'Loading...'}
+        subtitle={`Model: ${model}`}
+      />
+
+      {task && (
+        <Box marginBottom={1} gap={2}>
+          <Text dimColor>Threshold: <Text color={theme.text}>{task.completion_threshold}</Text></Text>
+          <Text dimColor>Pool: <Text color={theme.success}>{task.pool_balance} OS</Text></Text>
+          {bestScore !== null && <Text dimColor>Best: <Text color={theme.text}>{bestScore.toFixed(4)}</Text></Text>}
+        </Box>
+      )}
+
+      {resumed && <Text color={theme.info}>Session restored from round {roundNum - rounds.length}</Text>}
+
+      {/* Round history */}
+      {rounds.map((r, i) => (
+        <RoundResult key={i} {...r} />
+      ))}
+
+      {/* Active spinner */}
+      {(state === 'calling_llm' || state === 'submitting') && (
+        <Box marginTop={rounds.length > 0 ? 1 : 0}>
+          <Spinner
+            label={state === 'calling_llm' ? `Round ${roundNum}: calling ${model}` : `Round ${roundNum}: submitting`}
+            elapsed={elapsed}
+            stalled={elapsed > 10000}
+          />
+        </Box>
+      )}
+
+      {/* Summary */}
+      {state === 'done' && (
+        <Box flexDirection="column" marginTop={1} borderStyle="single" borderColor={theme.dim} paddingX={1}>
+          <Text bold color={theme.brand}>Summary</Text>
+          <Text>Best score:   <Text color={theme.text}>{bestScore?.toFixed(6) ?? 'N/A'}</Text></Text>
+          <Text>Total earned: <Text color={theme.success}>{totalEarned.toLocaleString()} OS</Text></Text>
+          <Text>Minted:       <Text color={theme.minted}>{totalMinted.toLocaleString()} OS</Text></Text>
+          <Text>Tokens used:  <Text dimColor>{totalTokens.toLocaleString()}</Text></Text>
+          {totalCost > 0 && <Text>API cost:     <Text color={theme.error}>${totalCost.toFixed(4)}</Text></Text>}
+        </Box>
+      )}
+
+      {error && <Text color={theme.error}>Error: {error}</Text>}
+    </Box>
+  )
+}

package/src/commands/tasks.tsx

@@ -0,0 +1,142 @@
+import React, { useState, useEffect } from 'react'
+import { Box, Text, useApp } from 'ink'
+import { Header } from '../components/Header.js'
+import { Table } from '../components/Table.js'
+import { theme } from '../theme.js'
+import { api } from '../api.js'
+
+// --- Tasks List ---
+
+export function TasksList({ status = 'open' }: { status?: string }) {
+  const { exit } = useApp()
+  const [tasks, setTasks] = useState<any[]>([])
+
+  useEffect(() => {
+    api<any[]>(`/api/tasks?task_status=${status}`, { auth: false })
+      .then(setTasks)
+      .finally(() => setTimeout(() => exit(), 100))
+  }, [])
+
+  const rows = tasks.map(t => ({
+    id: String(t.id).slice(0, 8),
+    title: t.title.length > 30 ? t.title.slice(0, 27) + '...' : t.title,
+    eval: t.eval_type,
+    best: t.best_score !== null ? t.best_score.toFixed(4) : '-',
+    pool: String(t.pool_balance),
+    burn: String(t.task_burn),
+  }))
+
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      <Table
+        title="Open Tasks"
+        columns={[
+          { key: 'id', label: 'ID', width: 10 },
+          { key: 'title', label: 'Title', width: 32 },
+          { key: 'eval', label: 'Eval', width: 14 },
+          { key: 'best', label: 'Best', width: 12, align: 'right' },
+          { key: 'burn', label: 'Burn', width: 8, align: 'right', color: theme.burned },
+          { key: 'pool', label: 'Pool', width: 8, align: 'right', color: theme.success },
+        ]}
+        rows={rows}
+      />
+    </Box>
+  )
+}
+
+// --- Task View ---
+
+export function TaskView({ taskId }: { taskId: string }) {
+  const { exit } = useApp()
+  const [task, setTask] = useState<any>(null)
+
+  useEffect(() => {
+    api<any>(`/api/tasks/${taskId}`, { auth: false })
+      .then(setTask)
+      .finally(() => setTimeout(() => exit(), 100))
+  }, [])
+
+  if (!task) return <Text dimColor>Loading...</Text>
+
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      <Header title={task.title} />
+      <Text dimColor>ID:        <Text color={theme.text}>{task.id}</Text></Text>
+      <Text dimColor>Eval:      <Text color={theme.text}>{task.eval_type} ({task.direction})</Text></Text>
+      <Text dimColor>Status:    <Text color={theme.text}>{task.status}</Text></Text>
+      <Text dimColor>Threshold: <Text color={theme.text}>{task.completion_threshold}</Text></Text>
+      <Text dimColor>Best:      <Text color={theme.text}>{task.best_score ?? '-'}</Text></Text>
+      <Text dimColor>Baseline:  <Text color={theme.text}>{task.baseline_score ?? '-'}</Text></Text>
+      <Text dimColor>Burned:    <Text color={theme.burned}>{task.task_burn} OS</Text></Text>
+      <Text dimColor>Pool:      <Text color={theme.success}>{task.pool_balance} OS</Text></Text>
+      <Box marginTop={1}>
+        <Text dimColor>{task.description}</Text>
+      </Box>
+    </Box>
+  )
+}
+
+// --- Leaderboard ---
+
+export function Leaderboard({ taskId }: { taskId: string }) {
+  const { exit } = useApp()
+  const [subs, setSubs] = useState<any[]>([])
+
+  useEffect(() => {
+    api<any[]>(`/api/tasks/${taskId}/leaderboard`, { auth: false })
+      .then(setSubs)
+      .finally(() => setTimeout(() => exit(), 100))
+  }, [])
+
+  const rows = subs.map((s, i) => ({
+    rank: String(i + 1),
+    score: s.score !== null ? s.score.toFixed(6) : '-',
+    reward: String(s.reward_earned || 0),
+    model: s.llm_model_used || '-',
+    time: s.created_at?.slice(0, 19) || '-',
+  }))
+
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      <Table
+        title="Leaderboard"
+        columns={[
+          { key: 'rank', label: '#', width: 4 },
+          { key: 'score', label: 'Score', width: 14, align: 'right' },
+          { key: 'reward', label: 'Reward', width: 10, align: 'right', color: theme.success },
+          { key: 'model', label: 'Model', width: 28 },
+          { key: 'time', label: 'Time', width: 20 },
+        ]}
+        rows={rows}
+      />
+    </Box>
+  )
+}
+
+// --- Mint ---
+
+export function Mint() {
+  const { exit } = useApp()
+  const [data, setData] = useState<any>(null)
+
+  useEffect(() => {
+    api<any>('/api/mint', { auth: false })
+      .then(setData)
+      .finally(() => setTimeout(() => exit(), 100))
+  }, [])
+
+  if (!data) return <Text dimColor>Loading...</Text>
+
+  const pct = (data.total_minted / data.total_supply * 100).toFixed(4)
+
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      <Header title="OS Mint State" />
+      <Text>Total supply:     <Text bold>{data.total_supply.toLocaleString()} OS</Text></Text>
+      <Text>Total minted:     <Text color={theme.minted}>{data.total_minted.toLocaleString()} OS</Text> <Text dimColor>({pct}%)</Text></Text>
+      <Text>Base reward:      <Text>{data.base_reward} OS</Text></Text>
+      <Text>Match multiplier: <Text>{data.match_multiplier}</Text></Text>
+      <Text>Halvings:         <Text>{data.halving_count}</Text></Text>
+    </Box>
+  )
+}

package/src/components/Header.tsx

@@ -0,0 +1,12 @@
+import React from 'react'
+import { Box, Text } from 'ink'
+import { theme } from '../theme.js'
+
+export function Header({ title, subtitle }: { title: string; subtitle?: string }) {
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Text bold color={theme.brand}>{'◆'} {title}</Text>
+      {subtitle && <Text color={theme.dim}>  {subtitle}</Text>}
+    </Box>
+  )
+}

package/src/components/RoundResult.tsx

@@ -0,0 +1,44 @@
+import React from 'react'
+import { Box, Text } from 'ink'
+import { StatusIcon } from './StatusIcon.js'
+import { theme } from '../theme.js'
+
+interface RoundResultProps {
+  round: number
+  score: number | null
+  improved: boolean
+  earned: number
+  tokens: number
+  error?: string | null
+  isCompletion?: boolean
+}
+
+export function RoundResult({ round, score, improved, earned, tokens, error, isCompletion }: RoundResultProps) {
+  const scoreStr = score !== null ? score.toFixed(6) : 'ERROR'
+
+  let status: 'success' | 'error' | 'dim' = 'dim'
+  let label = 'no change'
+  if (error) {
+    status = 'error'
+    label = 'error'
+  } else if (isCompletion) {
+    status = 'success'
+    label = 'COMPLETE'
+  } else if (improved) {
+    status = 'success'
+    label = 'improved'
+  }
+
+  return (
+    <Box gap={1}>
+      <Text dimColor>R{String(round).padStart(2)}</Text>
+      <Text color={error ? theme.error : theme.text}>{scoreStr.padStart(12)}</Text>
+      <StatusIcon status={status} />
+      <Text color={status === 'success' ? theme.success : status === 'error' ? theme.error : theme.dim}>
+        {label.padEnd(10)}
+      </Text>
+      {earned > 0 && <Text color={theme.success}>+{earned} OS</Text>}
+      <Text dimColor>{tokens.toLocaleString()} tok</Text>
+    </Box>
+  )
+}

package/src/components/Spinner.tsx

@@ -0,0 +1,44 @@
+import React, { useState, useEffect } from 'react'
+import { Text } from 'ink'
+import { theme } from '../theme.js'
+
+const FRAMES = ['▖', '▗', '▝', '▘']
+const VERBS = [
+  'Thinking', 'Computing', 'Analyzing', 'Reasoning', 'Processing',
+  'Optimizing', 'Evaluating', 'Iterating', 'Refining', 'Exploring',
+]
+
+interface SpinnerProps {
+  label?: string
+  elapsed?: number
+  stalled?: boolean
+}
+
+export function Spinner({ label, elapsed, stalled }: SpinnerProps) {
+  const [frame, setFrame] = useState(0)
+  const [verb, setVerb] = useState(VERBS[0])
+
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame(f => (f + 1) % FRAMES.length)
+    }, 80)
+    return () => clearInterval(timer)
+  }, [])
+
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setVerb(VERBS[Math.floor(Math.random() * VERBS.length)])
+    }, 3000)
+    return () => clearInterval(timer)
+  }, [])
+
+  const color = stalled ? theme.error : theme.brand
+  const elapsedStr = elapsed ? ` (${(elapsed / 1000).toFixed(1)}s)` : ''
+
+  return (
+    <Text>
+      <Text color={color}>{FRAMES[frame]}</Text>
+      <Text color={theme.dim}> {label || verb}...{elapsedStr}</Text>
+    </Text>
+  )
+}

package/src/components/StatusIcon.tsx

@@ -0,0 +1,19 @@
+import React from 'react'
+import { Text } from 'ink'
+import { theme } from '../theme.js'
+
+type Status = 'success' | 'error' | 'warning' | 'info' | 'pending' | 'dim'
+
+const ICONS: Record<Status, { char: string; color: string }> = {
+  success: { char: '✓', color: theme.success },
+  error: { char: '✗', color: theme.error },
+  warning: { char: '⚠', color: theme.warning },
+  info: { char: '●', color: theme.info },
+  pending: { char: '○', color: theme.dim },
+  dim: { char: '·', color: theme.dim },
+}
+
+export function StatusIcon({ status }: { status: Status }) {
+  const { char, color } = ICONS[status]
+  return <Text color={color}>{char}</Text>
+}

package/src/components/Table.tsx

@@ -0,0 +1,58 @@
+import React from 'react'
+import { Box, Text } from 'ink'
+import { theme } from '../theme.js'
+
+interface Column {
+  key: string
+  label: string
+  width?: number
+  align?: 'left' | 'right'
+  color?: string
+}
+
+interface TableProps {
+  columns: Column[]
+  rows: Record<string, string | number | null | undefined>[]
+  title?: string
+}
+
+export function Table({ columns, rows, title }: TableProps) {
+  return (
+    <Box flexDirection="column">
+      {title && (
+        <Box marginBottom={1}>
+          <Text bold color={theme.brand}>{title}</Text>
+        </Box>
+      )}
+      {/* Header */}
+      <Box>
+        {columns.map((col, i) => (
+          <Box key={col.key} width={col.width || 14}>
+            <Text bold dimColor>{col.label}</Text>
+          </Box>
+        ))}
+      </Box>
+      {/* Separator */}
+      <Box>
+        {columns.map(col => (
+          <Box key={col.key} width={col.width || 14}>
+            <Text dimColor>{'─'.repeat((col.width || 14) - 2)}</Text>
+          </Box>
+        ))}
+      </Box>
+      {/* Rows */}
+      {rows.map((row, i) => (
+        <Box key={i}>
+          {columns.map(col => {
+            const val = String(row[col.key] ?? '-')
+            return (
+              <Box key={col.key} width={col.width || 14} justifyContent={col.align === 'right' ? 'flex-end' : 'flex-start'}>
+                <Text color={col.color}>{val}</Text>
+              </Box>
+            )
+          })}
+        </Box>
+      ))}
+    </Box>
+  )
+}

package/src/config.ts

@@ -0,0 +1,46 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+
+const CONFIG_DIR = join(homedir(), '.oscli')
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json')
+
+export interface Config {
+  server_url: string
+  auth_token: string
+  default_model: string
+  api_base: string
+}
+
+const DEFAULT_CONFIG: Config = {
+  server_url: 'http://localhost:8000',
+  auth_token: '',
+  default_model: 'anthropic/claude-opus-4-6',
+  api_base: '',
+}
+
+export function loadConfig(): Config {
+  if (!existsSync(CONFIG_FILE)) return { ...DEFAULT_CONFIG }
+  try {
+    const data = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'))
+    return { ...DEFAULT_CONFIG, ...data }
+  } catch {
+    return { ...DEFAULT_CONFIG }
+  }
+}
+
+export function saveConfig(config: Partial<Config>): void {
+  mkdirSync(CONFIG_DIR, { recursive: true })
+  const current = loadConfig()
+  const merged = { ...current, ...config }
+  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2) + '\n')
+}
+
+export function getToken(): string {
+  const config = loadConfig()
+  if (!config.auth_token) {
+    console.error('Not logged in. Run: os-cli login')
+    process.exit(1)
+  }
+  return config.auth_token
+}

package/src/index.tsx

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import React from 'react'
+import { render } from 'ink'
+import { loadConfig } from './config.js'
+
+const args = process.argv.slice(2)
+const command = args[0]
+const subcommand = args[1]
+
+function getFlag(name: string): string | undefined {
+  const idx = args.indexOf(`--${name}`)
+  if (idx === -1) return undefined
+  return args[idx + 1]
+}
+
+function hasFlag(name: string): boolean {
+  return args.includes(`--${name}`)
+}
+
+async function main() {
+  const config = loadConfig()
+
+  switch (command) {
+    case 'register': {
+      const { Register } = await import('./commands/auth.js')
+      render(<Register />)
+      break
+    }
+    case 'login': {
+      const { Login } = await import('./commands/auth.js')
+      render(<Login />)
+      break
+    }
+    case 'balance': {
+      const { Balance } = await import('./commands/auth.js')
+      render(<Balance />)
+      break
+    }
+    case 'history': {
+      const { History } = await import('./commands/auth.js')
+      const limit = parseInt(getFlag('limit') || '20')
+      render(<History limit={limit} />)
+      break
+    }
+    case 'stats': {
+      const { Stats } = await import('./commands/auth.js')
+      render(<Stats />)
+      break
+    }
+    case 'tasks': {
+      if (subcommand === 'list') {
+        const { TasksList } = await import('./commands/tasks.js')
+        const status = getFlag('status') || 'open'
+        render(<TasksList status={status} />)
+      } else if (subcommand === 'view' && args[2]) {
+        const { TaskView } = await import('./commands/tasks.js')
+        render(<TaskView taskId={args[2]} />)
+      } else {
+        console.log('Usage: os-cli tasks <list|view <id>>')
+      }
+      break
+    }
+    case 'mine': {
+      const taskId = args[1]
+      if (!taskId) {
+        console.log('Usage: os-cli mine <task_id> [--model name] [--max-rounds n] [--api-base url]')
+        break
+      }
+      const { Mine } = await import('./commands/mine.js')
+      const model = getFlag('model') || config.default_model
+      const maxRounds = parseInt(getFlag('max-rounds') || '0')
+      const apiBase = getFlag('api-base') || config.api_base || undefined
+      render(<Mine taskId={taskId} model={model} maxRounds={maxRounds} apiBase={apiBase} />)
+      break
+    }
+    case 'leaderboard': {
+      if (!args[1]) { console.log('Usage: os-cli leaderboard <task_id>'); break }
+      const { Leaderboard } = await import('./commands/tasks.js')
+      render(<Leaderboard taskId={args[1]} />)
+      break
+    }
+    case 'mint': {
+      const { Mint } = await import('./commands/tasks.js')
+      render(<Mint />)
+      break
+    }
+    default:
+      console.log(`
+  ◆ OpenScienceNet CLI
+
+  Commands:
+    register              Create a new account
+    login                 Log in and save token
+    balance               Show OS coin balance
+    history               Transaction history
+    stats                 Mining statistics
+
+    tasks list            Browse open tasks
+    tasks view <id>       Task details
+    mine <task_id>        Start mining a task
+      --model <name>      LLM model (default: ${config.default_model})
+      --max-rounds <n>    Stop after n rounds
+      --api-base <url>    Custom API base (Ollama/vLLM)
+
+    leaderboard <id>      Top scores for a task
+    mint                  Global mint state
+`)
+  }
+}
+
+main().catch(e => {
+  console.error(e.message)
+  process.exit(1)
+})

package/src/llm.ts

@@ -0,0 +1,108 @@
+import Anthropic from '@anthropic-ai/sdk'
+import OpenAI from 'openai'
+
+export interface LLMResult {
+  thinking: string
+  answer: string
+  usage: { prompt_tokens: number; completion_tokens: number; total_tokens: number; cost: number }
+}
+
+export function buildPrompt(
+  task: { title: string; description: string; eval_type: string; direction: string; completion_threshold: number },
+  myBestAnswer: string | null,
+  myBestScore: number | null,
+  platformBestScore: number | null,
+): string {
+  const dirText = task.direction === 'maximize' ? 'higher is better' : 'lower is better'
+  const isCode = task.eval_type === 'code_output'
+
+  let prompt = `# Task: ${task.title}\n\n## Description\n${task.description}\n\n`
+  prompt += `## Evaluation\nScored using: ${task.eval_type}\nDirection: ${task.direction} (${dirText})\n`
+  prompt += `Completion threshold: ${task.completion_threshold}\n`
+  prompt += `Platform best: ${platformBestScore ?? 'None (no submissions yet)'}\n`
+
+  if (myBestAnswer !== null && myBestScore !== null) {
+    prompt += `\n## Your Previous Best\nScore: ${myBestScore}\nAnswer:\n${myBestAnswer}\n\nAnalyze why it scored ${myBestScore}. Improve it.\n`
+  } else {
+    prompt += '\nThis is your first attempt. Think carefully.\n'
+  }
+
+  if (isCode) {
+    prompt += `\n## CRITICAL RULES\n1. Do NOT hardcode test data. Input comes via function parameters.\n2. Functions must work with ANY input.\n\n`
+  }
+
+  prompt += `## OUTPUT FORMAT\n<thinking>your reasoning</thinking>\n<answer>${isCode ? 'ONLY executable code, NO prose, NO markdown fences' : 'your answer'}</answer>\n`
+  return prompt
+}
+
+function parseResponse(text: string): { thinking: string; answer: string } {
+  const thinkMatch = text.match(/<thinking>([\s\S]*?)<\/thinking>/)
+  const answerMatch = text.match(/<answer>([\s\S]*?)<\/answer>/)
+
+  let thinking = thinkMatch?.[1]?.trim() || text
+  let answer = answerMatch?.[1]?.trim() || text.trim()
+
+  // Strip markdown fences
+  answer = answer.replace(/```[\w]*\s*\n?/g, '').replace(/\n?\s*```/g, '').trim()
+
+  return { thinking, answer }
+}
+
+// Cost estimates per 1M tokens (input/output)
+const COST_TABLE: Record<string, [number, number]> = {
+  'claude-opus-4-6': [15, 75],
+  'claude-sonnet-4-20250514': [3, 15],
+  'gpt-4o': [2.5, 10],
+  'gpt-4o-mini': [0.15, 0.6],
+  'deepseek-chat': [0.14, 0.28],
+}
+
+function estimateCost(model: string, promptTok: number, completionTok: number): number {
+  const shortModel = model.replace(/^(anthropic|openai|deepseek)\//, '')
+  const costs = COST_TABLE[shortModel] || [5, 15] // default
+  return (promptTok * costs[0] + completionTok * costs[1]) / 1_000_000
+}
+
+export async function callLLM(prompt: string, model: string, apiBase?: string): Promise<LLMResult> {
+  const provider = model.split('/')[0]
+  const modelName = model.split('/').slice(1).join('/')
+
+  let text = ''
+  let promptTokens = 0
+  let completionTokens = 0
+
+  if (provider === 'anthropic') {
+    const client = new Anthropic()
+    const resp = await client.messages.create({
+      model: modelName,
+      max_tokens: 4096,
+      messages: [{ role: 'user', content: prompt }],
+    })
+    text = resp.content.filter(b => b.type === 'text').map(b => b.text).join('')
+    promptTokens = resp.usage.input_tokens
+    completionTokens = resp.usage.output_tokens
+  } else {
+    // OpenAI-compatible (openai, ollama, deepseek, vllm)
+    const client = new OpenAI({
+      apiKey: process.env.OPENAI_API_KEY || process.env.DEEPSEEK_API_KEY || 'ollama',
+      baseURL: apiBase || (provider === 'deepseek' ? 'https://api.deepseek.com' : undefined),
+    })
+    const resp = await client.chat.completions.create({
+      model: modelName,
+      max_tokens: 4096,
+      messages: [{ role: 'user', content: prompt }],
+    })
+    text = resp.choices[0]?.message?.content || ''
+    promptTokens = resp.usage?.prompt_tokens || 0
+    completionTokens = resp.usage?.completion_tokens || 0
+  }
+
+  const { thinking, answer } = parseResponse(text)
+  const cost = estimateCost(model, promptTokens, completionTokens)
+
+  return {
+    thinking,
+    answer,
+    usage: { prompt_tokens: promptTokens, completion_tokens: completionTokens, total_tokens: promptTokens + completionTokens, cost },
+  }
+}

package/src/session.ts

@@ -0,0 +1,36 @@
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync, existsSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+
+const SESSIONS_DIR = join(homedir(), '.oscli', 'sessions')
+
+export interface MiningSession {
+  my_best_answer: string | null
+  my_best_score: number | null
+  round_num: number
+  total_earned: number
+  total_minted: number
+  total_tokens: number
+  total_cost: number
+  model: string
+}
+
+export function loadSession(taskId: string): MiningSession | null {
+  const path = join(SESSIONS_DIR, `${taskId}.json`)
+  if (!existsSync(path)) return null
+  try {
+    return JSON.parse(readFileSync(path, 'utf-8'))
+  } catch {
+    return null
+  }
+}
+
+export function saveSession(taskId: string, data: MiningSession): void {
+  mkdirSync(SESSIONS_DIR, { recursive: true })
+  writeFileSync(join(SESSIONS_DIR, `${taskId}.json`), JSON.stringify(data, null, 2))
+}
+
+export function deleteSession(taskId: string): void {
+  const path = join(SESSIONS_DIR, `${taskId}.json`)
+  if (existsSync(path)) unlinkSync(path)
+}

package/src/theme.ts

@@ -0,0 +1,25 @@
+export const theme = {
+  // Brand
+  brand: '#6C5CE7',       // OS purple
+  brandDim: '#A29BFE',
+
+  // Semantic
+  success: '#00B894',
+  error: '#D63031',
+  warning: '#FDCB6E',
+  info: '#0984E3',
+
+  // Text
+  text: '#DFE6E9',
+  dim: '#636E72',
+  muted: '#B2BEC3',
+
+  // Mining
+  improved: '#00B894',
+  noChange: '#636E72',
+  minted: '#00CEC9',
+  burned: '#D63031',
+
+  // Spinner frames
+  spinnerFrames: ['▖', '▗', '▝', '▘'] as const,
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.tsx'],
+  format: ['esm'],
+  target: 'node18',
+  outDir: 'dist',
+  clean: true,
+  sourcemap: true,
+  external: ['react', 'ink'],
+})