@tolkbot/cli 0.4.0 → 0.6.0

package/dist/index.js

@@ -559,7 +559,7 @@ var require_to_regex_range = __commonJS({
       let zipped = zip(start, stop);
       let digits = zipped.length;
       let pattern = "";
-      let count = 0;
+      let count2 = 0;
       for (let i = 0; i < digits; i++) {
         let [startDigit, stopDigit] = zipped[i];
         if (startDigit === stopDigit) {
@@ -567,13 +567,13 @@ var require_to_regex_range = __commonJS({
         } else if (startDigit !== "0" || stopDigit !== "9") {
           pattern += toCharacterClass(startDigit, stopDigit, options);
         } else {
-          count++;
+          count2++;
         }
       }
-      if (count) {
+      if (count2) {
         pattern += options.shorthand === true ? "\\d" : "[0-9]";
       }
-      return { pattern, count: [count], digits };
+      return { pattern, count: [count2], digits };
     }
     function splitToPatterns(min, max, tok, options) {
       let ranges = splitToRanges(min, max);
@@ -2320,13 +2320,13 @@ var require_parse2 = __commonJS({
         consume(token.value);
       };
       const negate = () => {
-        let count = 1;
+        let count2 = 1;
         while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
           advance();
           state.start++;
-          count++;
+          count2++;
         }
-        if (count % 2 === 0) {
+        if (count2 % 2 === 0) {
           return false;
         }
         state.negated = true;
@@ -5784,10 +5784,10 @@ var require_out4 = __commonJS({
 });
 
 // src/main.ts
-import { Command as Command7, CommanderError, Option } from "commander";
+import { Command as Command9, CommanderError, Option as Option2 } from "commander";
 
 // package.json
-var version = "0.4.0";
+var version = "0.6.0";
 
 // src/commands/auth/index.ts
 import { Command } from "commander";
@@ -6315,7 +6315,7 @@ import { ConvexHttpClient } from "convex/browser";
 var BACKEND_METHODS = /* @__PURE__ */ new Set(["query", "mutation", "action"]);
 var client = null;
 function getConvexClient() {
-  client ??= new ConvexHttpClient(requireConvexUrl());
+  client ??= new ConvexHttpClient(requireConvexUrl(), { logger: false });
   return client;
 }
 function translateAuthError(error62, resolved) {
@@ -8068,14 +8068,14 @@ function codePointLength(str) {
   const units = str.length;
   if (!highSurrogate.test(str))
     return units;
-  let count = units;
+  let count2 = units;
   for (let i = 0; i < units - 1; i++) {
     if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
-      count--;
+      count2--;
       i++;
     }
   }
-  return count;
+  return count2;
 }
 function getLengthableOrigin(input2) {
   if (Array.isArray(input2))
@@ -12432,8 +12432,8 @@ function az_default() {
     localeError: error2()
   };
 }
-function getBelarusianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getBelarusianPlural(count2, one, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -15038,8 +15038,8 @@ function hu_default() {
     localeError: error23()
   };
 }
-function getArmenianPlural(count, one, many) {
-  return Math.abs(count) === 1 ? one : many;
+function getArmenianPlural(count2, one, many) {
+  return Math.abs(count2) === 1 ? one : many;
 }
 function withDefiniteArticle(word) {
   if (!word)
@@ -17731,8 +17731,8 @@ function ro_default() {
     localeError: error45()
   };
 }
-function getRussianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getRussianPlural(count2, one, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -26823,6 +26823,75 @@ var SUPPORTED_LOCALES = [
   "eu",
   "gl"
 ];
+var LOCALE_NAMES = {
+  en: "English",
+  "en-us": "English (US)",
+  "en-gb": "English (UK)",
+  "en-au": "English (Australia)",
+  "en-ca": "English (Canada)",
+  es: "Spanish",
+  "es-es": "Spanish (Spain)",
+  "es-mx": "Spanish (Mexico)",
+  "es-ar": "Spanish (Argentina)",
+  pt: "Portuguese",
+  "pt-br": "Portuguese (Brazil)",
+  "pt-pt": "Portuguese (Portugal)",
+  zh: "Chinese",
+  "zh-cn": "Chinese (Simplified)",
+  "zh-tw": "Chinese (Traditional)",
+  "zh-hk": "Chinese (Hong Kong)",
+  fr: "French",
+  "fr-fr": "French (France)",
+  "fr-ca": "French (Canada)",
+  de: "German",
+  "de-de": "German (Germany)",
+  "de-at": "German (Austria)",
+  "de-ch": "German (Switzerland)",
+  no: "Norwegian",
+  nb: "Norwegian Bokm\xE5l",
+  nn: "Norwegian Nynorsk",
+  sv: "Swedish",
+  da: "Danish",
+  fi: "Finnish",
+  is: "Icelandic",
+  it: "Italian",
+  nl: "Dutch",
+  "nl-be": "Dutch (Belgium)",
+  pl: "Polish",
+  cs: "Czech",
+  sk: "Slovak",
+  hu: "Hungarian",
+  ro: "Romanian",
+  bg: "Bulgarian",
+  hr: "Croatian",
+  sl: "Slovenian",
+  sr: "Serbian",
+  uk: "Ukrainian",
+  el: "Greek",
+  tr: "Turkish",
+  ru: "Russian",
+  ja: "Japanese",
+  ko: "Korean",
+  th: "Thai",
+  vi: "Vietnamese",
+  id: "Indonesian",
+  ms: "Malay",
+  tl: "Tagalog",
+  hi: "Hindi",
+  bn: "Bengali",
+  ta: "Tamil",
+  ar: "Arabic",
+  he: "Hebrew",
+  fa: "Persian",
+  af: "Afrikaans",
+  sw: "Swahili",
+  et: "Estonian",
+  lv: "Latvian",
+  lt: "Lithuanian",
+  ca: "Catalan",
+  eu: "Basque",
+  gl: "Galician"
+};
 var DEFAULT_BEHAVIORAL_SETTINGS = {
   tonePreset: "formal",
   toneInstructions: "Use a formal, professional tone. Avoid slang.",
@@ -27354,6 +27423,7 @@ var analyticsEventNames = [
   "glossary_imported",
   "translation_job_viewed",
   "translation_logs_viewed",
+  "activity_timeline_viewed",
   "cli_login_completed",
   "cli_command_completed",
   "cli_init_completed",
@@ -28316,6 +28386,16 @@ async function loadPlanContext(cwd) {
     framework: config3.config.framework
   };
 }
+async function readCreditBalance(ctx) {
+  try {
+    const balance = await ctx.client.query(api.usage.getCreditBalance, {
+      organizationId: ctx.project.organizationId
+    });
+    return balance?.total ?? null;
+  } catch {
+    return null;
+  }
+}
 function describePlan(plan) {
   const { summary } = plan;
   const lines = [
@@ -28331,9 +28411,9 @@ function describeLeftOut(plan) {
   const lines = [];
   const protectedCount = plan.protectedKeys.length;
   if (protectedCount > 0) {
-    const reasons = Object.entries(summary.protected).map(([reason, n]) => `${n} ${reason}`).join(", ");
+    const reasons2 = Object.entries(summary.protected).map(([reason, n]) => `${n} ${reason}`).join(", ");
     lines.push(
-      `${protectedCount} changed but kept for a person (${reasons})`
+      `${protectedCount} changed but kept for a person (${reasons2})`
     );
   }
   if (summary.held > 0)
@@ -28551,11 +28631,11 @@ function flattenValues(data) {
   const values = /* @__PURE__ */ new Map();
   function walk(obj, prefix) {
     for (const [key, value] of Object.entries(obj)) {
-      const fullKey5 = prefix ? `${prefix}.${key}` : key;
+      const fullKey6 = prefix ? `${prefix}.${key}` : key;
       if (typeof value === "string") {
-        values.set(fullKey5, value);
+        values.set(fullKey6, value);
       } else if (typeof value === "object" && value !== null) {
-        walk(value, fullKey5);
+        walk(value, fullKey6);
       }
     }
   }
@@ -31310,6 +31390,13 @@ var BILLING_BLOCKED = "BILLING_BLOCKED";
 
 // ../shared/src/projects/localeSetup.ts
 var LOCALE_SETUP_STALE_MS = 15 * 60 * 1e3;
+function localeSetupState(row, now) {
+  if (!row) return "not-set-up";
+  if (row.status === "onboarded") return "set-up";
+  if (row.onboardingError !== void 0) return "failed";
+  if (row.onboardingRequestedAt === void 0) return "not-set-up";
+  return now - row.onboardingRequestedAt > LOCALE_SETUP_STALE_MS ? "failed" : "running";
+}
 
 // ../shared/src/projects/index.ts
 var PROJECT_ARCHIVED = "PROJECT_ARCHIVED";
@@ -31343,6 +31430,7 @@ var ERROR_CODES = {
   login_failed: EXIT_CODES.failure,
   // 2: usage
   usage: EXIT_CODES.usage,
+  unsupported_locale: EXIT_CODES.usage,
   // 3: not authenticated, or not allowed
   not_authenticated: EXIT_CODES.auth,
   token_expired: EXIT_CODES.auth,
@@ -31665,24 +31753,377 @@ jobsCommand.command("cancel").description("Cancel a running translation job").ar
   await runJobsCancel(validateOrExit(schema, { ...opts, jobId }));
 });
 
-// src/commands/learnings/index.ts
-import { Command as Command4 } from "commander";
+// src/commands/languages/index.ts
+import { Command as Command4, Option } from "commander";
 import { z as z6 } from "zod/v4";
 
-// src/commands/learnings/archive.tsx
+// src/commands/languages/add.tsx
 import { Spinner as Spinner9 } from "@inkjs/ui";
-import { Box as Box12, render as render12, Text as Text12 } from "ink";
+import { Box as Box12, Text as Text12 } from "ink";
+
+// src/commands/languages/languages-core.ts
+var DEFAULT_EXISTING_MODE = "trust";
+var MAX_SUGGESTIONS = 6;
+function editDistance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j++) {
+      current[j] = Math.min(
+        (previous[j] ?? 0) + 1,
+        (current[j - 1] ?? 0) + 1,
+        (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+    }
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+function closestLocales(input2) {
+  const typed = input2.trim().toLowerCase().replace(/_/g, "-");
+  const language = typed.split("-")[0] ?? "";
+  const found = /* @__PURE__ */ new Set();
+  for (const locale of SUPPORTED_LOCALES) {
+    if (locale.split("-")[0] === language) found.add(locale);
+  }
+  if (typed.length >= 3) {
+    for (const locale of SUPPORTED_LOCALES) {
+      if (LOCALE_NAMES[locale].toLowerCase().includes(typed))
+        found.add(locale);
+    }
+  }
+  for (const locale of SUPPORTED_LOCALES) {
+    if (editDistance(locale, typed) === 1) found.add(locale);
+  }
+  return [...found].slice(0, MAX_SUGGESTIONS);
+}
+function resolveLocales(inputs) {
+  const resolved = [];
+  const unsupported = [];
+  for (const input2 of inputs) {
+    const locale = canonicalGlossaryLocale(input2.trim());
+    if (!locale) {
+      unsupported.push(input2);
+      continue;
+    }
+    if (!resolved.includes(locale)) resolved.push(locale);
+  }
+  if (unsupported.length === 0) return resolved;
+  const lines = unsupported.map((input2) => {
+    const close = closestLocales(input2);
+    return close.length > 0 ? `For ${input2}, the closest supported codes are ${close.join(", ")}.` : `Nothing supported is close to ${input2}.`;
+  });
+  const anyWithout = unsupported.some((i) => closestLocales(i).length === 0);
+  if (anyWithout) {
+    lines.push(`Supported codes: ${SUPPORTED_LOCALES.join(", ")}.`);
+  }
+  throw new CliError(
+    `TolkBot does not support ${unsupported.join(", ")}.`,
+    lines.join(" "),
+    "unsupported_locale"
+  );
+}
+function planAdd(project, rows, locales, now) {
+  const base = locales.find((l) => sameLocale(l, project.baseLanguage));
+  if (base) {
+    throw new UsageError(
+      `${base} is the project's base language, so it cannot be added as a target.`,
+      "Name a language to translate into."
+    );
+  }
+  return locales.map((locale) => {
+    const onProject = project.targetLanguages.some(
+      (t) => sameLocale(t, locale)
+    );
+    if (!onProject)
+      return { locale, action: "add", setup: "not-on-project" };
+    const row = rows.find((r) => sameLocale(r.locale, locale));
+    const setup = localeSetupState(row, now);
+    const action = setup === "set-up" || setup === "running" ? "none" : "set_up";
+    return { locale, action, setup };
+  });
+}
+function targetsAfter(project, plan) {
+  return [
+    ...project.targetLanguages,
+    ...plan.filter((p) => p.action === "add").map((p) => p.locale)
+  ];
+}
+function localeName(locale) {
+  return LOCALE_NAMES[locale] ?? locale;
+}
+function describeOutcome(outcome) {
+  const name = `${outcome.locale} (${localeName(outcome.locale)})`;
+  switch (outcome.outcome) {
+    case "added":
+      return `\u2713 ${name} added and set up.`;
+    case "set_up":
+      return `\u2713 ${name} was on the project; now set up.`;
+    case "unchanged":
+      return outcome.setup === "running" ? `- ${name} is already on the project and being set up.` : `- ${name} is already on the project.`;
+    case "failed":
+      return `\u2717 ${name} is on the project, but setting it up failed: ${outcome.error}`;
+  }
+}
+function describeNextSteps(ready, autoCreatePR) {
+  if (ready.length === 0) return [];
+  const lines = [
+    "Next, fill the files now:",
+    ...ready.map((l) => `  ${translateCommand(l)}`)
+  ];
+  if (autoCreatePR) {
+    lines.push(
+      "Or wait: pull requests are on for this project, so the next push that changes the base file opens one per language, with the keys that push added or changed."
+    );
+  }
+  return lines;
+}
+function translateCommand(locale) {
+  return `tolkbot translate --dst ${locale}`;
+}
+
+// src/commands/languages/add.tsx
 import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+async function runLanguagesAdd(opts) {
+  const locales = resolveLocales(opts.locales);
+  const ctx = await loadPlanContext(process.cwd());
+  const { project } = ctx;
+  const ids = {
+    organizationId: project.organizationId,
+    projectId: project._id
+  };
+  const rows = await ctx.client.query(api.projectLocales.list, ids);
+  const plan = planAdd(project, rows, locales, Date.now());
+  const outcomes = [];
+  const progress = renderTransient(
+    /* @__PURE__ */ jsxs12(Box12, { children: [
+      /* @__PURE__ */ jsx12(Spinner9, {}),
+      /* @__PURE__ */ jsxs12(Text12, { children: [
+        " ",
+        "Adding ",
+        locales.join(", "),
+        " to ",
+        project.name,
+        "\u2026"
+      ] })
+    ] })
+  );
+  try {
+    if (plan.some((p) => p.action === "add")) {
+      await ctx.client.mutation(api.projects.update, {
+        ...ids,
+        patch: {
+          targetLanguages: targetsAfter(project, plan)
+        }
+      });
+    }
+    const client3 = await getAuthenticatedConvexClient();
+    for (const { locale, action, setup } of plan) {
+      if (action === "none") {
+        outcomes.push({
+          locale,
+          outcome: "unchanged",
+          setup: setup === "running" ? "running" : "set-up"
+        });
+        continue;
+      }
+      try {
+        await client3.action(api.actions.onboardLocale.onboardLocale, {
+          ...ids,
+          locale,
+          mode: opts.existing
+        });
+        outcomes.push({
+          locale,
+          outcome: action === "add" ? "added" : "set_up"
+        });
+      } catch (error62) {
+        outcomes.push({
+          locale,
+          outcome: "failed",
+          error: toCliError(error62).baseMessage
+        });
+      }
+    }
+  } finally {
+    progress.unmount();
+  }
+  const ready = outcomes.filter((o) => o.outcome === "added" || o.outcome === "set_up").map((o) => o.locale);
+  const autoCreatePR = project.workflow?.autoCreatePR ?? DEFAULT_BEHAVIORAL_SETTINGS.workflow.autoCreatePR;
+  const failed = outcomes.filter((o) => o.outcome === "failed");
+  const payload = {
+    project: { name: project.name, slug: project.slug },
+    existing: opts.existing,
+    changed: ready.length > 0 || plan.some((p) => p.action === "add"),
+    languages: outcomes,
+    targetLanguages: targetsAfter(project, plan),
+    next: {
+      translate: ready.map(translateCommand),
+      pullRequestOnPush: autoCreatePR
+    }
+  };
+  const failure2 = failed.length > 0 ? new CliError(
+    `Setting up ${failed.map((o) => o.locale).join(", ")} failed.`,
+    "Run the same command again to retry, or set it up from the project's Translations page."
+  ) : null;
+  if (opts.json) {
+    if (!failure2) jsonSuccess(payload);
+    jsonResult(payload, 1);
+    fail(failure2);
+  }
+  for (const outcome of outcomes) console.log(describeOutcome(outcome));
+  if (!payload.changed) console.log("Nothing changed.");
+  const next = describeNextSteps(ready, autoCreatePR);
+  if (next.length > 0) {
+    console.log("");
+    for (const line of next) console.log(line);
+  }
+  if (failure2) fail(failure2);
+}
+
+// src/commands/languages/list.ts
+var SETUP_WORDS = {
+  "set-up": "set up",
+  running: "being set up",
+  failed: "setup failed",
+  "not-set-up": "not set up"
+};
+async function runLanguagesList(opts) {
+  const ctx = await loadPlanContext(process.cwd());
+  const { project } = ctx;
+  const rows = await ctx.client.query(api.projectLocales.list, {
+    organizationId: project.organizationId,
+    projectId: project._id
+  });
+  const scope = scopeOf(project);
+  const files = await listLocaleFiles(ctx.root, scope);
+  const sourceFiles = filesForLocale(files, project.baseLanguage);
+  const found = (file2) => ({
+    path: file2.relativePath,
+    exists: true
+  });
+  const fromPattern = (locale) => {
+    const existing = filesForLocale(files, locale);
+    if (existing.length > 0) return existing.map(found);
+    return [
+      {
+        path: replaceLocalePlaceholder(fullPattern(scope), locale),
+        exists: false
+      }
+    ];
+  };
+  const base = {
+    locale: project.baseLanguage,
+    name: localeName(project.baseLanguage),
+    files: fromPattern(project.baseLanguage)
+  };
+  const now = Date.now();
+  const targets = project.targetLanguages.map((locale) => ({
+    locale,
+    name: localeName(locale),
+    setup: localeSetupState(
+      rows.find((r) => sameLocale(r.locale, locale)),
+      now
+    ),
+    files: sourceFiles.length === 0 ? fromPattern(locale) : sourceFiles.map((source) => {
+      const target = targetFileFor(
+        source,
+        locale,
+        files,
+        scope
+      );
+      return {
+        path: target.relativePath,
+        exists: target.existing !== null
+      };
+    })
+  }));
+  if (opts.json) {
+    jsonSuccess({
+      project: { name: project.name, slug: project.slug },
+      pattern: fullPattern(scope),
+      base,
+      targets
+    });
+  }
+  console.log(
+    `${project.name} (${project.slug}), files ${fullPattern(scope)}`
+  );
+  console.log("");
+  const printFiles = (language) => {
+    for (const file2 of language.files) {
+      console.log(
+        `    ${file2.path}${file2.exists ? "" : " (no file yet)"}`
+      );
+    }
+  };
+  console.log(`${base.locale} (${base.name}), base language`);
+  printFiles(base);
+  for (const target of targets) {
+    console.log(
+      `${target.locale} (${target.name}), ${SETUP_WORDS[target.setup]}`
+    );
+    printFiles(target);
+  }
+  if (targets.length === 0) {
+    console.log("");
+    console.log(
+      "No target languages yet. Add one with 'tolkbot languages add <code>'."
+    );
+  }
+}
+
+// src/commands/languages/index.ts
+var languagesCommand = new Command4("languages").description(
+  "List the project's languages and add target languages"
+);
+var JSON_HELP2 = "Output as JSON (machine-readable)";
+languagesCommand.command("list").description(
+  "The base language and the target languages, with the files each one maps to and whether they exist"
+).option("--json", JSON_HELP2).action(async (opts) => {
+  const schema = z6.object({ json: z6.boolean().optional() });
+  await runLanguagesList(validateOrExit(schema, opts));
+});
+languagesCommand.command("add").description(
+  "Add target languages to the project and set them up, as the dashboard's Add language dialog does. Translating is 'tolkbot translate'"
+).argument("<locales...>", "Locale codes, e.g. nb de pt-BR").addOption(
+  new Option(
+    "--existing <mode>",
+    "What to do with translations the repository already has: keep them as written by a person (trust), or flag them for review"
+  ).choices(["trust", "review"]).default(DEFAULT_EXISTING_MODE)
+).option("--json", JSON_HELP2).addHelpText(
+  "after",
+  `
+Examples:
+  $ tolkbot languages add nb
+  $ tolkbot languages add de fr --existing review`
+).action(async (locales, opts) => {
+  const schema = z6.object({
+    locales: z6.array(z6.string().min(1)).min(1),
+    existing: z6.enum(["trust", "review"]),
+    json: z6.boolean().optional()
+  });
+  await runLanguagesAdd(validateOrExit(schema, { ...opts, locales }));
+});
+
+// src/commands/learnings/index.ts
+import { Command as Command5 } from "commander";
+import { z as z7 } from "zod/v4";
+
+// src/commands/learnings/archive.tsx
+import { Spinner as Spinner10 } from "@inkjs/ui";
+import { Box as Box13, render as render12, Text as Text13 } from "ink";
+import { jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
 function ArchiveUI({ state }) {
   if (state.type === "archiving") {
-    return /* @__PURE__ */ jsxs12(Box12, { children: [
-      /* @__PURE__ */ jsx12(Spinner9, {}),
-      /* @__PURE__ */ jsx12(Text12, { children: " Archiving learning\u2026" })
+    return /* @__PURE__ */ jsxs13(Box13, { children: [
+      /* @__PURE__ */ jsx13(Spinner10, {}),
+      /* @__PURE__ */ jsx13(Text13, { children: " Archiving learning\u2026" })
     ] });
   }
-  return /* @__PURE__ */ jsxs12(Box12, { children: [
-    /* @__PURE__ */ jsx12(Text12, { color: "green", children: "\u2713" }),
-    /* @__PURE__ */ jsx12(Text12, { children: " Learning archived" })
+  return /* @__PURE__ */ jsxs13(Box13, { children: [
+    /* @__PURE__ */ jsx13(Text13, { color: "green", children: "\u2713" }),
+    /* @__PURE__ */ jsx13(Text13, { children: " Learning archived" })
   ] });
 }
 async function runLearningsArchive(opts) {
@@ -31699,20 +32140,20 @@ async function runLearningsArchive(opts) {
     jsonSuccess({ id: opts.id, ok: true });
   }
   const { unmount } = renderTransient(
-    /* @__PURE__ */ jsx12(ArchiveUI, { state: { type: "archiving" } })
+    /* @__PURE__ */ jsx13(ArchiveUI, { state: { type: "archiving" } })
   );
   try {
     await run();
   } finally {
     unmount();
   }
-  render12(/* @__PURE__ */ jsx12(ArchiveUI, { state: { type: "success" } })).unmount();
+  render12(/* @__PURE__ */ jsx13(ArchiveUI, { state: { type: "success" } })).unmount();
 }
 
 // src/commands/learnings/list.tsx
-import { Spinner as Spinner10 } from "@inkjs/ui";
-import { Box as Box13, render as render13, Text as Text13 } from "ink";
-import { jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
+import { Spinner as Spinner11 } from "@inkjs/ui";
+import { Box as Box14, render as render13, Text as Text14 } from "ink";
+import { jsx as jsx14, jsxs as jsxs14 } from "react/jsx-runtime";
 var feedbackLabels = {
   "incorrect-term": "Incorrect term",
   "wrong-tone": "Wrong tone",
@@ -31722,47 +32163,47 @@ var feedbackLabels = {
 };
 function LearningsListUI({ state }) {
   if (state.type === "loading") {
-    return /* @__PURE__ */ jsxs13(Box13, { children: [
-      /* @__PURE__ */ jsx13(Spinner10, {}),
-      /* @__PURE__ */ jsx13(Text13, { children: " Loading learnings\u2026" })
+    return /* @__PURE__ */ jsxs14(Box14, { children: [
+      /* @__PURE__ */ jsx14(Spinner11, {}),
+      /* @__PURE__ */ jsx14(Text14, { children: " Loading learnings\u2026" })
     ] });
   }
   const { learnings } = state;
   if (learnings.length === 0) {
-    return /* @__PURE__ */ jsx13(Box13, { children: /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "No learnings found." }) });
+    return /* @__PURE__ */ jsx14(Box14, { children: /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: "No learnings found." }) });
   }
-  return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx13(Box13, { marginBottom: 1, children: /* @__PURE__ */ jsxs13(Text13, { bold: true, children: [
+  return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx14(Box14, { marginBottom: 1, children: /* @__PURE__ */ jsxs14(Text14, { bold: true, children: [
       learnings.length,
       " learning",
       learnings.length === 1 ? "" : "s"
     ] }) }),
-    learnings.map((l) => /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsxs13(Box13, { gap: 1, children: [
-        /* @__PURE__ */ jsxs13(Text13, { bold: true, children: [
+    learnings.map((l) => /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs14(Box14, { gap: 1, children: [
+        /* @__PURE__ */ jsxs14(Text14, { bold: true, children: [
           l.srcLocale,
           " \u2192 ",
           l.dstLocale
         ] }),
-        /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+        /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
           "[",
           feedbackLabels[l.feedbackType] ?? l.feedbackType,
           "]"
         ] }),
-        l.status === "archived" && /* @__PURE__ */ jsx13(Text13, { color: "yellow", children: "[archived]" })
+        l.status === "archived" && /* @__PURE__ */ jsx14(Text14, { color: "yellow", children: "[archived]" })
       ] }),
-      /* @__PURE__ */ jsx13(Box13, { paddingLeft: 2, children: /* @__PURE__ */ jsxs13(Text13, { children: [
+      /* @__PURE__ */ jsx14(Box14, { paddingLeft: 2, children: /* @__PURE__ */ jsxs14(Text14, { children: [
         '"',
         l.sourceText,
         '" \u2192 "',
         l.suggestedTranslation,
         '"'
       ] }) }),
-      l.reasoning && /* @__PURE__ */ jsx13(Box13, { paddingLeft: 2, children: /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+      l.reasoning && /* @__PURE__ */ jsx14(Box14, { paddingLeft: 2, children: /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
         "Reason: ",
         l.reasoning
       ] }) }),
-      /* @__PURE__ */ jsx13(Box13, { paddingLeft: 2, children: /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+      /* @__PURE__ */ jsx14(Box14, { paddingLeft: 2, children: /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
         "ID: ",
         l._id
       ] }) })
@@ -31797,7 +32238,7 @@ async function runLearningsList(opts) {
     });
   }
   const { unmount } = renderTransient(
-    /* @__PURE__ */ jsx13(LearningsListUI, { state: { type: "loading" } })
+    /* @__PURE__ */ jsx14(LearningsListUI, { state: { type: "loading" } })
   );
   let learnings;
   try {
@@ -31806,24 +32247,24 @@ async function runLearningsList(opts) {
     unmount();
   }
   render13(
-    /* @__PURE__ */ jsx13(LearningsListUI, { state: { type: "success", learnings } })
+    /* @__PURE__ */ jsx14(LearningsListUI, { state: { type: "success", learnings } })
   ).unmount();
 }
 
 // src/commands/learnings/remove.tsx
-import { Spinner as Spinner11 } from "@inkjs/ui";
-import { Box as Box14, render as render14, Text as Text14 } from "ink";
-import { jsx as jsx14, jsxs as jsxs14 } from "react/jsx-runtime";
+import { Spinner as Spinner12 } from "@inkjs/ui";
+import { Box as Box15, render as render14, Text as Text15 } from "ink";
+import { jsx as jsx15, jsxs as jsxs15 } from "react/jsx-runtime";
 function RemoveUI2({ state }) {
   if (state.type === "removing") {
-    return /* @__PURE__ */ jsxs14(Box14, { children: [
-      /* @__PURE__ */ jsx14(Spinner11, {}),
-      /* @__PURE__ */ jsx14(Text14, { children: " Removing learning\u2026" })
+    return /* @__PURE__ */ jsxs15(Box15, { children: [
+      /* @__PURE__ */ jsx15(Spinner12, {}),
+      /* @__PURE__ */ jsx15(Text15, { children: " Removing learning\u2026" })
     ] });
   }
-  return /* @__PURE__ */ jsxs14(Box14, { children: [
-    /* @__PURE__ */ jsx14(Text14, { color: "green", children: "\u2713" }),
-    /* @__PURE__ */ jsx14(Text14, { children: " Learning removed" })
+  return /* @__PURE__ */ jsxs15(Box15, { children: [
+    /* @__PURE__ */ jsx15(Text15, { color: "green", children: "\u2713" }),
+    /* @__PURE__ */ jsx15(Text15, { children: " Learning removed" })
   ] });
 }
 async function runLearningsRemove(opts) {
@@ -31840,62 +32281,62 @@ async function runLearningsRemove(opts) {
     jsonSuccess({ id: opts.id, ok: true });
   }
   const { unmount } = renderTransient(
-    /* @__PURE__ */ jsx14(RemoveUI2, { state: { type: "removing" } })
+    /* @__PURE__ */ jsx15(RemoveUI2, { state: { type: "removing" } })
   );
   try {
     await run();
   } finally {
     unmount();
   }
-  render14(/* @__PURE__ */ jsx14(RemoveUI2, { state: { type: "success" } })).unmount();
+  render14(/* @__PURE__ */ jsx15(RemoveUI2, { state: { type: "success" } })).unmount();
 }
 
 // src/commands/learnings/show.tsx
-import { Spinner as Spinner12 } from "@inkjs/ui";
-import { Box as Box15, render as render15, Text as Text15 } from "ink";
-import { jsx as jsx15, jsxs as jsxs15 } from "react/jsx-runtime";
+import { Spinner as Spinner13 } from "@inkjs/ui";
+import { Box as Box16, render as render15, Text as Text16 } from "ink";
+import { jsx as jsx16, jsxs as jsxs16 } from "react/jsx-runtime";
 function LearningShowUI({ state }) {
   if (state.type === "loading") {
-    return /* @__PURE__ */ jsxs15(Box15, { children: [
-      /* @__PURE__ */ jsx15(Spinner12, {}),
-      /* @__PURE__ */ jsx15(Text15, { children: " Loading learning\u2026" })
+    return /* @__PURE__ */ jsxs16(Box16, { children: [
+      /* @__PURE__ */ jsx16(Spinner13, {}),
+      /* @__PURE__ */ jsx16(Text16, { children: " Loading learning\u2026" })
     ] });
   }
   const { learning } = state;
-  return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs15(Box15, { gap: 1, children: [
-      /* @__PURE__ */ jsx15(Text15, { bold: true, children: "Source text:" }),
-      /* @__PURE__ */ jsx15(Text15, { children: learning.sourceText })
+  return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs16(Box16, { gap: 1, children: [
+      /* @__PURE__ */ jsx16(Text16, { bold: true, children: "Source text:" }),
+      /* @__PURE__ */ jsx16(Text16, { children: learning.sourceText })
     ] }),
-    /* @__PURE__ */ jsxs15(Box15, { gap: 1, children: [
-      /* @__PURE__ */ jsx15(Text15, { bold: true, children: "Suggested translation:" }),
-      /* @__PURE__ */ jsx15(Text15, { children: learning.suggestedTranslation })
+    /* @__PURE__ */ jsxs16(Box16, { gap: 1, children: [
+      /* @__PURE__ */ jsx16(Text16, { bold: true, children: "Suggested translation:" }),
+      /* @__PURE__ */ jsx16(Text16, { children: learning.suggestedTranslation })
     ] }),
-    /* @__PURE__ */ jsxs15(Box15, { gap: 1, children: [
-      /* @__PURE__ */ jsx15(Text15, { bold: true, children: "Locales:" }),
-      /* @__PURE__ */ jsxs15(Text15, { children: [
+    /* @__PURE__ */ jsxs16(Box16, { gap: 1, children: [
+      /* @__PURE__ */ jsx16(Text16, { bold: true, children: "Locales:" }),
+      /* @__PURE__ */ jsxs16(Text16, { children: [
         learning.srcLocale,
         " \u2192 ",
         learning.dstLocale
       ] })
     ] }),
-    /* @__PURE__ */ jsxs15(Box15, { gap: 1, children: [
-      /* @__PURE__ */ jsx15(Text15, { bold: true, children: "Feedback type:" }),
-      /* @__PURE__ */ jsx15(Text15, { children: learning.feedbackType })
+    /* @__PURE__ */ jsxs16(Box16, { gap: 1, children: [
+      /* @__PURE__ */ jsx16(Text16, { bold: true, children: "Feedback type:" }),
+      /* @__PURE__ */ jsx16(Text16, { children: learning.feedbackType })
     ] }),
-    /* @__PURE__ */ jsxs15(Box15, { gap: 1, children: [
-      /* @__PURE__ */ jsx15(Text15, { bold: true, children: "Reasoning:" }),
-      /* @__PURE__ */ jsx15(Text15, { children: learning.reasoning })
+    /* @__PURE__ */ jsxs16(Box16, { gap: 1, children: [
+      /* @__PURE__ */ jsx16(Text16, { bold: true, children: "Reasoning:" }),
+      /* @__PURE__ */ jsx16(Text16, { children: learning.reasoning })
     ] }),
-    /* @__PURE__ */ jsxs15(Box15, { gap: 1, children: [
-      /* @__PURE__ */ jsx15(Text15, { bold: true, children: "Status:" }),
-      /* @__PURE__ */ jsx15(Text15, { color: learning.status === "active" ? "green" : "yellow", children: learning.status })
+    /* @__PURE__ */ jsxs16(Box16, { gap: 1, children: [
+      /* @__PURE__ */ jsx16(Text16, { bold: true, children: "Status:" }),
+      /* @__PURE__ */ jsx16(Text16, { color: learning.status === "active" ? "green" : "yellow", children: learning.status })
     ] }),
-    /* @__PURE__ */ jsxs15(Box15, { gap: 1, children: [
-      /* @__PURE__ */ jsx15(Text15, { bold: true, children: "Source:" }),
-      /* @__PURE__ */ jsx15(Text15, { children: learning.source })
+    /* @__PURE__ */ jsxs16(Box16, { gap: 1, children: [
+      /* @__PURE__ */ jsx16(Text16, { bold: true, children: "Source:" }),
+      /* @__PURE__ */ jsx16(Text16, { children: learning.source })
     ] }),
-    /* @__PURE__ */ jsx15(Box15, { marginTop: 1, children: /* @__PURE__ */ jsxs15(Text15, { dimColor: true, children: [
+    /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsxs16(Text16, { dimColor: true, children: [
       "ID: ",
       learning._id
     ] }) })
@@ -31933,7 +32374,7 @@ async function runLearningsShow(opts) {
     });
   }
   const { unmount } = renderTransient(
-    /* @__PURE__ */ jsx15(LearningShowUI, { state: { type: "loading" } })
+    /* @__PURE__ */ jsx16(LearningShowUI, { state: { type: "loading" } })
   );
   let learning;
   try {
@@ -31941,50 +32382,287 @@ async function runLearningsShow(opts) {
   } finally {
     unmount();
   }
-  render15(/* @__PURE__ */ jsx15(LearningShowUI, { state: { type: "success", learning } })).unmount();
+  render15(/* @__PURE__ */ jsx16(LearningShowUI, { state: { type: "success", learning } })).unmount();
 }
 
 // src/commands/learnings/index.ts
-var learningsCommand = new Command4("learnings").description(
+var learningsCommand = new Command5("learnings").description(
   "View and manage translation learnings"
 );
 learningsCommand.command("list").description("List translation learnings for the current project").option("--status <status>", "Filter by status (active or archived)").option("--limit <n>", "Max number of results", (v) => Number(v), 100).option("--json", "Output as JSON (machine-readable)").action(async (opts) => {
-  const schema = z6.object({
-    status: z6.enum(["active", "archived"]).optional(),
-    limit: z6.coerce.number().int().positive().default(100),
-    json: z6.boolean().optional()
+  const schema = z7.object({
+    status: z7.enum(["active", "archived"]).optional(),
+    limit: z7.coerce.number().int().positive().default(100),
+    json: z7.boolean().optional()
   });
   const parsed = validateOrExit(schema, opts);
   await runLearningsList(parsed);
 });
 learningsCommand.command("show").description("Show details of a learning").requiredOption("--id <learningId>", "Learning ID").option("--json", "Output as JSON (machine-readable)").action(async (opts) => {
-  const schema = z6.object({
-    id: z6.string().min(1),
-    json: z6.boolean().optional()
+  const schema = z7.object({
+    id: z7.string().min(1),
+    json: z7.boolean().optional()
   });
   const parsed = validateOrExit(schema, opts);
   await runLearningsShow(parsed);
 });
 learningsCommand.command("archive").description("Archive a learning (keeps it but excludes from translations)").requiredOption("--id <learningId>", "Learning ID").option("--json", "Output as JSON (machine-readable)").action(async (opts) => {
-  const schema = z6.object({
-    id: z6.string().min(1),
-    json: z6.boolean().optional()
+  const schema = z7.object({
+    id: z7.string().min(1),
+    json: z7.boolean().optional()
   });
   const parsed = validateOrExit(schema, opts);
   await runLearningsArchive(parsed);
 });
 learningsCommand.command("remove").description("Permanently remove a learning").requiredOption("--id <learningId>", "Learning ID").option("--json", "Output as JSON (machine-readable)").action(async (opts) => {
-  const schema = z6.object({
-    id: z6.string().min(1),
-    json: z6.boolean().optional()
+  const schema = z7.object({
+    id: z7.string().min(1),
+    json: z7.boolean().optional()
   });
   const parsed = validateOrExit(schema, opts);
   await runLearningsRemove(parsed);
 });
 
+// src/commands/status/index.ts
+import { Command as Command6 } from "commander";
+import { z as z8 } from "zod/v4";
+
+// src/commands/status/status.tsx
+import { Spinner as Spinner14 } from "@inkjs/ui";
+import { Box as Box17, Text as Text17 } from "ink";
+
+// src/commands/status/status-core.ts
+function fullKey4(namespace, key) {
+  return namespace ? `${namespace}.${key}` : key;
+}
+function isPersonHold(reason) {
+  return reason === "locked" || reason === "pending-draft";
+}
+function count(reasons2) {
+  const byReason = {};
+  for (const reason of reasons2)
+    byReason[reason] = (byReason[reason] ?? 0) + 1;
+  return { total: reasons2.length, byReason };
+}
+function openPullRequest(rows, locale) {
+  const row = rows.find(
+    (r) => r.prState === "open" && r.prUrl !== void 0 && sameLocale(r.targetLanguage, locale)
+  );
+  if (!row?.prUrl) return null;
+  return { number: row.prNumber ?? null, url: row.prUrl };
+}
+function languageStatus(locale, plan, pullRequests, opts = {}) {
+  const { summary } = plan;
+  const held = [
+    ...plan.heldKeys,
+    ...plan.protectedKeys.flatMap(
+      ({ key, reason }) => isPersonHold(reason) ? [{ key, reason }] : []
+    )
+  ];
+  const kept = plan.protectedKeys.flatMap(
+    ({ key, reason }) => isPersonHold(reason) ? [] : [{ key, reason }]
+  );
+  const tasks = (reason) => plan.tasks.filter((t) => t.reason === reason).map((t) => fullKey4(t.namespace, t.key));
+  return {
+    locale,
+    expected: summary.totalKeys,
+    upToDate: summary.upToDate,
+    missing: summary.missing,
+    changed: summary.changed,
+    heldByPerson: count(held.map((h) => h.reason)),
+    keptForPerson: count(kept.map((k) => k.reason)),
+    untracked: summary.untracked,
+    pullRequest: openPullRequest(pullRequests, locale),
+    ...opts.keys ? {
+      keys: {
+        missing: tasks("missing"),
+        changed: tasks("changed"),
+        heldByPerson: held,
+        keptForPerson: kept,
+        untracked: plan.untrackedKeys.map((k) => k.key)
+      }
+    } : {}
+  };
+}
+function needsTranslation(language) {
+  return language.missing > 0 || language.changed > 0;
+}
+var REASON_WORDS = {
+  locked: "locked",
+  "pending-draft": "pending draft",
+  manual: "written by a person",
+  "target-edited": "edited since TolkBot wrote it",
+  unknown: "no record of who wrote it"
+};
+function reasons(counts) {
+  return Object.entries(counts.byReason).map(
+    ([reason, n]) => `${n} ${REASON_WORDS[reason]}`
+  ).join(", ");
+}
+function describeLanguage(language) {
+  const counts = [
+    `${language.expected} expected`,
+    `${language.upToDate} up to date`,
+    `${language.missing} missing`,
+    `${language.changed} changed since translated`
+  ].join(", ");
+  const mark = needsTranslation(language) ? "\u2022" : "\u2713";
+  const lines = [`${mark} ${language.locale}: ${counts}`];
+  if (language.heldByPerson.total > 0) {
+    lines.push(
+      `    ${language.heldByPerson.total} held by a person (${reasons(language.heldByPerson)})`
+    );
+  }
+  if (language.keptForPerson.total > 0) {
+    lines.push(
+      `    ${language.keptForPerson.total} changed but kept for a person (${reasons(language.keptForPerson)})`
+    );
+  }
+  if (language.untracked > 0) {
+    lines.push(
+      `    ${language.untracked} untracked: TolkBot has no record of them`
+    );
+  }
+  if (language.pullRequest) {
+    lines.push(`    Pull request: ${language.pullRequest.url}`);
+  }
+  const { keys } = language;
+  if (keys) {
+    const list = (label, names) => {
+      if (names.length === 0) return;
+      lines.push(`    ${label}:`);
+      for (const name of names) lines.push(`      ${name}`);
+    };
+    list("Missing", keys.missing);
+    list("Changed", keys.changed);
+    list(
+      "Held by a person",
+      keys.heldByPerson.map(
+        (k) => `${k.key} (${REASON_WORDS[k.reason]})`
+      )
+    );
+    list(
+      "Kept for a person",
+      keys.keptForPerson.map(
+        (k) => `${k.key} (${REASON_WORDS[k.reason]})`
+      )
+    );
+    list("Untracked", keys.untracked);
+  }
+  return lines;
+}
+
+// src/commands/status/status.tsx
+import { jsx as jsx17, jsxs as jsxs17 } from "react/jsx-runtime";
+var OFFLINE_HINT = "Without a login, 'tolkbot validate' checks the files on this machine.";
+async function runStatus(opts) {
+  let ctx;
+  try {
+    ctx = await loadPlanContext(process.cwd());
+  } catch (error62) {
+    if (error62 instanceof AuthError) {
+      throw new AuthError(
+        error62.baseMessage,
+        [error62.hint, OFFLINE_HINT].filter(Boolean).join(" "),
+        error62.code
+      );
+    }
+    throw error62;
+  }
+  const { project } = ctx;
+  const srcLocale = project.baseLanguage;
+  const locales = project.targetLanguages;
+  const progress = renderTransient(
+    /* @__PURE__ */ jsxs17(Box17, { children: [
+      /* @__PURE__ */ jsx17(Spinner14, {}),
+      /* @__PURE__ */ jsxs17(Text17, { children: [
+        " Reading the status of ",
+        project.name,
+        "\u2026"
+      ] })
+    ] })
+  );
+  const languages = [];
+  let credits;
+  try {
+    const pullRequests = locales.length === 0 ? [] : await ctx.client.query(api.prJobs.listByProject, {
+      organizationId: project.organizationId,
+      projectId: project._id
+    });
+    for (const locale of locales) {
+      const plan = await planForLocale(ctx, srcLocale, locale);
+      languages.push(
+        languageStatus(locale, plan, pullRequests, {
+          keys: opts.keys
+        })
+      );
+    }
+    credits = await readCreditBalance(ctx);
+  } finally {
+    progress.unmount();
+  }
+  const payload = {
+    project: {
+      name: project.name,
+      slug: project.slug,
+      url: `${env.TOLKBOT_WEB_URL}/projects/${project.slug}`,
+      baseLanguage: srcLocale,
+      pattern: fullPattern(scopeOf(project)),
+      autoCreatePR: project.workflow?.autoCreatePR ?? DEFAULT_BEHAVIORAL_SETTINGS.workflow.autoCreatePR
+    },
+    credits: { balance: credits },
+    languages
+  };
+  const outOfDate = languages.some(needsTranslation);
+  const exitCode = opts.exitCode && outOfDate ? 1 : 0;
+  if (opts.json) {
+    if (exitCode === 0) jsonSuccess(payload);
+    jsonResult(payload, exitCode);
+    return;
+  }
+  const { project: p } = payload;
+  console.log(`${p.name} (${p.slug}) ${p.url}`);
+  console.log(
+    `Base language ${p.baseLanguage}, files ${p.pattern}, auto-create pull requests ${p.autoCreatePR ? "on" : "off"}`
+  );
+  console.log(
+    credits === null ? "Credits left: could not be read" : `Credits left: ${credits}`
+  );
+  console.log("");
+  if (languages.length === 0) {
+    console.log(
+      `No target languages configured. Add them in the project settings at ${p.url}/settings.`
+    );
+  }
+  for (const language of languages) {
+    for (const line of describeLanguage(language)) console.log(line);
+  }
+  if (outOfDate) {
+    console.log(
+      "\nRun 'tolkbot translate --all' to translate what is missing or changed."
+    );
+  }
+  process.exitCode = exitCode;
+}
+
+// src/commands/status/index.ts
+var statusCommand = new Command6("status").description(
+  "Show what each language is missing, what waits for a person, the open pull requests and the credits left"
+).option("--keys", "List the keys by name under each language").option(
+  "--exit-code",
+  "Exit 1 when any language has missing or changed keys"
+).option("--json", "Output as JSON (machine-readable)").action(async (opts) => {
+  const schema = z8.object({
+    keys: z8.boolean().optional(),
+    exitCode: z8.boolean().optional(),
+    json: z8.boolean().optional()
+  });
+  await runStatus(validateOrExit(schema, opts));
+});
+
 // src/commands/telemetry.ts
-import { Command as Command5 } from "commander";
-import { z as z7 } from "zod/v4";
+import { Command as Command7 } from "commander";
+import { z as z9 } from "zod/v4";
 var REASONS = {
   env: `disabled by $${TELEMETRY_ENV_VAR}`,
   "do-not-track": `disabled by $${DO_NOT_TRACK_ENV_VAR}`,
@@ -32005,12 +32683,12 @@ async function printStatus(json2) {
     `Turn it off with \`tolkbot telemetry off\`, $${TELEMETRY_ENV_VAR}=0 or $${DO_NOT_TRACK_ENV_VAR}=1.`
   );
 }
-var telemetryCommand = new Command5("telemetry").description(
+var telemetryCommand = new Command7("telemetry").description(
   "Control anonymous usage reporting"
 );
 telemetryCommand.command("status", { isDefault: true }).description("Show whether telemetry is on and why").option("--json", "Output as JSON (machine-readable)").action(async (opts) => {
   const parsed = validateOrExit(
-    z7.object({ json: z7.boolean().optional() }),
+    z9.object({ json: z9.boolean().optional() }),
     opts
   );
   await printStatus(parsed.json);
@@ -32027,8 +32705,8 @@ telemetryCommand.command("on").description("Resume reporting usage from this mac
 });
 
 // src/commands/translate/index.ts
-import { Command as Command6 } from "commander";
-import { z as z8 } from "zod/v4";
+import { Command as Command8 } from "commander";
+import { z as z10 } from "zod/v4";
 
 // src/commands/translate/adopt.tsx
 var STAMP_CHUNK2 = 200;
@@ -32078,7 +32756,7 @@ async function runAdopt(opts) {
     if (locales.length === 0) {
       throw opts.all ? new CliError(
         "No target languages configured for this project.",
-        void 0,
+        "Add one with 'tolkbot languages add <code>'.",
         "no_target_languages"
       ) : new UsageError(
         "Either --dst <locale> or --all must be provided."
@@ -32109,8 +32787,8 @@ async function runAdopt(opts) {
 
 // src/commands/translate/edit.tsx
 import path10 from "path";
-import { Spinner as Spinner13 } from "@inkjs/ui";
-import { Box as Box16, render as render16, Text as Text16 } from "ink";
+import { Spinner as Spinner15 } from "@inkjs/ui";
+import { Box as Box18, render as render16, Text as Text18 } from "ink";
 
 // src/utils/locale-files.ts
 import path9 from "path";
@@ -32148,25 +32826,25 @@ function resolveKeyInFile(key, targetFile, fileCount, namespace) {
 }
 
 // src/commands/translate/edit.tsx
-import { jsx as jsx16, jsxs as jsxs16 } from "react/jsx-runtime";
+import { jsx as jsx18, jsxs as jsxs18 } from "react/jsx-runtime";
 function EditUI({ state }) {
   if (state.type === "editing") {
-    return /* @__PURE__ */ jsxs16(Box16, { children: [
-      /* @__PURE__ */ jsx16(Spinner13, {}),
-      /* @__PURE__ */ jsx16(Text16, { children: " Editing translation\u2026" })
+    return /* @__PURE__ */ jsxs18(Box18, { children: [
+      /* @__PURE__ */ jsx18(Spinner15, {}),
+      /* @__PURE__ */ jsx18(Text18, { children: " Editing translation\u2026" })
     ] });
   }
-  return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs16(Box16, { children: [
-      /* @__PURE__ */ jsx16(Text16, { color: "green", children: "\u2713" }),
-      /* @__PURE__ */ jsxs16(Text16, { children: [
+  return /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs18(Box18, { children: [
+      /* @__PURE__ */ jsx18(Text18, { color: "green", children: "\u2713" }),
+      /* @__PURE__ */ jsxs18(Text18, { children: [
         " ",
         "Updated ",
-        /* @__PURE__ */ jsx16(Text16, { bold: true, children: state.key })
+        /* @__PURE__ */ jsx18(Text18, { bold: true, children: state.key })
       ] })
     ] }),
-    /* @__PURE__ */ jsx16(Box16, { paddingLeft: 2, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: state.value }) }),
-    /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsxs16(Text16, { dimColor: true, children: [
+    /* @__PURE__ */ jsx18(Box18, { paddingLeft: 2, children: /* @__PURE__ */ jsx18(Text18, { dimColor: true, children: state.value }) }),
+    /* @__PURE__ */ jsx18(Box18, { marginTop: 1, children: /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
       "File: ",
       state.filePath
     ] }) })
@@ -32223,20 +32901,20 @@ async function runEdit(opts) {
       value: result2.value
     });
   }
-  const { unmount } = renderTransient(/* @__PURE__ */ jsx16(EditUI, { state: { type: "editing" } }));
+  const { unmount } = renderTransient(/* @__PURE__ */ jsx18(EditUI, { state: { type: "editing" } }));
   let result;
   try {
     result = await performEdit(opts);
   } finally {
     unmount();
   }
-  render16(/* @__PURE__ */ jsx16(EditUI, { state: { type: "success", ...result } })).unmount();
+  render16(/* @__PURE__ */ jsx18(EditUI, { state: { type: "success", ...result } })).unmount();
 }
 
 // src/commands/translate/translate.tsx
-import { Spinner as Spinner14 } from "@inkjs/ui";
-import { Box as Box17, Text as Text17 } from "ink";
-import { jsx as jsx17, jsxs as jsxs17 } from "react/jsx-runtime";
+import { Spinner as Spinner16 } from "@inkjs/ui";
+import { Box as Box19, Text as Text19 } from "ink";
+import { jsx as jsx19, jsxs as jsxs19 } from "react/jsx-runtime";
 function planOutput(plan) {
   return {
     ...plan.summary,
@@ -32245,7 +32923,7 @@ function planOutput(plan) {
     untrackedKeys: plan.untrackedKeys.map((k) => k.key)
   };
 }
-function fullKey4(namespace, key) {
+function fullKey5(namespace, key) {
   return namespace ? `${namespace}.${key}` : key;
 }
 function characters(text) {
@@ -32257,7 +32935,7 @@ function targetLocales(ctx, opts) {
   if (locales.length === 0) {
     throw new CliError(
       "No target languages configured.",
-      `Configure them in the project settings at ${env.TOLKBOT_WEB_URL}/projects/${ctx.project.slug}/settings.`,
+      "Add one with 'tolkbot languages add <code>'.",
       "no_target_languages"
     );
   }
@@ -32273,21 +32951,11 @@ async function runTranslate(opts) {
   }
   await runLanguages(ctx, srcLocale, dstLocales, opts);
 }
-async function creditBalance(ctx) {
-  try {
-    const balance = await ctx.client.query(api.usage.getCreditBalance, {
-      organizationId: ctx.project.organizationId
-    });
-    return balance?.total ?? null;
-  } catch {
-    return null;
-  }
-}
 var NO_ESTIMATE = "No credit estimate exists for this project yet. Keys and characters are what a run would send.";
 async function runDryRun(ctx, srcLocale, dstLocales, opts) {
   const languages = [];
   const progress = renderTransient(
-    /* @__PURE__ */ jsx17(Working, { text: `Planning ${dstLocales.join(", ")}\u2026` })
+    /* @__PURE__ */ jsx19(Working, { text: `Planning ${dstLocales.join(", ")}\u2026` })
   );
   try {
     for (const dstLocale of dstLocales) {
@@ -32302,7 +32970,7 @@ async function runDryRun(ctx, srcLocale, dstLocales, opts) {
           0
         ),
         tasks: plan.tasks.map((task) => ({
-          key: fullKey4(task.namespace, task.key),
+          key: fullKey5(task.namespace, task.key),
           path: task.path,
           reason: task.reason,
           ...opts.verbose ? { src: task.src } : {}
@@ -32317,7 +32985,7 @@ async function runDryRun(ctx, srcLocale, dstLocales, opts) {
     keys: languages.reduce((n, l) => n + l.keys, 0),
     characters: languages.reduce((n, l) => n + l.characters, 0)
   };
-  const balance = await creditBalance(ctx);
+  const balance = await readCreditBalance(ctx);
   track("cli_translate_completed", {
     mode: "plan",
     key_count: total.keys,
@@ -32365,9 +33033,9 @@ In all: ${total.keys} key(s), ${total.characters} characters.` + (balance === nu
   console.log("Nothing was started. Run without --dry-run to translate.");
 }
 function Working({ text }) {
-  return /* @__PURE__ */ jsxs17(Box17, { children: [
-    /* @__PURE__ */ jsx17(Spinner14, {}),
-    /* @__PURE__ */ jsxs17(Text17, { children: [
+  return /* @__PURE__ */ jsxs19(Box19, { children: [
+    /* @__PURE__ */ jsx19(Spinner16, {}),
+    /* @__PURE__ */ jsxs19(Text19, { children: [
       " ",
       text
     ] })
@@ -32378,7 +33046,7 @@ function progressText(dstLocale, summary) {
   const done = summary.completed + summary.failed;
   return `${dstLocale}: translating ${done}/${summary.total}\u2026`;
 }
-function describeOutcome(outcome) {
+function describeOutcome2(outcome) {
   const { dstLocale, status, keys, written } = outcome;
   const wrote = written ? `, ${written.keys} written to ${written.files} file(s)` : "";
   const notApplied = outcome.notApplied.length > 0 ? `, ${outcome.notApplied.length} not applied` : "";
@@ -32413,14 +33081,14 @@ async function runLanguages(ctx, srcLocale, dstLocales, opts) {
   const report = (outcome) => {
     outcomes.push(outcome);
     if (json2) return;
-    console.log(describeOutcome(outcome));
+    console.log(describeOutcome2(outcome));
     for (const line of describeNotApplied(outcome.notApplied)) {
       console.log(`  ${line}`);
     }
   };
   for (const dstLocale of dstLocales) {
     const progress = renderTransient(
-      /* @__PURE__ */ jsx17(Working, { text: `${dstLocale}: planning\u2026` })
+      /* @__PURE__ */ jsx19(Working, { text: `${dstLocale}: planning\u2026` })
     );
     try {
       const { tasks, plan } = await generateTasks(
@@ -32453,7 +33121,7 @@ async function runLanguages(ctx, srcLocale, dstLocales, opts) {
         printNotes(json2, leftOut);
         continue;
       }
-      progress.rerender(/* @__PURE__ */ jsx17(Working, { text: progressText(dstLocale, null) }));
+      progress.rerender(/* @__PURE__ */ jsx19(Working, { text: progressText(dstLocale, null) }));
       let jobId;
       try {
         jobId = await startTranslationJob({
@@ -32490,7 +33158,7 @@ async function runLanguages(ctx, srcLocale, dstLocales, opts) {
           project.organizationId,
           jobId,
           (latest) => progress.rerender(
-            /* @__PURE__ */ jsx17(Working, { text: progressText(dstLocale, latest) })
+            /* @__PURE__ */ jsx19(Working, { text: progressText(dstLocale, latest) })
           )
         );
       } catch (error62) {
@@ -32515,7 +33183,7 @@ async function runLanguages(ctx, srcLocale, dstLocales, opts) {
       };
       if (summary.status !== "cancelled") {
         progress.rerender(
-          /* @__PURE__ */ jsx17(Working, { text: `${dstLocale}: writing the files\u2026` })
+          /* @__PURE__ */ jsx19(Working, { text: `${dstLocale}: writing the files\u2026` })
         );
         const applied = await applyJob(ctx, jobId);
         finished.written = { files: applied.files, keys: applied.keys };
@@ -32579,7 +33247,7 @@ function checkTranslateOptions(opts) {
 
 // src/commands/translate/index.ts
 var RETRANSLATE_UNTRACKED_HELP = "Also retranslate translations TolkBot has no record of (kept by default)";
-var translateCommand = new Command6("translate").description(
+var translateCommand2 = new Command8("translate").description(
   "Translate what is missing or changed, and write the results into your locale files"
 ).option(
   "--src <locale>",
@@ -32595,31 +33263,31 @@ var translateCommand = new Command6("translate").description(
       "Run 'tolkbot translate --help'. Jobs are under 'tolkbot jobs'."
     );
   }
-  const schema = z8.object({
-    src: z8.string().min(1).optional(),
-    dst: z8.string().min(1).optional(),
-    all: z8.boolean().optional(),
-    dryRun: z8.boolean().optional(),
-    wait: z8.boolean(),
-    retranslateUntracked: z8.boolean().optional(),
-    verbose: z8.boolean().optional(),
-    json: z8.boolean().optional()
+  const schema = z10.object({
+    src: z10.string().min(1).optional(),
+    dst: z10.string().min(1).optional(),
+    all: z10.boolean().optional(),
+    dryRun: z10.boolean().optional(),
+    wait: z10.boolean(),
+    retranslateUntracked: z10.boolean().optional(),
+    verbose: z10.boolean().optional(),
+    json: z10.boolean().optional()
   });
   const parsed = validateOrExit(schema, opts);
   checkTranslateOptions(parsed);
   await runTranslate(parsed);
 });
-translateCommand.command("adopt").description(
+translateCommand2.command("adopt").description(
   "Record existing translations TolkBot has no baseline for as reviewed, so they are kept until their source changes"
 ).option(
   "--src <locale>",
   "Source locale (defaults to the project's base language)"
 ).option("--dst <locale>", "Destination locale").option("--all", "Every target language").option("--json", "Output as JSON (machine-readable)").action(async (opts) => {
-  const schema = z8.object({
-    src: z8.string().min(1).optional(),
-    dst: z8.string().min(1).optional(),
-    all: z8.boolean().optional(),
-    json: z8.boolean().optional()
+  const schema = z10.object({
+    src: z10.string().min(1).optional(),
+    dst: z10.string().min(1).optional(),
+    all: z10.boolean().optional(),
+    json: z10.boolean().optional()
   });
   const parsed = validateOrExit(schema, opts);
   if (parsed.dst && parsed.all) {
@@ -32627,20 +33295,20 @@ translateCommand.command("adopt").description(
   }
   await runAdopt(parsed);
 });
-translateCommand.command("edit").description("Edit a translation value in a locale file").requiredOption("--key <key>", "Translation key (e.g. common.hello)").requiredOption("--locale <locale>", "Target locale (e.g. fr, de)").requiredOption("--value <text>", "New translation value").option("--namespace <ns>", "Namespace to resolve file (if ambiguous)").option("--json", "Output as JSON (machine-readable)").action(async (opts) => {
-  const schema = z8.object({
-    key: z8.string().min(1),
-    locale: z8.string().min(1),
-    value: z8.string().min(1),
-    namespace: z8.string().optional(),
-    json: z8.boolean().optional()
+translateCommand2.command("edit").description("Edit a translation value in a locale file").requiredOption("--key <key>", "Translation key (e.g. common.hello)").requiredOption("--locale <locale>", "Target locale (e.g. fr, de)").requiredOption("--value <text>", "New translation value").option("--namespace <ns>", "Namespace to resolve file (if ambiguous)").option("--json", "Output as JSON (machine-readable)").action(async (opts) => {
+  const schema = z10.object({
+    key: z10.string().min(1),
+    locale: z10.string().min(1),
+    value: z10.string().min(1),
+    namespace: z10.string().optional(),
+    json: z10.boolean().optional()
   });
   const parsed = validateOrExit(schema, opts);
   await runEdit(parsed);
 });
 
 // src/commands/validate.tsx
-import { Box as Box18, render as render17, Text as Text18 } from "ink";
+import { Box as Box20, render as render17, Text as Text20 } from "ink";
 
 // ../ai/src/validators/placeholders.ts
 var IDENTIFIER = /^[A-Za-z0-9_$][A-Za-z0-9_$.[\]-]*$/;
@@ -33733,7 +34401,7 @@ function finalize2(issues, stats, strict) {
 }
 
 // src/commands/validate.tsx
-import { jsx as jsx18, jsxs as jsxs18 } from "react/jsx-runtime";
+import { jsx as jsx20, jsxs as jsxs20 } from "react/jsx-runtime";
 var LEVEL_COLOR = {
   error: "red",
   warning: "yellow",
@@ -33742,12 +34410,12 @@ var LEVEL_COLOR = {
 var GUTTER = 9;
 function IssueLine({ issue: issue2 }) {
   const location = [issue2.file, issue2.key].filter(Boolean).join(" \xB7 ");
-  return /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs18(Box18, { children: [
-      /* @__PURE__ */ jsx18(Box18, { width: GUTTER, flexShrink: 0, children: /* @__PURE__ */ jsx18(Text18, { color: LEVEL_COLOR[issue2.level], children: issue2.level }) }),
-      /* @__PURE__ */ jsx18(Box18, { flexGrow: 1, children: /* @__PURE__ */ jsx18(Text18, { children: issue2.message }) })
+  return /* @__PURE__ */ jsxs20(Box20, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs20(Box20, { children: [
+      /* @__PURE__ */ jsx20(Box20, { width: GUTTER, flexShrink: 0, children: /* @__PURE__ */ jsx20(Text20, { color: LEVEL_COLOR[issue2.level], children: issue2.level }) }),
+      /* @__PURE__ */ jsx20(Box20, { flexGrow: 1, children: /* @__PURE__ */ jsx20(Text20, { children: issue2.message }) })
     ] }),
-    /* @__PURE__ */ jsx18(Box18, { marginLeft: GUTTER, children: /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+    /* @__PURE__ */ jsx20(Box20, { marginLeft: GUTTER, children: /* @__PURE__ */ jsxs20(Text20, { dimColor: true, children: [
       issue2.rule,
       location ? ` \u2014 ${location}` : ""
     ] }) })
@@ -33756,20 +34424,20 @@ function IssueLine({ issue: issue2 }) {
 function ReportUI({ report }) {
   const { counts, stats } = report;
   const summary = ["error", "warning", "info"].filter((level) => counts[level] > 0).map((level) => `${counts[level]} ${level}(s)`).join(", ");
-  return /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs18(Box18, { children: [
-      /* @__PURE__ */ jsx18(Text18, { color: report.valid ? "green" : "red", children: report.valid ? "\u2713" : "\u2717" }),
-      /* @__PURE__ */ jsxs18(Text18, { children: [
+  return /* @__PURE__ */ jsxs20(Box20, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs20(Box20, { children: [
+      /* @__PURE__ */ jsx20(Text20, { color: report.valid ? "green" : "red", children: report.valid ? "\u2713" : "\u2717" }),
+      /* @__PURE__ */ jsxs20(Text20, { children: [
         " Validation ",
         report.valid ? "passed" : "failed"
       ] }),
-      summary ? /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+      summary ? /* @__PURE__ */ jsxs20(Text20, { dimColor: true, children: [
         " \u2014 ",
         summary
       ] }) : null
     ] }),
-    stats.locales.length > 0 && /* @__PURE__ */ jsxs18(Box18, { marginTop: 1, flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+    stats.locales.length > 0 && /* @__PURE__ */ jsxs20(Box20, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs20(Text20, { dimColor: true, children: [
         stats.filesChecked,
         " ",
         stats.format,
@@ -33778,18 +34446,18 @@ function ReportUI({ report }) {
         stats.totalKeys,
         " keys"
       ] }),
-      /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs20(Text20, { dimColor: true, children: [
         "Locales: ",
         stats.locales.join(", "),
         stats.baseLocale ? ` (base: ${stats.baseLocale})` : ""
       ] }),
-      stats.pattern && /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+      stats.pattern && /* @__PURE__ */ jsxs20(Text20, { dimColor: true, children: [
         "Pattern: ",
         stats.pattern
       ] })
     ] }),
-    report.issues.length > 0 && /* @__PURE__ */ jsx18(Box18, { marginTop: 1, flexDirection: "column", gap: 1, children: report.issues.map((issue2, idx) => /* @__PURE__ */ jsx18(IssueLine, { issue: issue2 }, idx)) }),
-    !report.strict && counts.warning > 0 && report.valid && /* @__PURE__ */ jsx18(Box18, { marginTop: 1, children: /* @__PURE__ */ jsx18(Text18, { dimColor: true, children: "Warnings did not fail this run. Use --strict to treat them as errors." }) })
+    report.issues.length > 0 && /* @__PURE__ */ jsx20(Box20, { marginTop: 1, flexDirection: "column", gap: 1, children: report.issues.map((issue2, idx) => /* @__PURE__ */ jsx20(IssueLine, { issue: issue2 }, idx)) }),
+    !report.strict && counts.warning > 0 && report.valid && /* @__PURE__ */ jsx20(Box20, { marginTop: 1, children: /* @__PURE__ */ jsx20(Text20, { dimColor: true, children: "Warnings did not fail this run. Use --strict to treat them as errors." }) })
   ] });
 }
 function emit(report, json2) {
@@ -33809,7 +34477,7 @@ function emit(report, json2) {
     if (!report.valid) fail(validationFailure(report));
     return;
   }
-  render17(/* @__PURE__ */ jsx18(ReportUI, { report })).unmount();
+  render17(/* @__PURE__ */ jsx20(ReportUI, { report })).unmount();
   process.exitCode = exitCode;
 }
 function validationFailure(report) {
@@ -33868,7 +34536,7 @@ function commandPath(command) {
   return names.join(" ");
 }
 function buildProgram() {
-  const program = new Command7().name("tolkbot").description("Localization workflow for your repo").version(version, "-v, --version", "Output the version number").helpOption("-h, --help", "Show help").helpCommand("help [command]", "Show help for a command").option("--token <token>", TOKEN_HELP).enablePositionalOptions();
+  const program = new Command9().name("tolkbot").description("Localization workflow for your repo").version(version, "-v, --version", "Output the version number").helpOption("-h, --help", "Show help").helpCommand("help [command]", "Show help for a command").option("--token <token>", TOKEN_HELP).enablePositionalOptions();
   program.hook("preAction", (_thisCommand, actionCommand) => {
     const { token } = actionCommand.optsWithGlobals();
     setTokenOverride(token);
@@ -33897,9 +34565,11 @@ function buildProgram() {
   program.addCommand(authCommand);
   program.addCommand(glossaryCommand);
   program.addCommand(jobsCommand);
+  program.addCommand(languagesCommand);
   program.addCommand(learningsCommand);
+  program.addCommand(statusCommand);
   program.addCommand(telemetryCommand);
-  program.addCommand(translateCommand);
+  program.addCommand(translateCommand2);
   program.addHelpText("after", PROGRAM_HELP_FOOTER);
   forEachCommand(program, (command) => {
     if (command !== program) addTokenOption(command);
@@ -33915,7 +34585,7 @@ function forEachCommand(command, visit2) {
 var TOKEN_HELP = `Auth token to use for this invocation (overrides $${TOKEN_ENV_VAR} and the stored token)`;
 function addTokenOption(command) {
   if (command.options.some((o) => o.long === "--token")) return;
-  command.addOption(new Option("--token <token>", TOKEN_HELP).hideHelp());
+  command.addOption(new Option2("--token <token>", TOKEN_HELP).hideHelp());
 }
 function jsonOptionOf(command) {
   return command.options.find((option) => option.long === "--json");
@@ -33955,6 +34625,8 @@ var PROGRAM_HELP_FOOTER = `
 Examples:
   $ tolkbot auth login
   $ tolkbot init
+  $ tolkbot status
+  $ tolkbot languages add nb
   $ tolkbot translate --all
   $ tolkbot translate --all --dry-run
   $ tolkbot jobs list