scaledthought 0.2.1 → 0.3.0

package/README.md

@@ -7,7 +7,7 @@ JSON when stdout isn't a terminal, and every error is one JSON line on stderr wi
 Agents: the full setup protocol is at <https://scaledthought.com/llms.txt>.
 
 ```bash
-npx -y scaledthought@latest init --region us   # or: --region ca (data stays in Canada)
+npx -y scaledthought@0.3 init --region us   # or: --region ca (data stays in Canada)
 ```
 
 `init` creates an account, writes `ST_API_KEY` and `ST_BASE_URL` to `./.env` (mode 0600), adds `.env` to
@@ -30,9 +30,9 @@ Inference is prepaid, and a new account has no credits: until your human pays, c
 `402 insufficient_credits`. So the first thing after `init` is a top-up your human approves:
 
 ```bash
-npx -y scaledthought@latest billing topup --amount-usd 5  # prints approval_url and topup_id
+npx -y scaledthought@0.3 billing topup --amount-usd 20  # prints approval_url and topup_id
 # show your human the approval_url, exactly as printed; they pay by card
-npx -y scaledthought@latest billing wait                  # returns once they've paid; on topup_pending run it again
+npx -y scaledthought@0.3 billing wait                  # returns once they've paid; on topup_pending run it again
 ```
 
 `billing wait` returns within about 90 seconds (`--timeout-s` to change it), under Claude Code's default 2-minute
@@ -40,11 +40,11 @@ shell timeout. Prefer it to `billing topup --wait`: an agent's shell tool usuall
 ends, so the link would reach the human only after the payment it is waiting for.
 
 ```bash
-npx -y scaledthought@latest models --live                 # models serving in your region now
-npx -y scaledthought@latest chat -m auto "Reply with OK"  # one real completion
-npx -y scaledthought@latest mcp                           # `claude mcp add …` command + JSON config
-npx -y scaledthought@latest account                       # plan, region, spend
-npx -y scaledthought@latest account ad-measurement off    # opt out of ad measurement
+npx -y scaledthought@0.3 models --live                 # models serving in your region now
+npx -y scaledthought@0.3 chat -m auto "Reply with OK"  # one real completion
+npx -y scaledthought@0.3 mcp                           # `claude mcp add …` command + JSON config
+npx -y scaledthought@0.3 account                       # plan, region, spend
+npx -y scaledthought@0.3 account ad-measurement off    # opt out of ad measurement
 ```
 
 Other commands: `keys list|create|rotate|revoke|revoke-self` (`keys create --expires-in 30d --scopes inference --child`, `keys rotate <id> --grace 24h`), `usage`, `billing status|topup|wait|auto-reload|transactions`, `batches …`,

package/dist/index.js

