@demath-ai/cli 0.1.0

package/dist/index.cjs

@@ -0,0 +1,823 @@
+'use strict';
+
+// src/constants.ts
+var CLI_VERSION = "0.1.0";
+var USER_AGENT = `demath-cli-npm/${CLI_VERSION} (+https://github.com/demath-ai/proj-dmv0/tree/main/tools/demath-cli-npm)`;
+var DEFAULT_API_URL = process.env.DEMATH_API_URL?.trim() || "https://api.demath.org";
+var APPROVED_MODELS = [
+  "anthropic/claude-opus-4-7",
+  "openai/gpt-5.5",
+  "google/gemini-3-deep-think"
+];
+var POLL_INTERVAL_MS = 3e3;
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "proof_complete",
+  "counterexample",
+  "breakthrough",
+  "substantial_progress",
+  "partial_progress",
+  "no_progress",
+  "stopped",
+  "error"
+]);
+var SUCCESS_STATUSES = /* @__PURE__ */ new Set([
+  "proof_complete",
+  "counterexample",
+  "breakthrough"
+]);
+
+// src/errors.ts
+var CliError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+};
+
+// src/http.ts
+async function request(opts) {
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  const ctrl = new AbortController();
+  const timeoutId = setTimeout(() => ctrl.abort(new Error("request timed out")), timeoutMs);
+  const onParentAbort = () => ctrl.abort(opts.signal.reason);
+  if (opts.signal) {
+    if (opts.signal.aborted) ctrl.abort(opts.signal.reason);
+    else opts.signal.addEventListener("abort", onParentAbort, { once: true });
+  }
+  const headers = {
+    Accept: "application/json",
+    "User-Agent": USER_AGENT
+  };
+  let bodyInit;
+  if (opts.body !== void 0) {
+    bodyInit = JSON.stringify(opts.body);
+    headers["Content-Type"] = "application/json";
+  }
+  let resp;
+  try {
+    resp = await fetch(opts.url, {
+      method: opts.method,
+      headers,
+      body: bodyInit,
+      signal: ctrl.signal
+    });
+  } catch (err) {
+    clearTimeout(timeoutId);
+    if (opts.signal) opts.signal.removeEventListener("abort", onParentAbort);
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new CliError(`network error reaching ${opts.url}: ${msg}`, 3);
+  } finally {
+    clearTimeout(timeoutId);
+    if (opts.signal) opts.signal.removeEventListener("abort", onParentAbort);
+  }
+  const rawText = await resp.text();
+  if (!resp.ok) {
+    let detail = `HTTP ${resp.status}`;
+    if (rawText) {
+      try {
+        const parsed = JSON.parse(rawText);
+        const d = parsed.detail ?? parsed.error;
+        if (typeof d === "string") detail = d;
+        else if (d !== void 0) detail = JSON.stringify(d);
+      } catch {
+        detail = rawText.slice(0, 400);
+      }
+    }
+    throw new CliError(`backend error: ${detail}`, 2);
+  }
+  if (!rawText) return {};
+  try {
+    return JSON.parse(rawText);
+  } catch {
+    throw new CliError(`backend returned non-JSON body: ${rawText.slice(0, 200)}`, 2);
+  }
+}
+
+// src/api.ts
+var DemathClient = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  cfg;
+  listProblems() {
+    return request({
+      method: "GET",
+      url: `${this.cfg.apiUrl}/problems`,
+      signal: this.cfg.signal
+    });
+  }
+  probe(model, apiKey) {
+    return request({
+      method: "POST",
+      url: `${this.cfg.apiUrl}/providers/probe`,
+      body: { model, api_key: apiKey },
+      signal: this.cfg.signal
+    });
+  }
+  startAttempt(r) {
+    const body = {
+      problem_id: r.problemId,
+      model: r.model,
+      api_key: r.apiKey,
+      miner_address: r.walletAddress
+    };
+    if (r.maxIterations !== void 0) body.max_iterations = r.maxIterations;
+    if (r.maxUsd !== void 0) body.max_usd = r.maxUsd;
+    return request({
+      method: "POST",
+      url: `${this.cfg.apiUrl}/attempts`,
+      body,
+      signal: this.cfg.signal
+    });
+  }
+  getAttempt(attemptId) {
+    return request({
+      method: "GET",
+      url: `${this.cfg.apiUrl}/attempts/${encodeURIComponent(attemptId)}`,
+      signal: this.cfg.signal
+    });
+  }
+  stopAttempt(attemptId) {
+    return request({
+      method: "POST",
+      url: `${this.cfg.apiUrl}/attempts/${encodeURIComponent(attemptId)}/stop`,
+      body: {},
+      // Stops shouldn't get cancelled by the same Ctrl-C that initiated them.
+      signal: void 0
+    });
+  }
+};
+
+// src/output.ts
+function logErr(line = "") {
+  process.stderr.write(line + "\n");
+}
+function printJson(value) {
+  process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+function padRight(s, n) {
+  return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+function truncate(s, n) {
+  if (!s) return "";
+  return s.length <= n ? s : s.slice(0, Math.max(0, n - 1)) + "\u2026";
+}
+
+// src/parser.ts
+function parseArgs(argv) {
+  const positional = [];
+  const flags = /* @__PURE__ */ new Map();
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i];
+    if (a === "--") {
+      positional.push(...argv.slice(i + 1));
+      break;
+    }
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1) {
+        flags.set(a.slice(2, eq), a.slice(eq + 1));
+        i++;
+        continue;
+      }
+      const key = a.slice(2);
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        flags.set(key, next);
+        i += 2;
+      } else {
+        flags.set(key, true);
+        i++;
+      }
+      continue;
+    }
+    if (a.startsWith("-") && a.length > 1) {
+      flags.set(a.slice(1), true);
+      i++;
+      continue;
+    }
+    positional.push(a);
+    i++;
+  }
+  return { positional, flags };
+}
+function getString(flags, key) {
+  const v = flags.get(key);
+  return typeof v === "string" ? v : void 0;
+}
+function requireString(flags, key) {
+  const v = getString(flags, key);
+  if (v === void 0) throw new CliError(`missing required flag --${key}`, 2);
+  return v;
+}
+function getBool(flags, key) {
+  return flags.has(key);
+}
+function getNumber(flags, key) {
+  const v = getString(flags, key);
+  if (v === void 0) return void 0;
+  const n = Number(v);
+  if (!Number.isFinite(n)) throw new CliError(`--${key} must be a number, got: ${v}`, 2);
+  return n;
+}
+var TOP_LEVEL_HELP = `demath ${CLI_VERSION} \u2014 mine $DEMATH from your terminal.
+
+USAGE
+  demath <command> [options]
+
+COMMANDS
+  problems      List active problems
+  probe         Verify your provider API key works (no spend)
+  mine          Start an attempt and stream live progress
+  status        Show the current state of an attempt by id
+  examples      Print copy-pasteable example invocations
+  skill         Print the SKILL.md doc to stdout (for AI agents)
+  --help        Show this help
+  --version     Print CLI version
+
+GLOBAL OPTIONS
+  --api-url <url>  Backend base URL (default: ${DEFAULT_API_URL})
+                   Override with DEMATH_API_URL env var.
+  --json           Machine-readable output on stdout (for AI agents).
+                   Per-command; only some commands stream NDJSON.
+
+APPROVED MODEL SLUGS
+${APPROVED_MODELS.map((m) => `  - ${m}`).join("\n")}
+
+PROVIDER API KEY HANDLING
+  DeMath never stores, persists, or logs your provider API key. The CLI
+  sends it once per attempt to the backend, which forwards it inline to
+  the upstream provider (Anthropic / OpenAI / Google / OpenRouter) and
+  drops it from memory the moment the attempt finishes. No disk write,
+  no log line, no telemetry, no IPFS bundle. Your billing relationship
+  with the upstream provider remains entirely yours.
+
+LOCK-FOR-LIFE
+  Your wallet binds to a single team on its first attempt. The backend
+  rejects team switches with HTTP 409. Use a different wallet to mine
+  a different team. Same rule for web, CLI, and any bot client.
+
+FOR AI AGENTS
+  Run \`demath skill\` to print the short, human-readable skill doc
+  (project intro + mine-in-three-steps + key constraints). The rest is
+  in this --help and the per-command --help; refresh both before every
+  invocation.
+
+See \`demath examples\` for worked invocations.
+See \`demath <command> --help\` for per-command flags.
+`;
+var PROBLEMS_HELP = `demath problems \u2014 list active problems.
+
+USAGE
+  demath problems [--api-url <url>] [--json]
+
+EXAMPLES
+  demath problems
+  demath problems --json | jq '.problems[].id'
+
+EXIT CODES
+  0  success
+  2  backend error
+  3  network error
+`;
+var PROBE_HELP = `demath probe \u2014 verify an API key works for a model (no token spend
+beyond a 1-token chat completion).
+
+USAGE
+  demath probe --model <slug> --key <api-key> [--api-url <url>] [--json]
+
+REQUIRED
+  --model   one of: ${APPROVED_MODELS.join(", ")}
+  --key     provider API key (OpenRouter / Anthropic / OpenAI / Gemini direct)
+            backend auto-detects the provider from the key prefix.
+
+EXAMPLES
+  demath probe --model anthropic/claude-opus-4-7 --key sk-ant-...
+  demath probe --model openai/gpt-5.5 --key sk-or-v1-... --json
+
+EXIT CODES
+  0  key works
+  2  probe failed / invalid model
+  3  network error
+`;
+var MINE_HELP = `demath mine \u2014 start an attempt and stream live progress until terminal.
+
+USAGE
+  demath mine --problem <id> --model <slug> --key <api-key>
+              --wallet <0x...> [--max-iterations N] [--max-usd N]
+              [--api-url <url>] [--json]
+
+REQUIRED
+  --problem         problem id (see \`demath problems\`)
+  --model           one of: ${APPROVED_MODELS.join(", ")}
+  --key             provider API key \u2014 held in memory only, never written to disk
+  --wallet          EVM address that will receive emission claims
+                    (locks to the chosen team on first use)
+
+OPTIONAL
+  --max-iterations  cap on agent loop iterations (default: backend default)
+  --max-usd         cost cap in USD (default: backend default)
+  --json            emit one NDJSON event per iteration on stdout
+
+EXAMPLES
+  demath mine \\
+    --problem irrationality-of-e \\
+    --model   anthropic/claude-opus-4-7 \\
+    --key     sk-ant-... \\
+    --wallet  0xYourEvmAddress \\
+    --max-usd 1.0
+
+  demath mine --problem collatz --model openai/gpt-5.5 \\
+    --key sk-or-v1-... --wallet 0xAbc... --json | tee run.ndjson
+
+EXIT CODES
+  0  attempt reached a success status (proof_complete | counterexample | breakthrough)
+  1  attempt ended without success (stopped | error)
+  2  backend error / invalid model / missing flag
+  3  network error
+  130  interrupted by Ctrl-C (backend stop requested)
+`;
+var STATUS_HELP = `demath status \u2014 show the current state of an attempt by id.
+
+USAGE
+  demath status --attempt <id> [--api-url <url>] [--json]
+
+REQUIRED
+  --attempt   attempt id returned by \`demath mine\` start
+
+EXAMPLES
+  demath status --attempt 65df82b6ea7f4aeeab86f60505571491
+  demath status --attempt <id> --json | jq .status
+
+EXIT CODES
+  0  fetched successfully
+  2  backend error
+  3  network error
+`;
+var EXAMPLES_HELP = `demath examples \u2014 print 5 copy-pasteable example invocations.
+
+USAGE
+  demath examples
+`;
+
+// src/commands/examples.ts
+var EXAMPLES = `DeMath CLI \u2014 worked examples
+
+  1) Look at the active problems (machine-readable):
+
+       demath problems --json
+
+  2) Probe your API key against a model before committing (zero spend):
+
+       demath probe \\
+         --model anthropic/claude-opus-4-7 \\
+         --key   sk-ant-... \\
+         --json
+
+  3) Start a budget-capped attempt on the test problem (a few cents):
+
+       demath mine \\
+         --problem irrationality-of-e \\
+         --model   anthropic/claude-opus-4-7 \\
+         --key     sk-ant-... \\
+         --wallet  0xYourEvmAddress \\
+         --max-usd 1.0
+
+  4) Same flow but routing via OpenRouter (one key, any team):
+
+       demath mine \\
+         --problem collatz \\
+         --model   openai/gpt-5.5 \\
+         --key     sk-or-v1-... \\
+         --wallet  0xYourEvmAddress \\
+         --max-iterations 8 \\
+         --max-usd 5.0 \\
+         --json
+
+  5) Inspect an attempt by id after the fact (e.g. for a background run):
+
+       demath status --attempt <attempt_id> --json
+
+Notes:
+  - Wallet \u2192 team lock-for-life: the first attempt binds your wallet to a
+    team (anthropic / openai / google). Subsequent attempts with a different
+    team return HTTP 409. Use a different wallet to mine a different team.
+  - The CLI never writes your API key to disk. The key is held in memory
+    for the duration of the attempt and only ever sent to api.demath.org.
+  - --json on any command emits machine-readable output on stdout; human
+    progress text goes to stderr so it can't pollute your JSON pipeline.
+`;
+function runExamples() {
+  process.stdout.write(EXAMPLES);
+  return 0;
+}
+
+// src/commands/mine.ts
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) return reject(signal.reason);
+    const t = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(t);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function runMine(args) {
+  if (!APPROVED_MODELS.includes(args.model)) {
+    throw new CliError(
+      `model must be one of: ${APPROVED_MODELS.join(", ")}`,
+      2
+    );
+  }
+  const ctrl = new AbortController();
+  let interrupted = false;
+  const onSig = () => {
+    interrupted = true;
+    ctrl.abort(new Error("SIGINT"));
+  };
+  process.on("SIGINT", onSig);
+  process.on("SIGTERM", onSig);
+  const client = new DemathClient({ apiUrl: args.apiUrl, signal: ctrl.signal });
+  if (!args.json) {
+    logErr(
+      `  starting attempt: problem=${args.problem}  model=${args.model}  wallet=${args.wallet}`
+    );
+    if (args.maxUsd !== void 0) {
+      logErr(`  budget: $${args.maxUsd.toFixed(2)}`);
+    }
+  }
+  const start = await client.startAttempt({
+    problemId: args.problem,
+    model: args.model,
+    apiKey: args.apiKey,
+    walletAddress: args.wallet,
+    maxIterations: args.maxIterations,
+    maxUsd: args.maxUsd
+  });
+  const attemptId = start.attempt_id;
+  if (!attemptId) {
+    throw new CliError("backend did not return attempt_id", 2);
+  }
+  if (args.json) {
+    process.stdout.write(JSON.stringify({ event: "start", attempt_id: attemptId }) + "\n");
+  } else {
+    logErr(`  attempt_id: ${attemptId}`);
+    logErr("  watching live progress (Ctrl+C to stop the attempt)\u2026");
+    logErr();
+  }
+  let lastIterCount = 0;
+  let lastRecord;
+  try {
+    while (true) {
+      try {
+        await sleep(POLL_INTERVAL_MS, ctrl.signal);
+      } catch {
+        break;
+      }
+      const record = await client.getAttempt(attemptId);
+      lastRecord = record;
+      const iters = record.iterations ?? [];
+      const status = record.status ?? "?";
+      const totalCost = record.total_cost ?? 0;
+      for (let i = lastIterCount; i < iters.length; i++) {
+        const it = iters[i];
+        if (args.json) {
+          process.stdout.write(
+            JSON.stringify({ event: "iteration", attempt_id: attemptId, ...it }) + "\n"
+          );
+        } else {
+          printIterLine(it, totalCost);
+        }
+      }
+      lastIterCount = iters.length;
+      if (TERMINAL_STATUSES.has(status)) {
+        if (args.json) {
+          process.stdout.write(
+            JSON.stringify({ event: "final", attempt_id: attemptId, ...record }) + "\n"
+          );
+        } else {
+          logErr();
+          printFinal(record);
+        }
+        process.off("SIGINT", onSig);
+        process.off("SIGTERM", onSig);
+        return SUCCESS_STATUSES.has(status) ? 0 : 1;
+      }
+    }
+  } catch (err) {
+    process.off("SIGINT", onSig);
+    process.off("SIGTERM", onSig);
+    if (!interrupted) throw err;
+  }
+  process.off("SIGINT", onSig);
+  process.off("SIGTERM", onSig);
+  if (!args.json) {
+    logErr();
+    logErr("  Ctrl+C \u2014 stopping the attempt\u2026");
+  }
+  try {
+    await new DemathClient({ apiUrl: args.apiUrl }).stopAttempt(attemptId);
+    if (args.json) {
+      process.stdout.write(JSON.stringify({ event: "stopped", attempt_id: attemptId }) + "\n");
+    } else {
+      logErr("  stopped");
+      if (lastRecord) printFinal(lastRecord);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (args.json) {
+      process.stdout.write(
+        JSON.stringify({ event: "stop_failed", attempt_id: attemptId, error: msg }) + "\n"
+      );
+    } else {
+      logErr(`  warning: stop request failed: ${msg}`);
+    }
+  }
+  return 130;
+}
+function printIterLine(it, totalCost) {
+  const n = (it.iteration ?? 0).toString().padStart(3, " ");
+  const status = padRight(it.status ?? "?", 22);
+  const inT = (it.input_tokens ?? 0).toString().padStart(6, " ");
+  const outT = (it.output_tokens ?? 0).toString().padStart(6, " ");
+  const itCost = (it.usd_cost ?? 0).toFixed(4);
+  const total = totalCost.toFixed(4);
+  const summary = (it.summary ?? it.body ?? "").toString().replace(/\s+/g, " ");
+  const tail = summary ? `  ${truncate(summary, 200)}` : "";
+  logErr(
+    `  iter ${n}  status=${status}  tokens in=${inT} out=${outT}  +$${itCost}  (total $${total})${tail}`
+  );
+}
+function printFinal(record) {
+  const status = (record.status ?? "?").toUpperCase();
+  const cost = record.total_cost ?? 0;
+  const inT = record.total_input_tokens ?? 0;
+  const outT = record.total_output_tokens ?? 0;
+  const iters = (record.iterations ?? []).length;
+  const cid = record.ipfs_cid;
+  logErr(`  \u2554\u2550 ${status} \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+  logErr(`  \u2551  iterations:    ${iters}`);
+  logErr(`  \u2551  tokens in:     ${inT}`);
+  logErr(`  \u2551  tokens out:    ${outT}`);
+  logErr(`  \u2551  total cost:    $${cost.toFixed(4)}`);
+  if (cid) logErr(`  \u2551  IPFS bundle:   https://ipfs.io/ipfs/${cid}`);
+  if (record.error) logErr(`  \u2551  error:         ${truncate(record.error, 200)}`);
+  logErr(`  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+  logErr();
+  if (SUCCESS_STATUSES.has((record.status ?? "").toLowerCase())) {
+    logErr(
+      "  Claim on the web: https://demath.org/claim (after the next epoch settles, 24h cadence on mainnet)"
+    );
+  }
+}
+
+// src/commands/problems.ts
+async function runProblems(args) {
+  const client = new DemathClient({ apiUrl: args.apiUrl });
+  const payload = await client.listProblems();
+  const problems = payload.problems ?? [];
+  if (args.json) {
+    printJson({ problems });
+    return 0;
+  }
+  const idWidth = Math.max(20, ...problems.map((p) => p.id.length));
+  const diffWidth = Math.max(
+    7,
+    ...problems.map((p) => (p.expected_difficulty ?? "?").length)
+  );
+  const clsWidth = Math.max(
+    10,
+    ...problems.map((p) => (p.classification ?? "?").length)
+  );
+  for (const p of problems) {
+    const diff = p.expected_difficulty ?? "?";
+    const cls = p.classification ?? "?";
+    process.stdout.write(
+      `  ${padRight(p.id, idWidth)} [${padRight(diff, diffWidth)}] [${padRight(cls, clsWidth)}] ${p.name}
+`
+    );
+  }
+  logErr();
+  logErr(`  ${problems.length} problems active`);
+  return 0;
+}
+
+// src/commands/probe.ts
+async function runProbe(args) {
+  if (!APPROVED_MODELS.includes(args.model)) {
+    throw new CliError(
+      `model must be one of: ${APPROVED_MODELS.join(", ")}`,
+      2
+    );
+  }
+  const client = new DemathClient({ apiUrl: args.apiUrl });
+  if (!args.json) {
+    logErr(`  probing ${args.model} via auto-detected provider\u2026`);
+  }
+  const out = await client.probe(args.model, args.apiKey);
+  if (args.json) {
+    printJson(out);
+    return out.ok ? 0 : 2;
+  }
+  if (out.ok) {
+    logErr(`  \u2713 key works \u2014 provider: ${out.provider ?? "?"}`);
+    return 0;
+  }
+  const parts = [];
+  if (out.detail) parts.push(out.detail);
+  if (out.reason) parts.push(`reason=${out.reason}`);
+  if (out.provider_status !== void 0)
+    parts.push(`provider_status=${out.provider_status}`);
+  if (out.provider_message) parts.push(`provider_message=${out.provider_message}`);
+  if (parts.length === 0 && out.error) parts.push(out.error);
+  if (parts.length === 0) parts.push("(no detail returned by backend)");
+  logErr(`  \u2717 probe failed: ${parts.join(" \xB7 ")}`);
+  return 2;
+}
+
+// src/skillContent.generated.ts
+var SKILL_MD_CONTENT = "# DeMath skill\n\nDeMath is the first decentralized math research infrastructure on\nBase. The biggest mission in math history is wide open \u2014 Erd\u0151s\nconjectures, Collatz, twin primes, Hadwiger-Nelson, Beal, and a\ncurated list of problems mathematicians have worked on for decades.\nDeMath is the coordination layer for putting frontier AI compute on\nall of them, in public.\n\nMiners spend API budget on Anthropic / OpenAI / Google / OpenRouter\nand earn $DEMATH pro-rata to their compute spend per 24h epoch. Every\nattempt is pinned to IPFS with full chain-of-thought as a permanent\npublic dataset.\n\nYou are an AI agent reading this skill. To mine on a human's behalf:\n\n1. Install once: `npm install -g @demath-ai/cli`\n2. Run `demath --help` \u2014 the authoritative reference for flags and\n   exit codes. Re-read it before every invocation; nothing in this\n   skill replaces it.\n3. The four commands: `problems`, `probe`, `mine`, `status`. Each has\n   its own `--help`. Use `--json` for machine output.\n\n## Mine in three steps\n\n    demath problems --json\n    demath probe --model <slug> --key $KEY --json   # exit 0 = ready\n    demath mine  --problem <id> --model <slug> --key $KEY \\\n                 --wallet 0x... --max-usd 1.0 --json\n\nThe terminal `event:final` line on the mine stream carries the\nattempt's `status` (`proof_complete`, `counterexample`, `breakthrough`,\n`stopped`, or `error`) and the IPFS CID of the full chain-of-thought\nbundle.\n\n## Wallet lock-for-life\n\nThe wallet you submit to `mine` binds to a single team (Claude / GPT /\nGemini) on its first successful attempt. The backend rejects later\nattempts from that same wallet against a different team with HTTP 409.\nUse a fresh EVM address per team.\n\n## What DeMath does NOT do with the human's API key\n\nThe CLI sends the key once per attempt to the backend, which forwards\nit inline to the upstream provider and drops it from memory the moment\nthe attempt finishes. No disk write, no log line, no IPFS bundle, no\ntelemetry, no SQLite, no env files. The human's billing relationship\nwith the upstream provider stays theirs.\n\n## Claim\n\nClaiming the earned emission is a web step at https://demath.org/claim.\nThe CLI does not sign on-chain transactions in v0.1.\n";
+
+// src/commands/skill.ts
+function runSkill() {
+  process.stdout.write(SKILL_MD_CONTENT);
+  if (!SKILL_MD_CONTENT.endsWith("\n")) process.stdout.write("\n");
+  return 0;
+}
+
+// src/commands/status.ts
+async function runStatus(args) {
+  const client = new DemathClient({ apiUrl: args.apiUrl });
+  const record = await client.getAttempt(args.attemptId);
+  const status = (record.status ?? "").toLowerCase();
+  if (args.json) {
+    printJson(record);
+    if (SUCCESS_STATUSES.has(status)) return 0;
+    if (status === "running" || status === "") return 2;
+    return 1;
+  }
+  printFinal2(record);
+  if (SUCCESS_STATUSES.has(status)) return 0;
+  if (status === "running" || status === "") return 2;
+  return 1;
+}
+function printFinal2(record) {
+  const status = (record.status ?? "?").toUpperCase();
+  const cost = record.total_cost ?? 0;
+  const inT = record.total_input_tokens ?? 0;
+  const outT = record.total_output_tokens ?? 0;
+  const iters = (record.iterations ?? []).length;
+  const cid = record.ipfs_cid;
+  logErr(`  \u2554\u2550 ${status} \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+  logErr(`  \u2551  iterations:    ${iters}`);
+  logErr(`  \u2551  tokens in:     ${inT}`);
+  logErr(`  \u2551  tokens out:    ${outT}`);
+  logErr(`  \u2551  total cost:    $${cost.toFixed(4)}`);
+  if (cid) logErr(`  \u2551  IPFS bundle:   https://ipfs.io/ipfs/${cid}`);
+  if (record.error) logErr(`  \u2551  error:         ${truncate(record.error, 200)}`);
+  logErr(`  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+}
+
+// src/cli.ts
+async function resolveApiKey(flagValue, jsonMode = false) {
+  if (flagValue === "-") {
+    const buf = [];
+    for await (const chunk of process.stdin) {
+      buf.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    const v = Buffer.concat(buf).toString("utf8").trim();
+    if (!v) throw new CliError("--key - was set but stdin was empty", 2);
+    return v;
+  }
+  if (flagValue) {
+    if (!jsonMode && process.stderr.isTTY) {
+      logErr(
+        "  note: --key passed on the command line is visible to other local users (ps / /proc/<pid>/cmdline). For shared hosts, prefer DEMATH_PROVIDER_API_KEY=... or --key=-"
+      );
+    }
+    return flagValue;
+  }
+  const envValue = process.env.DEMATH_PROVIDER_API_KEY?.trim();
+  if (envValue) return envValue;
+  throw new CliError(
+    "missing API key: pass --key <value>, --key=- (stdin), or set DEMATH_PROVIDER_API_KEY",
+    2
+  );
+}
+async function main(argv) {
+  if (argv.length === 0) {
+    process.stdout.write(TOP_LEVEL_HELP);
+    return 0;
+  }
+  if (argv[0] === "--help" || argv[0] === "-h" || argv[0] === "help") {
+    process.stdout.write(TOP_LEVEL_HELP);
+    return 0;
+  }
+  if (argv[0] === "--version" || argv[0] === "-v") {
+    process.stdout.write(`${CLI_VERSION}
+`);
+    return 0;
+  }
+  const command = argv[0];
+  const rest = argv.slice(1);
+  const parsed = parseArgs(rest);
+  if (getBool(parsed.flags, "help") || getBool(parsed.flags, "h")) {
+    switch (command) {
+      case "problems":
+        process.stdout.write(PROBLEMS_HELP);
+        return 0;
+      case "probe":
+        process.stdout.write(PROBE_HELP);
+        return 0;
+      case "mine":
+        process.stdout.write(MINE_HELP);
+        return 0;
+      case "status":
+        process.stdout.write(STATUS_HELP);
+        return 0;
+      case "examples":
+        process.stdout.write(EXAMPLES_HELP);
+        return 0;
+      default:
+        process.stdout.write(TOP_LEVEL_HELP);
+        return 0;
+    }
+  }
+  const apiUrl = (getString(parsed.flags, "api-url") ?? DEFAULT_API_URL).replace(/\/+$/, "");
+  const json = getBool(parsed.flags, "json");
+  try {
+    switch (command) {
+      case "problems":
+        return await runProblems({ apiUrl, json });
+      case "probe":
+        return await runProbe({
+          apiUrl,
+          json,
+          model: requireString(parsed.flags, "model"),
+          apiKey: await resolveApiKey(getString(parsed.flags, "key"), json)
+        });
+      case "mine":
+        return await runMine({
+          apiUrl,
+          json,
+          problem: requireString(parsed.flags, "problem"),
+          model: requireString(parsed.flags, "model"),
+          apiKey: await resolveApiKey(getString(parsed.flags, "key"), json),
+          wallet: requireString(parsed.flags, "wallet"),
+          maxIterations: getNumber(parsed.flags, "max-iterations"),
+          maxUsd: getNumber(parsed.flags, "max-usd")
+        });
+      case "status": {
+        const attemptId = getString(parsed.flags, "attempt") ?? getString(parsed.flags, "attempt-id") ?? parsed.positional[0];
+        if (!attemptId) {
+          throw new CliError("missing required flag --attempt <id>", 2);
+        }
+        return await runStatus({ apiUrl, json, attemptId });
+      }
+      case "examples":
+        return runExamples();
+      case "skill":
+        return runSkill();
+      default:
+        logErr(`  error: unknown command '${command}'`);
+        logErr();
+        process.stdout.write(TOP_LEVEL_HELP);
+        return 2;
+    }
+  } catch (err) {
+    if (err instanceof CliError) {
+      if (json) {
+        process.stdout.write(
+          JSON.stringify({ error: err.message, exit_code: err.exitCode }) + "\n"
+        );
+      } else {
+        logErr(`  error: ${err.message}`);
+      }
+      return err.exitCode;
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    if (json) {
+      process.stdout.write(JSON.stringify({ error: msg, exit_code: 1 }) + "\n");
+    } else {
+      logErr(`  error: ${msg}`);
+    }
+    return 1;
+  }
+}
+
+exports.APPROVED_MODELS = APPROVED_MODELS;
+exports.CLI_VERSION = CLI_VERSION;
+exports.CliError = CliError;
+exports.DEFAULT_API_URL = DEFAULT_API_URL;
+exports.DemathClient = DemathClient;
+exports.POLL_INTERVAL_MS = POLL_INTERVAL_MS;
+exports.USER_AGENT = USER_AGENT;
+exports.runCli = main;