@@ -553,7 +553,7 @@ import { join } from "node:path";
 // package.json
 var package_default = {
   name: "scaledthought",
-  version: "0.2.1",
+  version: "0.3.0",
   description: "Headless open-model inference, run by your agent. Prepaid, pay per token. US or Canada.",
   license: "MIT",
   keywords: [
@@ -631,9 +631,20 @@ function readDotEnv(cwd) {
   }
   return out;
 }
-var CREDITS_HINT = "This account has no credits for this request (inference is prepaid). Run `npx -y scaledthought@latest billing topup --amount-usd 5` (creating it charges nothing), end your turn giving your human its message_for_human (the approval_url), and once they say they've paid run `npx -y scaledthought@latest billing wait`, then retry. Don't retry before that or create another account.";
+var CREDITS_HINT = "This account has no credits for this request (inference is prepaid). Run `npx -y scaledthought@0.3 billing topup --amount-usd 20` (creating it charges nothing) and give your human its message_for_human. If it printed opened_in_browser: true, run `npx -y scaledthought@0.3 billing wait` in the same turn (again on topup_pending, up to 15 minutes): it returns as soon as they pay. Otherwise end your turn with the message and run billing wait once they're back. Then retry. Don't retry before that or create another account.";
 var HINTS = {
-  no_key: "Run `npx -y scaledthought@latest init --region us|ca` in this directory, or set ST_API_KEY.",
+  no_key: "For an existing account run `npx -y scaledthought@0.3 login`; for a new one, `init --region us|ca`. Or set ST_API_KEY.",
+  key_exists: "This folder already has a key (ST_API_KEY in ./.env or the environment). Use it, or pass --force to replace it.",
+  authorization_pending: "Your human hasn't typed the code yet. If they have the page open, run `npx -y scaledthought@0.3 login --wait` again right away (codes last 10 minutes); otherwise remind them of the code and the URL.",
+  access_denied: "Your human denied the connection. Ask them before running login again.",
+  expired_token: "The code expired. Run `npx -y scaledthought@0.3 login` again for a new one.",
+  already_claimed: "This code was already used. Run `npx -y scaledthought@0.3 login` again for a new one.",
+  invalid_connect_code: "A connect line works once, for 15 minutes, and its code starts with stl_. Ask your human for a new line from the dashboard.",
+  too_many_failed_claims: "Too many failed connect-line claims in this region. Wait a few minutes, then retry.",
+  invalid_device_code: "Run `npx -y scaledthought@0.3 login` again for a new code.",
+  no_login_pending: "Run `npx -y scaledthought@0.3 login` first: it prints a code for your human.",
+  account_not_found: "Pass a saved account's id or exact name (see choose_account from `init`), or connect another with `login`.",
+  no_saved_accounts: "No account is saved on this machine. Run `npx -y scaledthought@0.3 login` to connect an existing one.",
   bad_key: "ST_API_KEY must look like st_{us|ca}_{live|test}_<40 chars>. Re-run init in a directory without one.",
   invalid_api_key: "The key is missing, revoked or mistyped. Check ST_API_KEY in .env; create a new one with `keys create`.",
   missing_api_key: "Send the key as `Authorization: Bearer $ST_API_KEY`.",
@@ -647,12 +658,12 @@ var HINTS = {
   credits_required_for_fine_tuning: `Fine-tuning is paid from prepaid credits. ${CREDITS_HINT}`,
   approval_required: "This change needs your human's approval. Send them the approval_url from `billing topup`; disabling or lowering auto-reload needs none.",
   daily_cap_exceeded: "An operator-set daily cap on this account is reached. It resets at 00:00 UTC. Tell your human.",
-  free_tier_limit: "Accounts that haven't bought credits have lower limits. The first credit purchase lifts them: run `billing topup --amount-usd 5` and show your human the approval_url.",
+  free_tier_limit: "Accounts that haven't bought credits have lower limits. The first credit purchase lifts them: run `billing topup --amount-usd 20` and show your human the approval_url.",
   free_tier_key_limit: "Accounts that haven't bought credits have at most 5 active keys. Revoke one with `keys revoke <id>`, or buy credits with `billing topup`.",
   too_many_pending_topups: "Two approval links are still unpaid. Ask your human to use one (see `billing status` pending_topups), or wait for them to expire.",
   daily_topup_limit: "Top-ups are limited to $2,000 per account per rolling 24 hours (open links and auto-reloads included). Use a smaller amount (see available_usd) or wait.",
-  billing_upgrade_removed: "Run `billing topup --amount-usd 5` and show your human the approval_url.",
-  gone: "This endpoint was removed. For credits use `billing topup --amount-usd 5`.",
+  billing_upgrade_removed: "Run `billing topup --amount-usd 20` and show your human the approval_url.",
+  gone: "This endpoint was removed. For credits use `billing topup --amount-usd 20`.",
   fine_tuning_requires_self_hosted: "This base model can't be fine-tuned in your region (it isn't served on our own GPUs). Choose another base model.",
   rate_limit_exceeded: "Wait the number of seconds in retry_after, then retry.",
   session_limit_exceeded: "Too many realtime sessions are open on this key. Close one, then retry.",
@@ -905,8 +916,8 @@ async function speak(ctx, o) {
 
 // src/commands.ts
 import { spawn } from "node:child_process";
-import { chmodSync, existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync } from "node:fs";
-import { join as join3, resolve as resolve2 } from "node:path";
+import { chmodSync as chmodSync3, existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join5, resolve as resolve2 } from "node:path";
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
@@ -8964,6 +8975,8 @@ var EXPERIMENT_METRICS = [
   "signups",
   "activation_rate",
   "paid_rate",
+  "topup_request_rate",
+  "topup_completion_rate",
   "cost_per_activated",
   "cost_per_payer",
   "onboarding_success_rate",
@@ -9238,27 +9251,516 @@ var TERMS_URL = `${LEGAL_SITE}${LEGAL_PATHS.terms}`;
 var PRIVACY_URL = `${LEGAL_SITE}${LEGAL_PATHS.privacy}`;
 var ACCEPTABLE_USE_URL = `${LEGAL_SITE}${LEGAL_PATHS.acceptableUse}`;
 var REFUND_POLICY_URL = `${LEGAL_SITE}${LEGAL_PATHS.creditsAndRefunds}`;
-var TERMS_NOTICE = `By creating this account you accept the ScaledThought Terms of Service (${TERMS_URL}) and Privacy Policy ` + `(${PRIVACY_URL}) on behalf of the person or organisation you act for, who is the customer.`;
+var TERMS_NOTICE = `Nothing has been accepted on your behalf. You accept the ScaledThought Terms of Service (${TERMS_URL}) and the ` + `Credits & Refunds policy (${REFUND_POLICY_URL}) yourself when you buy credits. Privacy Policy: ${PRIVACY_URL}.`;
+
+// src/connect.ts
+import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { hostname } from "node:os";
+import { basename as basename2, join as join4 } from "node:path";
+
+// src/credentials.ts
+import { spawnSync } from "node:child_process";
+import { chmodSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "node:fs";
+import { join as join3 } from "node:path";
+var SERVICE = "scaledthought";
+var slot = (a) => `${a.region}:${a.account_id}`;
+var SLOT_RE = /^(us|ca):acct_[0-9A-Za-z]{1,40}$/;
+function writePrivate(file, data) {
+  writeFileSync(file, `${JSON.stringify(data, null, 2)}
+`, { mode: 384 });
+  chmodSync(file, 384);
+}
+function readJson(file, fallback) {
+  try {
+    return existsSync2(file) ? JSON.parse(readFileSync3(file, "utf8")) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+function fileBackend(dir) {
+  const file = join3(dir, "credentials.json");
+  const all = () => readJson(file, {});
+  return {
+    where: "~/.config/scaledthought/credentials.json (0600)",
+    get: (s) => all()[s] ?? null,
+    set: (s, key) => {
+      writePrivate(file, { ...all(), [s]: key });
+      return true;
+    },
+    del: (s) => {
+      const a = all();
+      delete a[s];
+      writePrivate(file, a);
+    }
+  };
+}
+function keychainBackend() {
+  return {
+    where: "macOS Keychain (service scaledthought)",
+    get: (s) => {
+      const r = spawnSync("security", ["find-generic-password", "-s", SERVICE, "-a", s, "-w"], { encoding: "utf8" });
+      return r.status === 0 ? r.stdout.trim() || null : null;
+    },
+    set: (s, key) => spawnSync("security", ["-i"], {
+      input: `add-generic-password -U -s ${SERVICE} -a ${s} -l ScaledThought -w ${key}
+`,
+      encoding: "utf8"
+    }).status === 0,
+    del: (s) => {
+      spawnSync("security", ["delete-generic-password", "-s", SERVICE, "-a", s], { encoding: "utf8" });
+    }
+  };
+}
+function secretToolBackend() {
+  return {
+    where: "the Secret Service keyring (secret-tool, service scaledthought)",
+    get: (s) => {
+      const r = spawnSync("secret-tool", ["lookup", "service", SERVICE, "account", s], { encoding: "utf8" });
+      return r.status === 0 ? r.stdout.trim() || null : null;
+    },
+    set: (s, key) => spawnSync("secret-tool", ["store", `--label=ScaledThought ${s}`, "service", SERVICE, "account", s], {
+      input: key,
+      encoding: "utf8"
+    }).status === 0,
+    del: (s) => {
+      spawnSync("secret-tool", ["clear", "service", SERVICE, "account", s], { encoding: "utf8" });
+    }
+  };
+}
+var has = (bin) => spawnSync(bin, ["--help"], { stdio: "ignore" }).error === undefined;
+function storeAt(dir, os) {
+  const indexFile = join3(dir, "accounts.json");
+  const file = fileBackend(dir);
+  const index = () => readJson(indexFile, []).filter((e) => SLOT_RE.test(slot(e)));
+  const ensureDir = () => mkdirSync(dir, { recursive: true, mode: 448 });
+  let where = os?.where ?? file.where;
+  return {
+    get where() {
+      return where;
+    },
+    list: () => index().map(({ in: _in, ...a }) => a),
+    getKey: (a) => {
+      const e = index().find((x) => slot(x) === slot(a));
+      if (!e)
+        return null;
+      return (e.in === "os" && os ? os.get(slot(a)) : file.get(slot(a))) ?? null;
+    },
+    save: (a, key) => {
+      ensureDir();
+      let into = "file";
+      if (os?.set(slot(a), key))
+        into = "os";
+      else
+        file.set(slot(a), key);
+      where = into === "os" && os ? os.where : file.where;
+      writePrivate(indexFile, [...index().filter((x) => slot(x) !== slot(a)), { ...a, in: into }]);
+    },
+    remove: (a) => {
+      const e = index().find((x) => slot(x) === slot(a));
+      if (!e)
+        return;
+      if (e.in === "os" && os)
+        os.del(slot(a));
+      else
+        file.del(slot(a));
+      writePrivate(indexFile, index().filter((x) => slot(x) !== slot(a)));
+    },
+    touch: (a) => {
+      const all = index();
+      const e = all.find((x) => slot(x) === slot(a));
+      if (!e)
+        return;
+      e.last_used_at = new Date().toISOString();
+      writePrivate(indexFile, all);
+    }
+  };
+}
+function machineStore(env, platform = process.platform) {
+  const mode = env.ST_CREDENTIAL_STORE;
+  const home = env.HOME || env.USERPROFILE;
+  if (mode === "off" || !home)
+    return null;
+  const dir = join3(env.XDG_CONFIG_HOME || join3(home, ".config"), "scaledthought");
+  let os = null;
+  if (mode !== "file") {
+    if (platform === "darwin" && existsSync2("/usr/bin/security"))
+      os = keychainBackend();
+    else if (platform === "linux" && env.DBUS_SESSION_BUS_ADDRESS && has("secret-tool"))
+      os = secretToolBackend();
+  }
+  return storeAt(dir, os);
+}
+
+// src/connect.ts
+var NPX = "npx -y scaledthought@0.3";
+var LOGIN_DIR = ".scaledthought";
+var LOGIN_FILE = join4(LOGIN_DIR, "login.json");
+var KEY_SAVED_TO = ".env (ST_API_KEY, ST_BASE_URL)";
+var CONNECT_CODE_RE = /^stl_[A-Za-z0-9_-]{22,64}$/;
+var PROJECT_SCOPES = ["inference", "read", "keys", "billing"];
+var storeOf = (ctx) => ctx.store !== undefined ? ctx.store : machineStore(ctx.env);
+function defaultClientLabel(env, host = hostname()) {
+  const keys = Object.keys(env).filter((k) => env[k] !== undefined && env[k] !== "");
+  const tool = env.CLAUDECODE ? "Claude Code" : keys.some((k) => k.startsWith("CODEX_")) ? "Codex" : keys.some((k) => k.startsWith("CURSOR_")) ? "Cursor" : "CLI";
+  return `${tool} on ${host.replace(/\.local$/, "")}`.slice(0, 80);
+}
+function readLoginState(cwd) {
+  const f = join4(cwd, LOGIN_FILE);
+  if (!existsSync3(f))
+    return null;
+  try {
+    const s = JSON.parse(readFileSync4(f, "utf8"));
+    return typeof s.device_code === "string" && (s.region === "us" || s.region === "ca") ? s : null;
+  } catch {
+    return null;
+  }
+}
+function writeLoginState(cwd, s) {
+  mkdirSync2(join4(cwd, LOGIN_DIR), { recursive: true, mode: 448 });
+  const f = join4(cwd, LOGIN_FILE);
+  writeFileSync2(f, `${JSON.stringify(s)}
+`, { mode: 384 });
+  chmodSync2(f, 384);
+  ensureIgnored(cwd, `${LOGIN_DIR}/`);
+}
+var clearLoginState = (cwd) => rmSync(join4(cwd, LOGIN_FILE), { force: true });
+function ensureIgnored(cwd, entry) {
+  const gi = join4(cwd, ".gitignore");
+  const text = existsSync3(gi) ? readFileSync4(gi, "utf8") : "";
+  const bare = entry.replace(/\/$/, "");
+  if (text.split(/\r?\n/).some((l) => [entry, bare, `/${entry}`, `/${bare}`].includes(l.trim())))
+    return;
+  const sep = text === "" || text.endsWith(`
+`) ? "" : `
+`;
+  writeFileSync2(gi, `${text}${sep}${entry}
+`);
+}
+function refuseExistingKey(ctx, force) {
+  if (force)
+    return;
+  const where = ctx.env.ST_API_KEY ? "the ST_API_KEY environment variable" : readDotEnv(ctx.cwd).ST_API_KEY ? "./.env" : null;
+  if (where)
+    throw new CliError("key_exists", `This folder already has a ScaledThought key (${where}). Nothing was changed.`);
+}
+function saveToStore(ctx, a, key, noSave) {
+  if (noSave)
+    return false;
+  const store = storeOf(ctx);
+  if (!store)
+    return false;
+  try {
+    store.save({ ...a, saved_at: new Date().toISOString() }, key);
+    return store.where;
+  } catch {
+    return false;
+  }
+}
+function finish(ctx, c, o) {
+  writeEnv(ctx.cwd, { ST_API_KEY: c.api_key, ST_BASE_URL: c.base_url });
+  ensureGitignored(ctx.cwd);
+  const saved = saveToStore(ctx, { region: c.region, account_id: c.account_id, account_name: c.account_name, base_url: c.base_url }, c.api_key, o.noSave);
+  clearLoginState(ctx.cwd);
+  return {
+    status: "connected",
+    account_id: c.account_id,
+    account_name: c.account_name,
+    region: c.region,
+    key_name: c.key_name,
+    key_saved_to: KEY_SAVED_TO,
+    saved_to_credential_store: saved !== false,
+    ...saved ? { credential_store: saved } : {}
+  };
+}
+var claim2 = (ctx, region, body) => api(ctx, "POST", "/v1/device/token", { auth: false, region, body });
+async function login(ctx, o = {}) {
+  refuseExistingKey(ctx, o.force);
+  const region = o.region ?? "us";
+  const label = (o.label ?? defaultClientLabel(ctx.env)).slice(0, 80);
+  const r = await api(ctx, "POST", "/v1/device/codes", { auth: false, region, body: { client_label: label, origin: "agent" } });
+  writeLoginState(ctx.cwd, {
+    device_code: r.device_code,
+    region,
+    origin: "agent",
+    user_code: r.user_code,
+    created_at: new Date().toISOString()
+  });
+  const noOpen = o.noOpen || ctx.env.ST_NO_BROWSER === "1";
+  const opened = !noOpen && await (o.open ?? openInBrowser)(r.verification_url);
+  return {
+    status: "pending",
+    user_code: r.user_code,
+    verification_url: r.verification_url,
+    opened_in_browser: opened,
+    expires_in: r.expires_in,
+    client_label: label,
+    message_for_human: opened ? `To connect this agent to your ScaledThought account, I've opened ${r.verification_url}. Sign in and type the code ${r.user_code}.` : `To connect this agent to your ScaledThought account, open ${r.verification_url}, sign in and type the code ${r.user_code}.`,
+    next_command: `${NPX} login --wait`,
+    next_steps: [
+      opened ? `Tell your human message_for_human, then in the same turn run: ${NPX} login --wait. On authorization_pending run it again, for up to 10 minutes in all.` : `Give your human message_for_human and end your turn. When they say they've typed the code, run: ${NPX} login --wait.`,
+      "Never put the code in a link: the human types it on the page."
+    ]
+  };
+}
+async function loginWait(ctx, o = {}) {
+  const s = readLoginState(ctx.cwd);
+  if (s?.origin !== "agent")
+    throw new CliError("no_login_pending", "No login is waiting in this folder.");
+  refuseExistingKey(ctx, o.force);
+  const deadline = Date.now() + (o.timeoutS ?? 90) * 1000;
+  for (;; ) {
+    try {
+      return finish(ctx, await claim2(ctx, s.region, { device_code: s.device_code }), o);
+    } catch (e) {
+      if (!(e instanceof CliError))
+        throw e;
+      if (e.code !== "authorization_pending") {
+        if (["expired_token", "access_denied", "already_claimed", "invalid_device_code"].includes(e.code))
+          clearLoginState(ctx.cwd);
+        throw e;
+      }
+      if (Date.now() >= deadline)
+        throw new CliError("authorization_pending", "Your human hasn't approved the code yet.", undefined, {
+          user_code: s.user_code ?? null
+        });
+    }
+    await new Promise((r) => setTimeout(r, o.pollMs ?? 5000));
+  }
+}
+async function loginWithCode(ctx, o) {
+  const code = o.code.trim();
+  if (!CONNECT_CODE_RE.test(code))
+    throw new CliError("invalid_connect_code", "That isn't a connect line's code (it starts with stl_). Copy the whole line from the dashboard.");
+  refuseExistingKey(ctx, o.force);
+  const region = o.region ?? "us";
+  const label = (o.label ?? defaultClientLabel(ctx.env)).slice(0, 80);
+  return finish(ctx, await claim2(ctx, region, { connect_code: code, client_label: label }), o);
+}
+var usdOf = (b) => b && typeof b.balance_usd === "number" ? b.balance_usd : null;
+var withKey = (ctx, key) => ({ ...ctx, env: { ...ctx.env, ST_API_KEY: key } });
+async function projectKey(ctx, store, a) {
+  const key = store.getKey(a);
+  if (!key || regionOfKey(key) !== a.region)
+    return null;
+  const folder = basename2(ctx.cwd) || "project";
+  const name = `project: ${folder}`.slice(0, 80);
+  let created;
+  try {
+    created = await api(withKey(ctx, key), "POST", "/v1/keys", {
+      body: {
+        name,
+        child: true,
+        scopes: PROJECT_SCOPES,
+        lives_in: `env:${hostname()}:${ctx.cwd}`.slice(0, 300)
+      }
+    });
+  } catch (e) {
+    if (e instanceof CliError && ["invalid_api_key", "key_expired", "account_suspended"].includes(e.code)) {
+      store.remove(a);
+      return null;
+    }
+    if (e instanceof CliError && (e.code === "insufficient_scope" || e.code === "scope_not_allowed")) {
+      writeEnv(ctx.cwd, { ST_API_KEY: key, ST_BASE_URL: a.base_url });
+      ensureGitignored(ctx.cwd);
+      store.touch(a);
+      return { key, key_id: null, key_name: "this machine's saved key (it can't make project keys)" };
+    }
+    throw e;
+  }
+  writeEnv(ctx.cwd, { ST_API_KEY: created.api_key, ST_BASE_URL: a.base_url });
+  ensureGitignored(ctx.cwd);
+  store.touch(a);
+  return { key: created.api_key, key_id: created.id, key_name: created.name };
+}
+var label = (a, balance) => balance == null ? a.account_name : `${a.account_name} ($${balance.toFixed(2)})`;
+async function reuseSavedAccount(ctx, o) {
+  const store = storeOf(ctx);
+  const saved = (store?.list() ?? []).filter((a) => !o.region || a.region === o.region);
+  if (!store || saved.length === 0) {
+    if (o.account)
+      throw new CliError("no_saved_accounts", `No account is saved on this machine${o.region ? ` in ${o.region}` : ""}.`);
+    return null;
+  }
+  let pick;
+  if (o.account) {
+    const want = o.account.trim().toLowerCase();
+    pick = saved.find((a) => a.account_id.toLowerCase() === want) ?? saved.find((a) => a.account_name.toLowerCase() === want);
+    if (!pick)
+      throw new CliError("account_not_found", `No saved account named or numbered "${o.account}".`, undefined, {
+        saved_accounts: saved.map((a) => ({ account_id: a.account_id, name: a.account_name, region: a.region }))
+      });
+  } else if (saved.length > 1) {
+    const rows = await Promise.all(saved.map(async (a) => {
+      const key = store.getKey(a);
+      const b = key ? await api(withKey(ctx, key), "GET", "/v1/billing").catch(() => null) : null;
+      return { a, balance: usdOf(b) };
+    }));
+    rows.sort((x, y) => (y.a.last_used_at ?? y.a.saved_at).localeCompare(x.a.last_used_at ?? x.a.saved_at));
+    const names = rows.map((r) => label(r.a, r.balance));
+    return {
+      status: "choose_account",
+      choose_account: rows.map((r) => ({
+        account_id: r.a.account_id,
+        name: r.a.account_name,
+        region: r.a.region,
+        balance_usd: r.balance,
+        last_used: (r.a.last_used_at ?? r.a.saved_at).slice(0, 10)
+      })),
+      message_for_human: `Which ScaledThought account should this repo use: ${names.slice(0, -1).join(", ")} or ${names.at(-1)}? Or a new one for separate billing?`,
+      next_steps: [
+        "Ask your human message_for_human and end your turn. Nothing was created.",
+        `Then run: ${NPX} init --account "<name or account_id>" (or ${NPX} init --new-account for a separate, new account).`
+      ]
+    };
+  } else
+    pick = saved[0];
+  const made = await projectKey(ctx, store, pick);
+  if (!made) {
+    if (o.account)
+      throw new CliError("account_not_found", `The key saved for ${pick.account_name} no longer works, so it was forgotten.`, `Connect it again with \`${NPX} login\`.`);
+    return reuseSavedAccount(ctx, o);
+  }
+  const billing = await api(withKey(ctx, made.key), "GET", "/v1/billing").catch(() => null);
+  return {
+    already_initialized: false,
+    reused_account: true,
+    account_id: pick.account_id,
+    account_name: pick.account_name,
+    region: pick.region,
+    base_url: pick.base_url,
+    key_name: made.key_name,
+    key_id: made.key_id,
+    key_saved_to: KEY_SAVED_TO,
+    saved_to_credential_store: true,
+    note: `This folder uses ${pick.account_name}, the account saved on this machine, with its own project key. To switch: ${NPX} use "<name>". For a separate account: ${NPX} init --new-account.`,
+    ...await liveSummary(withKey(ctx, made.key), pick.region, usdOf(billing))
+  };
+}
+async function afterNewAccount(ctx, a, o) {
+  const saved = saveToStore(ctx, {
+    region: a.region,
+    account_id: a.account_id,
+    account_name: a.name?.trim() || `Account ${a.account_id.slice(-6)}`,
+    base_url: a.base_url
+  }, a.api_key, o.noSave);
+  let existingCode = null;
+  try {
+    const r = await api(withKey(ctx, a.api_key), "POST", "/v1/device/codes", { body: { origin: "init", client_label: (o.label ?? defaultClientLabel(ctx.env)).slice(0, 80) } });
+    if (typeof r.device_code === "string") {
+      writeLoginState(ctx.cwd, {
+        device_code: r.device_code,
+        region: a.region,
+        origin: "init",
+        user_code: typeof r.user_code === "string" ? r.user_code : undefined,
+        new_account_id: a.account_id,
+        created_at: new Date().toISOString()
+      });
+      existingCode = typeof r.user_code === "string" ? r.user_code : null;
+    }
+  } catch {}
+  return { saved, existingCode };
+}
+function existingAccountCode(cwd) {
+  const s = readLoginState(cwd);
+  return s?.origin === "init" && s.user_code ? s.user_code : null;
+}
+var existingAccountHint = (code) => `If you already have a ScaledThought account, choose "Use it instead" on that page and type the code ${code}: I'll use that account and nothing is charged.`;
+async function useAccount(ctx, o) {
+  const store = storeOf(ctx);
+  const saved = store?.list() ?? [];
+  if (!store || saved.length === 0)
+    throw new CliError("no_saved_accounts", "No account is saved on this machine.");
+  const want = o.target.trim().toLowerCase();
+  const pick = saved.find((a) => a.account_id.toLowerCase() === want) ?? saved.find((a) => a.account_name.toLowerCase() === want);
+  if (!pick)
+    throw new CliError("account_not_found", `No saved account named or numbered "${o.target}".`, undefined, {
+      saved_accounts: saved.map((a) => ({ account_id: a.account_id, name: a.account_name, region: a.region }))
+    });
+  const oldKey = readDotEnv(ctx.cwd).ST_API_KEY;
+  if (oldKey) {
+    const cur = await api(withKey(ctx, oldKey), "GET", "/v1/account").catch(() => null);
+    if (cur?.account_id === pick.account_id)
+      return { status: "unchanged", account_id: pick.account_id, account_name: pick.account_name };
+  }
+  const made = await projectKey(ctx, store, pick);
+  if (!made)
+    throw new CliError("account_not_found", `The key saved for ${pick.account_name} no longer works, so it was forgotten.`, `Connect it again with \`${NPX} login --force\`.`);
+  let oldRevoked = false;
+  if (oldKey && !saved.some((a) => store.getKey(a) === oldKey)) {
+    oldRevoked = await api(withKey(ctx, oldKey), "DELETE", "/v1/keys/self").then(() => true, () => false);
+  }
+  return {
+    status: "switched",
+    account_id: pick.account_id,
+    account_name: pick.account_name,
+    region: pick.region,
+    key_name: made.key_name,
+    key_saved_to: KEY_SAVED_TO,
+    old_key_revoked: oldRevoked,
+    ...ctx.env.ST_API_KEY ? { warnings: ["ST_API_KEY is set in the environment and overrides ./.env: unset it to use the new key."] } : {}
+  };
+}
+async function connectedExisting(ctx, o = {}) {
+  const s = readLoginState(ctx.cwd);
+  if (s?.origin !== "init")
+    return null;
+  let c;
+  try {
+    c = await claim2(ctx, s.region, { device_code: s.device_code });
+  } catch (e) {
+    if (e instanceof CliError && ["expired_token", "access_denied", "already_claimed"].includes(e.code))
+      clearLoginState(ctx.cwd);
+    return null;
+  }
+  const done = finish(ctx, c, o);
+  const store = storeOf(ctx);
+  if (c.closed_account && store)
+    store.remove({ region: s.region, account_id: c.closed_account });
+  const billing = await api(withKey(ctx, c.api_key), "GET", "/v1/billing").catch(() => null);
+  const balance = usdOf(billing);
+  return {
+    status: "connected_existing",
+    account_id: c.account_id,
+    account_name: c.account_name,
+    balance_usd: balance,
+    key_name: c.key_name,
+    key_saved_to: KEY_SAVED_TO,
+    saved_to_credential_store: done.saved_to_credential_store,
+    closed_account: c.closed_account ? `${c.closed_account} (new, never paid)` : null,
+    message_for_human: `You already had an account, so I've connected to it instead: ${c.account_name}${balance == null ? "" : `, $${balance.toFixed(2)} left`}. Nothing was charged.`
+  };
+}
+async function readCodeFrom(stream) {
+  let text = "";
+  for await (const chunk of stream) {
+    text += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    if (text.includes(`
+`) || text.length > 4096)
+      break;
+  }
+  return /\bstl_[A-Za-z0-9_-]+/.exec(text)?.[0] ?? (text.split(/\r?\n/)[0] ?? "").trim();
+}
 
 // src/commands.ts
-var NPX = "npx -y scaledthought@latest";
-var FIRST_TOPUP_USD = 5;
-var TOPUP_COMMAND = `${NPX} billing topup --amount-usd ${FIRST_TOPUP_USD}`;
-var WAIT_COMMAND = `${NPX} billing wait`;
+var NPX2 = "npx -y scaledthought@0.3";
+var FIRST_TOPUP_USD = 20;
+var TOPUP_COMMAND = `${NPX2} billing topup --amount-usd ${FIRST_TOPUP_USD}`;
+var WAIT_COMMAND = `${NPX2} billing wait`;
+var WAIT_PATIENCE_MIN = 15;
 var CREDIT_STEPS = [
   `Inference is prepaid and this account has no credits yet: completions return 402 insufficient_credits until your human pays. Do these first, in order:`,
   `1. Run: ${TOPUP_COMMAND}. It opens the checkout page in your human's browser and prints approval_url, topup_id and message_for_human. Creating it charges nothing: don't ask first.`,
-  `2. End your turn with message_for_human (it says the checkout page is open and holds the approval_url exactly as printed, in case it didn't open): the one-time payment page where your human accepts the Terms and pays $${FIRST_TOPUP_USD} by card. Don't run anything that waits before they have it, don't retry the call and don't create another account.`,
-  `3. When they say they've paid, run: ${WAIT_COMMAND}. It returns status "paid" with the new balance (at once if already paid); topup_pending means not yet.`,
+  `2. If opened_in_browser is true, the funding page (where your human confirms $${FIRST_TOPUP_USD}, can turn on auto-reload, accepts the Terms and pays by card) is already in front of them: tell them so with message_for_human and, in the same turn, run: ${WAIT_COMMAND}. It returns status "paid" with the new balance as soon as they pay; on topup_pending run it again, for up to ${WAIT_PATIENCE_MIN} minutes in all. Don't wait for them to say they've paid.`,
+  `3. If opened_in_browser is false (or it's still unpaid after ${WAIT_PATIENCE_MIN} minutes), end your turn with message_for_human: it holds the approval_url exactly as printed. When they're back, run ${WAIT_COMMAND}. Either way, don't retry the call and don't create another account.`,
   "4. Then make the call below."
 ];
 function nextSteps(model, needsCredits) {
   return [
     ...needsCredits ? CREDIT_STEPS : [],
-    model ? `Verify with one real completion: ${NPX} chat -m ${model} "Reply with OK" (or POST $ST_BASE_URL/chat/completions with that model)` : `No chat model is live in this region right now. Check again with: ${NPX} models --live`,
-    `Or let the router pick: ${NPX} chat -m auto "Reply with OK"`,
+    model ? `Verify with one real completion: ${NPX2} chat -m ${model} "Reply with OK" (or POST $ST_BASE_URL/chat/completions with that model)` : `No chat model is live in this region right now. Check again with: ${NPX2} models --live`,
+    `Or let the router pick: ${NPX2} chat -m auto "Reply with OK"`,
     "Use it from code: any OpenAI SDK with base_url=$ST_BASE_URL and api_key=$ST_API_KEY (both are in .env)",
-    `Optional, connect MCP: ${NPX} mcp`,
+    `Optional, connect MCP: ${NPX2} mcp`,
     ...needsCredits ? [] : [`More credits when needed: ${TOPUP_COMMAND} returns an approval_url for your human (inference is prepaid)`]
   ];
 }
@@ -9278,7 +9780,7 @@ async function liveSummary(ctx, region, balanceUsd) {
   return {
     balance_usd: balanceUsd ?? 0,
     needs_credits: needsCredits,
-    next_command: needsCredits ? TOPUP_COMMAND : `${NPX} chat -m ${suggested ?? "auto"} "Reply with OK"`,
+    next_command: needsCredits ? TOPUP_COMMAND : `${NPX2} chat -m ${suggested ?? "auto"} "Reply with OK"`,
     newest_models: live.slice(0, 5),
     suggested_model: suggested,
     next_steps: nextSteps(suggested, needsCredits)
@@ -9328,6 +9830,13 @@ async function init(ctx, opts) {
       ...ignored.length ? { warnings: [`${ignored.join(" and ")} apply only to a new account and were not sent.`] } : {}
     };
   }
+  if (opts.account && opts.newAccount)
+    throw new CliError("bad_argument", "Pass --account or --new-account, not both.");
+  if (!opts.newAccount) {
+    const reused = await reuseSavedAccount(ctx, { region: opts.region, account: opts.account });
+    if (reused)
+      return reused;
+  }
   const region = opts.region ?? "us";
   const attribution = signupAttribution(region, opts);
   const acct = await api(ctx, "POST", "/v1/accounts", {
@@ -9343,6 +9852,7 @@ async function init(ctx, opts) {
   });
   writeEnv(ctx.cwd, { ST_API_KEY: acct.api_key, ST_BASE_URL: acct.base_url });
   ensureGitignored(ctx.cwd);
+  const { saved, existingCode } = await afterNewAccount(ctx, { ...acct, name: opts.name }, { noSave: opts.noSave });
   const keyed = { ...ctx, env: { ...ctx.env, ST_API_KEY: acct.api_key } };
   const billing = await api(keyed, "GET", "/v1/billing").catch(() => null);
   return {
@@ -9351,6 +9861,11 @@ async function init(ctx, opts) {
     region: acct.region,
     base_url: acct.base_url,
     key_saved_to: ".env (ST_API_KEY, ST_BASE_URL)",
+    saved_to_credential_store: saved !== false,
+    ...saved ? {
+      credential_store: `${saved}: other folders on this machine reuse this account (init there makes a project key). Opt out with --no-save.`
+    } : {},
+    ...existingCode ? { existing_account_code: existingCode, existing_account_hint: existingAccountHint(existingCode) } : {},
     terms: termsOf(acct),
     ...attribution.source ? { source: acct.source ?? attribution.source } : {},
     ...await liveSummary(keyed, acct.region, balanceOf(billing)),
@@ -9358,26 +9873,26 @@ async function init(ctx, opts) {
   };
 }
 function writeEnv(cwd, vars) {
-  const f = join3(cwd, ".env");
+  const f = join5(cwd, ".env");
   const names = new Set(Object.keys(vars));
-  const kept = existsSync2(f) ? readFileSync3(f, "utf8").split(/\r?\n/).filter((l) => !names.has(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(l)?.[1] ?? "")) : [];
+  const kept = existsSync4(f) ? readFileSync5(f, "utf8").split(/\r?\n/).filter((l) => !names.has(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(l)?.[1] ?? "")) : [];
   while (kept.length && kept[kept.length - 1].trim() === "")
     kept.pop();
   const lines = [...kept, ...Object.entries(vars).map(([k, v]) => `${k}=${v}`)];
-  writeFileSync(f, `${lines.join(`
+  writeFileSync3(f, `${lines.join(`
 `)}
 `, { mode: 384 });
-  chmodSync(f, 384);
+  chmodSync3(f, 384);
 }
 function ensureGitignored(cwd) {
-  const gi = join3(cwd, ".gitignore");
-  const text = existsSync2(gi) ? readFileSync3(gi, "utf8") : "";
+  const gi = join5(cwd, ".gitignore");
+  const text = existsSync4(gi) ? readFileSync5(gi, "utf8") : "";
   if (/^\/?\.env\*?\s*$/m.test(text))
     return;
   const sep = text === "" || text.endsWith(`
 `) ? "" : `
 `;
-  writeFileSync(gi, `${text}${sep}.env
+  writeFileSync3(gi, `${text}${sep}.env
 `);
 }
 function isCatalogRow(m) {
@@ -9539,9 +10054,9 @@ async function chat(ctx, o) {
   };
 }
 var billingStatus = async (ctx) => withoutFreeFields(await api(ctx, "GET", "/v1/billing"));
-var TOPUP_LIMITS = { min_usd: 5, max_usd: 2000, daily_max_usd: 2000, auto_reload_monthly_max_usd: 1e4 };
+var TOPUP_LIMITS = { min_usd: 20, max_usd: 2000, daily_max_usd: 2000 };
 function checkTopupLimits(amountUsd, autoReload) {
-  const { min_usd, max_usd, daily_max_usd, auto_reload_monthly_max_usd } = TOPUP_LIMITS;
+  const { min_usd, max_usd, daily_max_usd } = TOPUP_LIMITS;
   const range = (flag, v, lo, hi) => {
     if (v < lo || v > hi)
       throw new CliError("bad_argument", `--${flag} must be between ${lo} and ${hi.toLocaleString("en-US")}, got ${v}.`, `Top-ups are $${min_usd} to $${max_usd.toLocaleString("en-US")} each, and at most $${daily_max_usd.toLocaleString("en-US")} per account per rolling 24 hours (auto-reloads included).`);
@@ -9550,19 +10065,22 @@ function checkTopupLimits(amountUsd, autoReload) {
   if (!autoReload)
     return;
   range("auto-reload-amount", autoReload.amount_usd, min_usd, max_usd);
-  range("auto-reload-below", autoReload.threshold_usd, 0.01, max_usd);
-  if (autoReload.monthly_limit_usd !== undefined)
-    range("auto-reload-monthly-max", autoReload.monthly_limit_usd, autoReload.amount_usd, auto_reload_monthly_max_usd);
+  range("auto-reload-below", autoReload.threshold_usd, 5, max_usd);
+  if (autoReload.monthly_limit_usd != null)
+    range("auto-reload-monthly-max", autoReload.monthly_limit_usd, autoReload.amount_usd, Number.POSITIVE_INFINITY);
 }
 var TOPUP_DONE = new Set(["paid", "expired", "failed", "canceled"]);
 function topupNextSteps(topupId, amountUsd, opened, autoReload) {
+  const wait = `${WAIT_COMMAND}${topupId ? ` ${topupId}` : ""}`;
   return [
-    ...opened ? ["The checkout page is already open in your human's browser: don't open it again or paste the link on its own."] : [],
-    `Give your human message_for_human now and end your turn there: it holds the approval_url exactly as printed (a one-time payment link; don't shorten or reformat it). They accept the Terms and the Credits & Refunds policy and pay $${amountUsd} by card; credits are added once the payment is confirmed. Nothing is charged without their approval. Don't run billing wait (or anything else that waits) before they have the link: they may not see your messages until your turn ends.`,
+    opened ? `The checkout page is already open in your human's browser: don't open it again. Tell them with message_for_human (it holds the approval_url in case it didn't open), then in the same turn run: ${wait}. It returns status "paid" with the balance as soon as they pay; on topup_pending run it again, for up to ${WAIT_PATIENCE_MIN} minutes in all. Don't wait for them to say they've paid. If it's still unpaid after that, end your turn with message_for_human.` : `Give your human message_for_human now and end your turn there: it holds the approval_url exactly as printed (a one-time payment link; don't shorten or reformat it). Don't run billing wait (or anything else that waits) before they have the link: they may not see your messages until your turn ends.`,
+    `On that page they accept the Terms and the Credits & Refunds policy and pay $${amountUsd} by card; credits are added once the payment is confirmed. Nothing is charged without their approval.`,
     ...autoReload ? [
       `Approving also saves the card for auto-reload: $${autoReload.amount_usd} whenever the balance drops below $${autoReload.threshold_usd}${autoReload.monthly_limit_usd ? `, at most $${autoReload.monthly_limit_usd} a month` : ""}.`
     ] : [],
-    `When they say they've paid: ${WAIT_COMMAND}${topupId ? ` ${topupId}` : ""} (returns status "paid" with the balance, at once if already paid; topup_pending means not yet: tell them, don't make a new link).`,
+    ...opened ? [] : [
+      `When they say they've paid: ${wait} (returns status "paid" with the balance, at once if already paid; topup_pending means not yet: tell them, don't make a new link).`
+    ],
     "Once paid, retry the call that returned 402. Don't create another top-up while this one is pending: the link stays valid until expires_at."
   ];
 }
@@ -9589,32 +10107,87 @@ async function billingTopup(ctx, o) {
   });
   const noOpen = o.noOpen || ctx.env.ST_NO_BROWSER === "1";
   const opened = !noOpen && !!created.approval_url && await (o.open ?? openInBrowser)(created.approval_url);
+  const existing = existingAccountCode(ctx.cwd);
+  const message = messageForHuman(created.approval_url, o.amountUsd, o.autoReload, opened);
   return {
     status: "pending",
     ...created,
     opened_in_browser: opened,
-    message_for_human: messageForHuman(created.approval_url, o.amountUsd, o.autoReload, opened),
+    message_for_human: message && existing ? `${message}
+
+${existingAccountHint(existing)}` : message,
     next_steps: topupNextSteps(created.topup_id, o.amountUsd, opened, o.autoReload)
   };
 }
+async function billingAutoReloadSetup(ctx, o = {}) {
+  const body = {
+    ...o.thresholdUsd !== undefined ? { threshold_usd: o.thresholdUsd } : {},
+    ...o.amountUsd !== undefined ? { amount_usd: o.amountUsd } : {}
+  };
+  const created = await api(ctx, "POST", "/v1/billing/auto-reload/setup", {
+    body
+  });
+  const noOpen = o.noOpen || ctx.env.ST_NO_BROWSER === "1";
+  const opened = !noOpen && !!created.approval_url && await (o.open ?? openInBrowser)(created.approval_url);
+  const wait = `${WAIT_COMMAND} ${created.topup_id}`;
+  return {
+    status: "pending",
+    ...created,
+    opened_in_browser: opened,
+    message_for_human: setupMessageForHuman(created.approval_url, created.auto_reload, opened),
+    next_steps: [
+      opened ? `The page is already open in your human's browser: don't open it again. Tell them with message_for_human, then in the same turn run: ${wait}. It returns status "paid" once the card is saved and auto-reload is on; on topup_pending run it again, for up to ${WAIT_PATIENCE_MIN} minutes in all.` : `Give your human message_for_human now and end your turn there: it holds the approval_url exactly as printed. When they're back, run: ${wait}.`,
+      "Nothing is charged now. `billing auto-reload off` turns it off without approval."
+    ]
+  };
+}
 function messageForHuman(approvalUrl, amountUsd, autoReload, opened = false) {
   if (!approvalUrl)
     return null;
-  const reload = autoReload ? ` It also turns on auto-reload: $${autoReload.amount_usd} whenever the balance drops below $${autoReload.threshold_usd}${autoReload.monthly_limit_usd ? `, at most $${autoReload.monthly_limit_usd} a month` : ""}.` : "";
+  const reload = autoReload ? `Auto-reload is pre-selected there: $${autoReload.amount_usd} whenever the balance drops below $${autoReload.threshold_usd}, so I don't stall when credits run low; untick it if you'd rather not.` : "I recommend turning on auto-reload there, so I don't stall when credits run low.";
+  const rest = `${reload} Then you accept the Terms of Service and the Credits & Refunds policy and pay by card. Nothing is charged until you approve, and we email you a receipt.`;
   if (opened)
-    return `To finish the setup, I've opened the ScaledThought checkout page in your browser to buy $${amountUsd} of prepaid credits (USD). If it didn't open, use this link:
+    return `To finish the setup, I've opened the ScaledThought funding page in your browser for $${amountUsd} of prepaid credits (USD); you can change the amount there. If it didn't open, use this link:
 
 ${approvalUrl}
 
-On that page you accept the Terms of Service and the Credits & Refunds policy and pay by card. Nothing is charged until you approve.${reload} Tell me when it's done and I'll continue.`;
-  return `To finish the setup, please buy $${amountUsd} of prepaid ScaledThought credits (USD) here:
+${rest} I'm watching for the payment and will carry on as soon as it goes through.`;
+  return `To finish the setup, please add $${amountUsd} of prepaid ScaledThought credits (USD) here (you can change the amount):
 
 ${approvalUrl}
 
-On that page you accept the Terms of Service and the Credits & Refunds policy and pay by card. Nothing is charged until you approve.${reload} Tell me when it's done and I'll continue.`;
+${rest} Tell me when it's done and I'll continue.`;
+}
+function setupMessageForHuman(approvalUrl, terms, opened = false) {
+  if (!approvalUrl)
+    return null;
+  const what = `turn on auto-reload: whenever the balance drops below $${terms.threshold_usd}, $${terms.amount_usd} of prepaid credits (USD) is added from a card you save, so I don't stall when credits run low. You can change those amounts on the page. Nothing is charged now, and I can turn it off any time.`;
+  if (opened)
+    return `I've opened a ScaledThought page in your browser to ${what} If it didn't open, use this link:
+
+${approvalUrl}
+
+I'm watching and will carry on as soon as it's set up.`;
+  return `Please use this ScaledThought page to ${what}
+
+${approvalUrl}
+
+Tell me when it's done and I'll continue.`;
 }
 var WAIT_DEFAULT_S = 90;
 async function billingWait(ctx, o = {}) {
+  try {
+    return await billingWaitOnce(ctx, o);
+  } catch (e) {
+    if (e instanceof CliError && ["invalid_api_key", "topup_canceled", "account_suspended"].includes(e.code)) {
+      const switched = await connectedExisting(ctx, { noSave: o.noSave });
+      if (switched)
+        return switched;
+    }
+    throw e;
+  }
+}
+async function billingWaitOnce(ctx, o) {
   let id = o.topupId;
   if (id !== undefined && !/^top_[0-9A-Za-z]+$/.test(id))
     throw new CliError("bad_argument", `"${id}" is not a top-up id (top_...).`, "Use topup_id from `billing topup`.");
@@ -9637,7 +10210,7 @@ async function billingWait(ctx, o = {}) {
     if (TOPUP_DONE.has(t.status ?? ""))
       throw new CliError(`topup_${t.status}`, t.status === "expired" ? `Top-up ${id} expired before it was paid.` : `Top-up ${id} was not paid (${t.status}${t.failure_code ? `: ${t.failure_code}` : ""}).`, `Run \`${TOPUP_COMMAND}\` again and show your human the new approval_url.`, { topup_id: id });
     if (Date.now() >= deadline)
-      throw new CliError("topup_pending", `Top-up ${id} isn't paid yet.`, `Not paid yet. If your human doesn't have the approval_url (below) yet, end your turn now and give it to them. Otherwise tell them it's still unpaid and run \`${WAIT_COMMAND} ${id}\` again once they say they've paid. Don't create a new top-up.`, { topup_id: id, approval_url: t.approval_url ?? null });
+      throw new CliError("topup_pending", `Top-up ${id} isn't paid yet.`, `Not paid yet. If the checkout page is open in your human's browser (billing topup printed opened_in_browser: true), run \`${WAIT_COMMAND} ${id}\` again right away, for up to ${WAIT_PATIENCE_MIN} minutes in all. If they don't have the approval_url (below), or it's still unpaid after that, end your turn and give it to them, then run it again when they're back. Don't create a new top-up.`, { topup_id: id, approval_url: t.approval_url ?? null });
     await new Promise((r) => setTimeout(r, o.pollMs ?? 3000));
   }
 }
@@ -9649,7 +10222,7 @@ async function billingTopupAndWait(ctx, o) {
   let t = created;
   while (!TOPUP_DONE.has(t.status ?? "")) {
     if (Date.now() > deadline)
-      throw new CliError("topup_wait_timeout", `Top-up ${id} is still ${t.status}.`, `The link may still work. Check later with: ${NPX} billing status`, { topup_id: id });
+      throw new CliError("topup_wait_timeout", `Top-up ${id} is still ${t.status}.`, `The link may still work. Check later with: ${NPX2} billing status`, { topup_id: id });
     await new Promise((r) => setTimeout(r, o.pollMs ?? 3000));
     t = await api(ctx, "GET", `/v1/billing/topups/${encodeURIComponent(id)}`);
   }
@@ -9660,7 +10233,7 @@ async function billingTopupAndWait(ctx, o) {
 var billingAutoReloadOff = (ctx) => api(ctx, "PATCH", "/v1/billing/auto-reload", { body: { enabled: false } });
 var billingTransactions = (ctx, o = {}) => api(ctx, "GET", `/v1/billing/transactions${o.cursor ? `?cursor=${encodeURIComponent(o.cursor)}` : ""}`);
 function billingUpgradeRemoved() {
-  throw new CliError("billing_upgrade_removed", "billing upgrade (monthly caps) was replaced by prepaid credits.", `Run \`${NPX} billing topup --amount-usd 5\` and send your human the approval_url. Optional auto-reload: add --auto-reload-below 2 --auto-reload-amount 10.`);
+  throw new CliError("billing_upgrade_removed", "billing upgrade (monthly caps) was replaced by prepaid credits.", `Run \`${NPX2} billing topup --amount-usd 20\` and send your human the approval_url. They can turn on auto-reload on the same page.`);
 }
 var benchmarks = (ctx, id, region) => api(ctx, "GET", `/v1/models/${encodeURIComponent(id)}/benchmarks`, {
   auth: false,
@@ -9669,10 +10242,10 @@ var benchmarks = (ctx, id, region) => api(ctx, "GET", `/v1/models/${encodeURICom
 async function uploadJsonl(ctx, path, purpose) {
   const { key, region } = resolveKey(ctx);
   const file = resolve2(ctx.cwd, path);
-  if (!existsSync2(file))
+  if (!existsSync4(file))
     throw new CliError("file_not_found", `No file at ${path}.`, "Pass the path to a .jsonl file.");
   const form = new FormData;
-  form.set("file", new Blob([readFileSync3(file)], { type: "application/jsonl" }), path.split("/").pop() ?? "data.jsonl");
+  form.set("file", new Blob([readFileSync5(file)], { type: "application/jsonl" }), path.split("/").pop() ?? "data.jsonl");
   form.set("purpose", purpose);
   const res = await ctx.fetch(`${controlUrl(region, ctx.env)}/v1/files`, {
     method: "POST",
@@ -9727,9 +10300,9 @@ var VIDEO_WAIT_MS = 30 * 60000;
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 function imageDataUrl(ctx, path) {
   const file = resolve2(ctx.cwd, path);
-  if (!existsSync2(file))
+  if (!existsSync4(file))
     throw new CliError("file_not_found", `No file at ${path}.`, "Pass the path to a PNG, JPEG or WebP image.");
-  const data = readFileSync3(file);
+  const data = readFileSync5(file);
   if (data.byteLength > 10 * 1024 * 1024)
     throw new CliError("input_reference_too_large", "Images are limited to 10 MiB.");
   const type = data[0] === 255 && data[1] === 216 ? "image/jpeg" : data[0] === 137 && data[1] === 80 ? "image/png" : data.subarray(8, 12).toString() === "WEBP" ? "image/webp" : null;
@@ -9765,7 +10338,7 @@ async function videoDownload(ctx, id, output, variant = "video") {
     throw await responseError(res);
   const data = Buffer.from(await res.arrayBuffer());
   const path = resolve2(ctx.cwd, output);
-  writeFileSync(path, data);
+  writeFileSync3(path, data);
   return {
     id,
     variant,
@@ -9870,9 +10443,23 @@ function mcpSetup(ctx) {
     openapi: `${controlUrl(region, ctx.env)}/openapi.json`
   };
 }
+var DASH_PAGES = ["overview", "billing", "keys", "members", "connect"];
+async function dashboardOpen(ctx, o = {}) {
+  if (o.page !== undefined && !DASH_PAGES.includes(o.page))
+    throw new CliError("bad_argument", `--page must be one of ${DASH_PAGES.join(", ")}.`, "e.g. --page billing");
+  const r = await api(ctx, "POST", "/v1/dashboard/link", { body: { ...o.page ? { page: o.page } : {}, ...o.email ? { email: o.email } : {} } });
+  const noOpen = o.noOpen || ctx.env.ST_NO_BROWSER === "1";
+  const opened = !noOpen && await (o.open ?? openInBrowser)(r.url);
+  return {
+    ...r,
+    opened_in_browser: opened,
+    message_for_human: opened ? r.message_for_human : r.message_for_human.replace("I've opened your ScaledThought dashboard.", `Your ScaledThought dashboard: ${r.url}`)
+  };
+}
+var membersList = (ctx) => api(ctx, "GET", "/v1/members");
 
 // src/decide.ts
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync6 } from "node:fs";
 import { resolve as resolve3 } from "node:path";
 var DEFAULT_DECISION_MODEL = "open-jev-27b";
 var usage2 = (msg) => new CliError("usage_error", msg, 'Example: --question urgent:noul:"Is this urgent?" (see decide --help)');
@@ -9944,7 +10531,7 @@ function readState(ctx, o) {
   if (o.stateFile !== undefined) {
     let text;
     try {
-      text = readFileSync4(resolve3(ctx.cwd, o.stateFile), "utf8");
+      text = readFileSync6(resolve3(ctx.cwd, o.stateFile), "utf8");
     } catch {
       throw usage2("--state-file could not be read.");
     }
@@ -9961,7 +10548,7 @@ function decisionRequest(ctx, o) {
       throw usage2("--file holds the whole request; don't combine it with --state or --question.");
     let body;
     try {
-      body = JSON.parse(readFileSync4(resolve3(ctx.cwd, o.file), "utf8"));
+      body = JSON.parse(readFileSync6(resolve3(ctx.cwd, o.file), "utf8"));
     } catch {
       throw usage2("--file must be a readable JSON file.");
     }
@@ -9995,7 +10582,7 @@ async function decide2(ctx, body) {
 }
 
 // src/realtime.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
 var SAMPLE_RATE = 24000;
 var MAX_INPUT_SECONDS = 300;
@@ -10060,7 +10647,7 @@ async function realtime(ctx, o) {
     throw new CliError("unsupported_runtime", "This command needs a WebSocket client (Node.js 22 or newer).", "Upgrade Node.js to 22+.");
   let pcm;
   try {
-    pcm = readWav(readFileSync5(resolve4(ctx.cwd, o.input)));
+    pcm = readWav(readFileSync7(resolve4(ctx.cwd, o.input)));
   } catch (e) {
     if (e instanceof CliError)
       throw e;
@@ -10152,7 +10739,7 @@ async function realtime(ctx, o) {
   });
   const audio = Buffer.concat(out);
   const path = resolve4(ctx.cwd, o.output);
-  writeFileSync2(path, wavOf(audio));
+  writeFileSync4(path, wavOf(audio));
   return {
     model: o.model,
     region,
@@ -10202,7 +10789,7 @@ function num(flag, v) {
 var init2 = defineCommand({
   meta: {
     name: "init",
-    description: "Create an account, save ST_API_KEY and ST_BASE_URL to ./.env, list live models and the next steps (a new account has no credits: top up first). Idempotent. " + "Creating an account accepts the Terms of Service (scaledthought.com/legal/terms) for the human you act for."
+    description: "Create an account, save ST_API_KEY and ST_BASE_URL to ./.env, list live models and the next steps (a new account has no credits: top up first). Idempotent. " + "Creating an account accepts nothing for your human: they accept the Terms themselves when they buy credits."
   },
   args: {
     ...jsonFlag,
@@ -10216,6 +10803,19 @@ var init2 = defineCommand({
     "ad-click": {
       type: "string",
       description: "Signed ad-click token, from a prompt ending in `(ad click <token>)` that a human copied on a US campaign's landing page (optional; us region only). Opt out later with `account ad-measurement off`"
+    },
+    account: {
+      type: "string",
+      description: "Use this account saved on this machine (id or name, from choose_account) with a new project key, instead of creating one"
+    },
+    "new-account": {
+      type: "boolean",
+      description: "Create a new account even when one is saved on this machine (separate billing)"
+    },
+    save: {
+      type: "boolean",
+      default: true,
+      description: "Save the account's key in this machine's credential store so other folders reuse it (--no-save to opt out)"
     }
   },
   run: ({ args }) => run(() => init(makeCtx(), {
@@ -10223,9 +10823,70 @@ var init2 = defineCommand({
     name: args.name,
     email: args.email,
     source: args.source,
-    adClick: args["ad-click"]
+    adClick: args["ad-click"],
+    account: args.account,
+    newAccount: args["new-account"],
+    noSave: args.save === false
   }), args)
 });
+var login2 = defineCommand({
+  meta: {
+    name: "login",
+    description: "Connect this folder to an existing account: prints a code your human types on the dashboard (opened in their browser). Then `login --wait` saves a new key to ./.env. `login --code XXXX-XXXX` uses a connect line from the dashboard"
+  },
+  args: {
+    ...jsonFlag,
+    region: { type: "string", description: "The account's region: us (default) or ca" },
+    open: { type: "boolean", default: true, description: "Open the connect page (--no-open only prints it)" },
+    label: { type: "string", description: 'How this agent is named to the human (default "<tool> on <hostname>")' },
+    wait: {
+      type: "boolean",
+      description: "Wait (about 90 s) for your human to approve the code, then save the key. Run again on authorization_pending"
+    },
+    code: {
+      type: "string",
+      description: "A connect line's code from the dashboard (stl_…): already approved, works once. `--code -` reads it from stdin"
+    },
+    force: { type: "boolean", description: "Replace the key already in ./.env" },
+    save: {
+      type: "boolean",
+      default: true,
+      description: "Save the key in this machine's credential store (--no-save to opt out)"
+    },
+    "timeout-s": { type: "string", description: "With --wait: seconds to wait (default 90, at most 600)" }
+  },
+  run: async ({ args }) => {
+    const ctx = makeCtx();
+    const noSave = args.save === false;
+    const t = args["timeout-s"] === undefined ? undefined : num("timeout-s", args["timeout-s"]);
+    if (t !== undefined && t > 600)
+      throw new CliError("bad_argument", `--timeout-s must be at most 600, got ${t}.`, "Run login --wait again.");
+    await run(async () => args.code ? loginWithCode(ctx, {
+      code: args.code === "-" ? await readCodeFrom(process.stdin) : args.code,
+      region: region(args.region),
+      label: args.label,
+      force: args.force,
+      noSave
+    }) : args.wait ? loginWait(ctx, { timeoutS: t, noSave, force: args.force }) : login(ctx, {
+      region: region(args.region),
+      label: args.label,
+      noOpen: args.open === false,
+      force: args.force,
+      noSave
+    }), args);
+  }
+});
+var use = defineCommand({
+  meta: {
+    name: "use",
+    description: "Point this folder at another account saved on this machine: a new project key in ./.env, and the folder's old project key revoked"
+  },
+  args: {
+    ...jsonFlag,
+    account: { type: "positional", required: true, description: "The account's name or id" }
+  },
+  run: ({ args }) => run(() => useAccount(makeCtx(), { target: args.account }), args)
+});
 var models = defineCommand({
   meta: { name: "models", description: "List models with prices and benchmarks, newest first; or show one" },
   args: {
@@ -10504,7 +11165,7 @@ function autoReloadArgs(args) {
   if (below === undefined && amount === undefined && max === undefined)
     return;
   if (below === undefined || amount === undefined)
-    throw new CliError("bad_argument", "Auto-reload needs both --auto-reload-below and --auto-reload-amount.", "e.g. --auto-reload-below 2 --auto-reload-amount 10 [--auto-reload-monthly-max 50]");
+    throw new CliError("bad_argument", "Auto-reload needs both --auto-reload-below and --auto-reload-amount.", "e.g. --auto-reload-below 5 --auto-reload-amount 10");
   return { threshold_usd: below, amount_usd: amount, ...max !== undefined ? { monthly_limit_usd: max } : {} };
 }
 var billing = defineCommand({
@@ -10521,20 +11182,22 @@ var billing = defineCommand({
     topup: defineCommand({
       meta: {
         name: "topup",
-        description: "Buy prepaid credits: opens the checkout page in your human's browser (approval_url), then run `billing wait`. Optional auto-reload"
+        description: "Buy prepaid credits: opens the funding page in your human's browser (approval_url), where they confirm the amount, can turn on auto-reload (recommended) and pay; then run `billing wait`, which returns once they pay"
       },
       args: {
         ...jsonFlag,
         "amount-usd": {
           type: "string",
-          required: true,
-          description: "Credits to buy in USD ($5 to $2,000; at most $2,000 per 24 h)"
+          description: "Credits to buy in USD (default 20; $20 to $2,000, at most $2,000 per 24 h). Your human can change it"
+        },
+        "auto-reload-below": {
+          type: "string",
+          description: "Suggest auto-reload (pre-selected on the page) when the balance drops below this (USD, at least 5)"
         },
-        "auto-reload-below": { type: "string", description: "Auto-reload when the balance drops below this (USD)" },
-        "auto-reload-amount": { type: "string", description: "Amount of each auto-reload (USD)" },
+        "auto-reload-amount": { type: "string", description: "Amount of each suggested auto-reload (USD)" },
         "auto-reload-monthly-max": {
           type: "string",
-          description: "Most auto-reload may charge per calendar month (USD, default 5x the amount)"
+          description: "Optional: most auto-reload may charge per calendar month (USD; default: no monthly limit)"
         },
         open: {
           type: "boolean",
@@ -10547,7 +11210,7 @@ var billing = defineCommand({
         }
       },
       run: async ({ args }) => {
-        const amountUsd = num("amount-usd", args["amount-usd"]);
+        const amountUsd = num("amount-usd", args["amount-usd"]) ?? 20;
         const autoReload = autoReloadArgs(args);
         checkTopupLimits(amountUsd, autoReload);
         const noOpen = args.open === false;
@@ -10575,8 +11238,35 @@ var billing = defineCommand({
       }
     }),
     "auto-reload": defineCommand({
-      meta: { name: "auto-reload", description: "Turn auto-reload off (turning it on or up needs a topup approval)" },
+      meta: {
+        name: "auto-reload",
+        description: "Turn auto-reload on (a link your human approves; nothing is bought) or off (no approval)"
+      },
       subCommands: {
+        setup: defineCommand({
+          meta: {
+            name: "setup",
+            description: "Opens a page in your human's browser where they save a card and turn auto-reload on, buying nothing; then run `billing wait`"
+          },
+          args: {
+            ...jsonFlag,
+            below: {
+              type: "string",
+              description: "Reload when the balance drops below this (USD, default and minimum 5)"
+            },
+            amount: { type: "string", description: "Credits each reload adds (USD, default 20)" },
+            open: {
+              type: "boolean",
+              default: true,
+              description: "Open the page in the browser (--no-open only prints approval_url)"
+            }
+          },
+          run: ({ args }) => run(() => billingAutoReloadSetup(makeCtx(), {
+            thresholdUsd: num("below", args.below),
+            amountUsd: num("amount", args.amount),
+            noOpen: args.open === false
+          }), args)
+        }),
         off: defineCommand({
           meta: { name: "off", description: "Disable auto-reload. No approval needed" },
           args: jsonFlag,
@@ -10802,6 +11492,31 @@ var mcp = defineCommand({
   args: jsonFlag,
   run: ({ args }) => run(() => mcpSetup(makeCtx()), args)
 });
+var dashboard = defineCommand({
+  meta: {
+    name: "dashboard",
+    description: "Open your human's ScaledThought dashboard (billing, keys, members, connect an agent) in their browser. No typing: if they're not signed in, one click emails them a link"
+  },
+  args: {
+    ...jsonFlag,
+    page: { type: "string", description: "overview (default), billing, keys, members or connect" },
+    email: {
+      type: "string",
+      description: "Set the owner's email (only before anyone has signed in; normally the first payer is the owner)"
+    },
+    open: { type: "boolean", default: true, description: "Open it in the browser (--no-open only prints the URL)" }
+  },
+  run: ({ args }) => run(() => dashboardOpen(makeCtx(), {
+    page: args.page,
+    email: args.email,
+    noOpen: args.open === false
+  }), args)
+});
+var members2 = defineCommand({
+  meta: { name: "members", description: "Who can sign in to this account's dashboard (email, role, status)" },
+  args: jsonFlag,
+  run: ({ args }) => run(() => membersList(makeCtx()), args)
+});
 var root = defineCommand({
   meta: {
     name: "scaledthought",
@@ -10810,6 +11525,8 @@ var root = defineCommand({
   },
   subCommands: {
     init: init2,
+    login: login2,
+    use,
     models,
     benchmarks: benchmarks2,
     status: status2,
@@ -10827,7 +11544,9 @@ var root = defineCommand({
     video,
     webhooks,
     doctor: doctor2,
-    mcp
+    mcp,
+    dashboard,
+    members: members2
   }
 });
 var NUMERIC_FLAGS = new Set([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scaledthought",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Headless open-model inference, run by your agent. Prepaid, pay per token. US or Canada.",
   "license": "MIT",
   "keywords": [