glotfile 0.7.1 → 0.7.3

package/dist/server/cli.js

@@ -1972,6 +1972,9 @@ var init_export_run = __esm({
 function supportsBatchTranslate(p) {
   return typeof p.submitTranslationBatch === "function";
 }
+function supportsBatchComplete(p) {
+  return typeof p.submitCompletionBatch === "function";
+}
 function buildSystemPrompt(hasPluralItems) {
   const lines = [
     "You are a professional software localization engine for a UI string catalog.",
@@ -2216,6 +2219,73 @@ var init_batch = __esm({
   }
 });
 
+// src/server/ai/pricing.ts
+function addUsage(into, add) {
+  into.inputTokens += add.inputTokens;
+  into.outputTokens += add.outputTokens;
+  into.cacheCreationInputTokens += add.cacheCreationInputTokens;
+  into.cacheReadInputTokens += add.cacheReadInputTokens;
+}
+function usageCostUsd(usage, ai, multiplier = 1) {
+  if (!usage) return void 0;
+  const pricing = resolvePricing(ai);
+  return pricing ? estimateUsageCostUsd(usage, pricing, multiplier) : void 0;
+}
+function estimateUsageCostUsd(usage, pricing, multiplier = 1) {
+  const inputCost = (usage.inputTokens + usage.cacheCreationInputTokens * CACHE_WRITE_MULTIPLIER + usage.cacheReadInputTokens * CACHE_READ_MULTIPLIER) * pricing.inputPerMTok;
+  return (inputCost + usage.outputTokens * pricing.outputPerMTok) / 1e6 * multiplier;
+}
+function bareModelId(model) {
+  let id = model.trim().toLowerCase();
+  const slash = id.lastIndexOf("/");
+  if (slash !== -1) id = id.slice(slash + 1);
+  const anth = id.lastIndexOf("anthropic.");
+  if (anth !== -1) id = id.slice(anth + "anthropic.".length);
+  return id;
+}
+function resolvePricing(ai) {
+  if (ai.inputPricePerMTok !== void 0 && ai.outputPricePerMTok !== void 0) {
+    return { source: "profile", inputPerMTok: ai.inputPricePerMTok, outputPerMTok: ai.outputPricePerMTok };
+  }
+  if (FREE_PROVIDERS.has(ai.provider)) return { source: "builtin", inputPerMTok: 0, outputPerMTok: 0 };
+  const id = bareModelId(ai.model);
+  let best;
+  for (const row of PRICE_TABLE) {
+    if (id.startsWith(row[0]) && (!best || row[0].length > best[0].length)) best = row;
+  }
+  return best ? { source: "builtin", inputPerMTok: best[1], outputPerMTok: best[2] } : null;
+}
+var BATCH_PRICE_MULTIPLIER, CACHE_WRITE_MULTIPLIER, CACHE_READ_MULTIPLIER, PRICE_TABLE, FREE_PROVIDERS;
+var init_pricing = __esm({
+  "src/server/ai/pricing.ts"() {
+    "use strict";
+    BATCH_PRICE_MULTIPLIER = 0.5;
+    CACHE_WRITE_MULTIPLIER = 1.25;
+    CACHE_READ_MULTIPLIER = 0.1;
+    PRICE_TABLE = [
+      ["claude-fable-5", 10, 50],
+      ["claude-mythos-5", 10, 50],
+      // Deprecated Opus 4.1 / 4.0 cost 3x the 4.5+ generation — they must outrank
+      // the shorter "claude-opus-4" prefix (4-2025 covers the dated Opus 4 full IDs).
+      ["claude-opus-4-1", 15, 75],
+      ["claude-opus-4-0", 15, 75],
+      ["claude-opus-4-2025", 15, 75],
+      ["claude-opus-4", 5, 25],
+      ["claude-sonnet-4", 3, 15],
+      ["claude-haiku-4", 1, 5],
+      ["claude-3-5-haiku", 0.8, 4],
+      ["gpt-5.5-pro", 30, 180],
+      ["gpt-5.5", 5, 30],
+      ["gpt-5.4-pro", 30, 180],
+      ["gpt-5.4-mini", 0.75, 4.5],
+      ["gpt-5.4-nano", 0.2, 1.25],
+      ["gpt-5.4", 2.5, 15],
+      ["gpt-5.3-codex", 1.75, 14]
+    ];
+    FREE_PROVIDERS = /* @__PURE__ */ new Set(["ollama", "claude-code"]);
+  }
+});
+
 // src/server/ai/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
 var AnthropicProvider;
@@ -2224,6 +2294,7 @@ var init_anthropic = __esm({
     "use strict";
     init_provider();
     init_batch();
+    init_pricing();
     AnthropicProvider = class {
       constructor(config, client) {
         this.config = config;
@@ -2238,9 +2309,25 @@ var init_anthropic = __esm({
       }
       config;
       client;
+      usage = { inputTokens: 0, outputTokens: 0, cacheCreationInputTokens: 0, cacheReadInputTokens: 0 };
       supportsVision() {
         return true;
       }
+      recordUsage(usage) {
+        if (!usage) return;
+        addUsage(this.usage, {
+          inputTokens: usage.input_tokens ?? 0,
+          outputTokens: usage.output_tokens ?? 0,
+          cacheCreationInputTokens: usage.cache_creation_input_tokens ?? 0,
+          cacheReadInputTokens: usage.cache_read_input_tokens ?? 0
+        });
+      }
+      takeUsage() {
+        const taken = this.usage;
+        this.usage = { inputTokens: 0, outputTokens: 0, cacheCreationInputTokens: 0, cacheReadInputTokens: 0 };
+        const any = taken.inputTokens || taken.outputTokens || taken.cacheCreationInputTokens || taken.cacheReadInputTokens;
+        return any ? taken : void 0;
+      }
       translate(reqs, onBatchComplete, signal, onMalformedReply) {
         return runBatched(reqs, this.config.batchSize, (batch, sig) => this.callBatch(batch, sig), onBatchComplete, signal, onMalformedReply);
       }
@@ -2262,10 +2349,13 @@ var init_anthropic = __esm({
         content.push({ type: "text", text: buildBatchPrompt(batch) });
         return content;
       }
-      async complete(req) {
-        const content = req.content.map(
+      completionContent(req) {
+        return req.content.map(
           (b) => b.type === "image" ? { type: "image", source: { type: "base64", media_type: b.mediaType, data: b.base64 } } : { type: "text", text: b.text ?? "" }
         );
+      }
+      async complete(req) {
+        const content = this.completionContent(req);
         const res = await this.client.messages.create({
           model: this.config.model,
           max_tokens: req.maxTokens ?? 8192,
@@ -2273,6 +2363,7 @@ var init_anthropic = __esm({
           output_config: { format: { type: "json_schema", schema: req.schema } },
           messages: [{ role: "user", content }]
         });
+        this.recordUsage(res.usage);
         const text = res.content.find((b) => b.type === "text")?.text ?? "{}";
         try {
           return JSON.parse(text);
@@ -2314,6 +2405,7 @@ var init_anthropic = __esm({
             out.set(entry.custom_id, { type: "failed", error: entry.result.error?.message ?? entry.result.type });
             continue;
           }
+          this.recordUsage(entry.result.message?.usage);
           const text = entry.result.message?.content.find((b) => b.type === "text")?.text ?? "";
           try {
             out.set(entry.custom_id, { type: "items", items: parseReplyItems(text) });
@@ -2327,6 +2419,40 @@ var init_anthropic = __esm({
       async cancelTranslationBatch(batchId) {
         await this.batchesClient().cancel(batchId);
       }
+      // Mirrors complete() exactly — same prompts and schema — so batch and sync
+      // completion replies are interchangeable downstream.
+      async submitCompletionBatch(jobs) {
+        const requests = jobs.map((job) => ({
+          custom_id: job.customId,
+          params: {
+            model: this.config.model,
+            max_tokens: job.request.maxTokens ?? 8192,
+            // Batch entries don't share a live cache window, so cache_control is omitted here.
+            system: [{ type: "text", text: job.request.system }],
+            output_config: { format: { type: "json_schema", schema: job.request.schema } },
+            messages: [{ role: "user", content: this.completionContent(job.request) }]
+          }
+        }));
+        const res = await this.batchesClient().create({ requests });
+        return res.id;
+      }
+      async completionBatchResults(batchId) {
+        const out = /* @__PURE__ */ new Map();
+        for await (const entry of await this.batchesClient().results(batchId)) {
+          if (entry.result.type !== "succeeded") {
+            out.set(entry.custom_id, { type: "failed", error: entry.result.error?.message ?? entry.result.type });
+            continue;
+          }
+          this.recordUsage(entry.result.message?.usage);
+          const text = entry.result.message?.content.find((b) => b.type === "text")?.text ?? "";
+          try {
+            out.set(entry.custom_id, { type: "json", value: JSON.parse(text) });
+          } catch {
+            out.set(entry.custom_id, { type: "malformed", raw: text });
+          }
+        }
+        return out;
+      }
       async callBatch(batch, signal) {
         const content = this.buildUserContent(batch);
         const res = await this.client.messages.create({
@@ -2336,6 +2462,7 @@ var init_anthropic = __esm({
           output_config: { format: { type: "json_schema", schema: BATCH_SCHEMA } },
           messages: [{ role: "user", content }]
         }, { signal });
+        this.recordUsage(res.usage);
         const text = res.content.find((b) => b.type === "text")?.text ?? "";
         return parseReplyItems(text);
       }
@@ -3133,6 +3260,30 @@ var init_pending_batch = __esm({
   }
 });
 
+// src/server/log.ts
+import { appendFileSync, readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
+import { resolve as resolve5 } from "path";
+function logPath(projectRoot) {
+  return resolve5(projectRoot, ".glotfile", "log.jsonl");
+}
+function appendLog(projectRoot, entry) {
+  ensureGlotfileDir(projectRoot);
+  appendFileSync(logPath(projectRoot), JSON.stringify(entry) + "\n", "utf8");
+}
+function readLog(projectRoot, limit = 100) {
+  const path = logPath(projectRoot);
+  if (!existsSync7(path)) return [];
+  const lines = readFileSync7(path, "utf8").split("\n").filter((l) => l.trim() !== "");
+  const entries = lines.map((l) => JSON.parse(l));
+  return entries.reverse().slice(0, limit);
+}
+var init_log = __esm({
+  "src/server/log.ts"() {
+    "use strict";
+    init_glotfile_dir();
+  }
+});
+
 // src/server/ai/batch-run.ts
 function buildBatchJobs(reqs, batchSize) {
   const byLocale = /* @__PURE__ */ new Map();
@@ -3180,7 +3331,9 @@ async function submitBatchTranslation(state, provider, reqs, batchSize, model, p
   return pending;
 }
 async function applyBatchResults(load, persist, provider, pending, projectRoot, ai) {
+  provider.takeUsage?.();
   const outcomes = await provider.translationBatchResults(pending.batchId);
+  const batchUsage = provider.takeUsage?.();
   const fresh = load();
   const isStale = (r) => {
     const entry = fresh.keys[r.key];
@@ -3189,13 +3342,19 @@ async function applyBatchResults(load, persist, provider, pending, projectRoot,
   const applied = [];
   const results = [];
   const retryReqs = [];
-  let staleSkipped = 0;
+  const stale = [];
+  const jobFailures = [];
   for (const job of pending.jobs) {
     const outcome = outcomes.get(job.customId);
     const itemsById = outcome?.type === "items" ? new Map(outcome.items.map((i) => [i.id, i])) : null;
+    if (!itemsById) {
+      if (!outcome) jobFailures.push({ customId: job.customId, locale: job.locale, type: "missing" });
+      else if (outcome.type === "malformed") jobFailures.push({ customId: job.customId, locale: job.locale, type: "malformed", raw: outcome.raw });
+      else if (outcome.type === "failed") jobFailures.push({ customId: job.customId, locale: job.locale, type: "failed", error: outcome.error });
+    }
     for (const stored of job.requests) {
       if (isStale(stored)) {
-        staleSkipped++;
+        stale.push({ key: stored.key, locale: stored.targetLocale });
         continue;
       }
       const { sourceHash: _hash, ...req } = stored;
@@ -3214,7 +3373,20 @@ async function applyBatchResults(load, persist, provider, pending, projectRoot,
     const retryResults = await runLocaleParallel(
       retryReqs,
       provider,
-      {},
+      {
+        // Record the raw reply so an unparseable retry response is diagnosable
+        // from the activity log instead of vanishing into per-item errors.
+        onMalformedReply: (raw, batchSize, locale) => {
+          appendLog(projectRoot, {
+            at: (/* @__PURE__ */ new Date()).toISOString(),
+            kind: "translate",
+            summary: `Malformed model reply (${locale}, batch of ${batchSize})`,
+            model: pending.model,
+            locale,
+            raw
+          });
+        }
+      },
       ai.concurrency,
       void 0,
       ai.batchSize
@@ -3222,10 +3394,34 @@ async function applyBatchResults(load, persist, provider, pending, projectRoot,
     applied.push(...retryReqs);
     results.push(...retryResults);
   }
+  const retryUsage = provider.takeUsage?.();
+  const pricing = resolvePricing({ ...ai, model: pending.model });
+  let estimatedCostUsd;
+  if (pricing && (batchUsage || retryUsage)) {
+    estimatedCostUsd = (batchUsage ? estimateUsageCostUsd(batchUsage, pricing, BATCH_PRICE_MULTIPLIER) : 0) + (retryUsage ? estimateUsageCostUsd(retryUsage, pricing) : 0);
+  }
+  let usage;
+  if (batchUsage || retryUsage) {
+    usage = batchUsage ?? { inputTokens: 0, outputTokens: 0, cacheCreationInputTokens: 0, cacheReadInputTokens: 0 };
+    if (retryUsage) addUsage(usage, retryUsage);
+  }
   const { written, errors } = applyResults(fresh, applied, results);
   persist(fresh);
   clearPendingBatch(projectRoot);
-  return { written, errors, staleSkipped, retried: retryReqs.length, screenshotsSkipped };
+  const costSuffix = estimatedCostUsd !== void 0 ? ` (~$${estimatedCostUsd.toFixed(2)})` : "";
+  appendLog(projectRoot, {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    kind: "translate",
+    summary: `Applied batch ${pending.batchId}: wrote ${written}, ${errors.length} error(s), ${retryReqs.length} retried, ${stale.length} stale${costSuffix}`,
+    model: pending.model,
+    items: applied.map((r) => ({ id: r.id, key: r.key, source: r.source, targetLocale: r.targetLocale })),
+    results,
+    jobFailures: jobFailures.length ? jobFailures : void 0,
+    stale: stale.length ? stale : void 0,
+    usage,
+    estimatedCostUsd
+  });
+  return { written, errors, staleSkipped: stale.length, retried: retryReqs.length, screenshotsSkipped };
 }
 var init_batch_run = __esm({
   "src/server/ai/batch-run.ts"() {
@@ -3234,97 +3430,352 @@ var init_batch_run = __esm({
     init_batch();
     init_run();
     init_pending_batch();
+    init_log();
+    init_pricing();
   }
 });
 
-// src/server/ai/pricing.ts
-function bareModelId(model) {
-  let id = model.trim().toLowerCase();
-  const slash = id.lastIndexOf("/");
-  if (slash !== -1) id = id.slice(slash + 1);
-  const anth = id.lastIndexOf("anthropic.");
-  if (anth !== -1) id = id.slice(anth + "anthropic.".length);
-  return id;
-}
-function resolvePricing(ai) {
-  if (ai.inputPricePerMTok !== void 0 && ai.outputPricePerMTok !== void 0) {
-    return { source: "profile", inputPerMTok: ai.inputPricePerMTok, outputPerMTok: ai.outputPricePerMTok };
-  }
-  if (FREE_PROVIDERS.has(ai.provider)) return { source: "builtin", inputPerMTok: 0, outputPerMTok: 0 };
-  const id = bareModelId(ai.model);
-  let best;
-  for (const row of PRICE_TABLE) {
-    if (id.startsWith(row[0]) && (!best || row[0].length > best[0].length)) best = row;
-  }
-  return best ? { source: "builtin", inputPerMTok: best[1], outputPerMTok: best[2] } : null;
-}
-var PRICE_TABLE, FREE_PROVIDERS;
-var init_pricing = __esm({
-  "src/server/ai/pricing.ts"() {
-    "use strict";
-    PRICE_TABLE = [
-      ["claude-fable-5", 10, 50],
-      ["claude-mythos-5", 10, 50],
-      // Deprecated Opus 4.1 / 4.0 cost 3x the 4.5+ generation — they must outrank
-      // the shorter "claude-opus-4" prefix (4-2025 covers the dated Opus 4 full IDs).
-      ["claude-opus-4-1", 15, 75],
-      ["claude-opus-4-0", 15, 75],
-      ["claude-opus-4-2025", 15, 75],
-      ["claude-opus-4", 5, 25],
-      ["claude-sonnet-4", 3, 15],
-      ["claude-haiku-4", 1, 5],
-      ["claude-3-5-haiku", 0.8, 4],
-      ["gpt-5.5-pro", 30, 180],
-      ["gpt-5.5", 5, 30],
-      ["gpt-5.4-pro", 30, 180],
-      ["gpt-5.4-mini", 0.75, 4.5],
-      ["gpt-5.4-nano", 0.2, 1.25],
-      ["gpt-5.4", 2.5, 15],
-      ["gpt-5.3-codex", 1.75, 14]
-    ];
-    FREE_PROVIDERS = /* @__PURE__ */ new Set(["ollama", "claude-code"]);
-  }
-});
-
-// src/server/ai/estimate.ts
-function estimateTokens(text) {
-  const cjk = text.match(CJK_RE)?.length ?? 0;
-  return Math.ceil((text.length - cjk) / 4 + cjk / 2);
+// src/server/ai/context.ts
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve6 } from "path";
+function globToRegExp2(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
 }
-function estimateOutputTokens(req) {
-  const translated = Math.ceil(estimateTokens(req.source) * EXPANSION);
-  if (req.plural) {
-    return ITEM_REPLY_OVERHEAD + req.plural.categories.length * (translated + FORM_REPLY_OVERHEAD);
+function extractSnippets(refs, projectRoot, fileCache) {
+  const filtered = refs.filter((r) => !EXCLUDED_DIRS.some((d) => r.file.startsWith(d)));
+  const sorted = [...filtered].sort((a, b) => a.file.length - b.file.length);
+  const selected = sorted.slice(0, MAX_SNIPPETS);
+  const extraRefs = filtered.length > MAX_SNIPPETS ? filtered.length - MAX_SNIPPETS : 0;
+  const snippets = [];
+  for (const ref of selected) {
+    const absPath = resolve6(projectRoot, ref.file);
+    if (!fileCache.has(ref.file)) {
+      if (!existsSync8(absPath)) continue;
+      const content = readFileSync8(absPath, "utf8");
+      fileCache.set(ref.file, content.split("\n"));
+    }
+    const lines = fileCache.get(ref.file);
+    const start = Math.max(0, ref.line - 1 - SNIPPET_WINDOW);
+    const end = Math.min(lines.length, ref.line + SNIPPET_WINDOW);
+    snippets.push({
+      file: ref.file,
+      startLine: start + 1,
+      lines: lines.slice(start, end).join("\n"),
+      scanner: ref.scanner,
+      ...snippets.length === 0 && extraRefs > 0 ? { extraRefs } : {}
+    });
   }
-  return ITEM_REPLY_OVERHEAD + translated;
+  return snippets;
 }
-function estimateTranslation(state, ai, opts) {
-  const reqs = selectRequests(state, opts);
-  const byLocale = /* @__PURE__ */ new Map();
-  for (const r of reqs) {
-    let group = byLocale.get(r.targetLocale);
-    if (!group) {
-      group = [];
-      byLocale.set(r.targetLocale, group);
+function buildUsageIndex(cache2) {
+  const index = /* @__PURE__ */ new Map();
+  for (const [file, entry] of Object.entries(cache2.files)) {
+    for (const ref of entry.refs) {
+      const existing = index.get(ref.key) ?? [];
+      existing.push({ key: ref.key, file, line: ref.line, col: ref.col, scanner: ref.scanner });
+      index.set(ref.key, existing);
     }
-    group.push(r);
   }
-  const perLocale = [];
-  for (const [locale, group] of byLocale) {
-    let inputTokens2 = 0;
-    let outputTokens2 = 0;
-    const batches = chunk(group, Math.max(1, ai.batchSize));
-    for (const batch of batches) {
-      const system = buildSystemPrompt(batch.some((r) => r.plural !== void 0));
-      inputTokens2 += estimateTokens(system) + estimateTokens(buildBatchPrompt(batch));
-      for (const r of batch) outputTokens2 += estimateOutputTokens(r);
+  return index;
+}
+function selectContextTargets(state, opts, cache2, lastRunAt) {
+  const cutoff = opts.all ? void 0 : opts.since ?? lastRunAt;
+  const keyRe = opts.keyGlob ? globToRegExp2(opts.keyGlob) : null;
+  const keySet = opts.keys ? new Set(opts.keys) : null;
+  const usageIndex = buildUsageIndex(cache2);
+  let candidates = [];
+  for (const key of Object.keys(state.keys).sort()) {
+    const entry = state.keys[key];
+    if (entry.context && !opts.force) continue;
+    if (keySet && !keySet.has(key)) continue;
+    if (keyRe && !keyRe.test(key)) continue;
+    if (cutoff) {
+      if (!entry.createdAt) continue;
+      if (entry.createdAt < cutoff) continue;
     }
-    perLocale.push({ locale, requests: group.length, batches: batches.length, inputTokens: inputTokens2, outputTokens: outputTokens2 });
+    const source = entry.values[state.config.sourceLocale]?.value ?? "";
+    candidates.push({ id: String(candidates.length), key, source, usageSnippets: [] });
   }
-  const inputTokens = perLocale.reduce((n, l) => n + l.inputTokens, 0);
-  const outputTokens = perLocale.reduce((n, l) => n + l.outputTokens, 0);
-  const pricing = resolvePricing(ai);
-  return {
+  candidates.sort((a, b) => {
+    const ta = state.keys[a.key].createdAt ?? "";
+    const tb = state.keys[b.key].createdAt ?? "";
+    return tb.localeCompare(ta);
+  });
+  if (opts.limit !== void 0) candidates = candidates.slice(0, opts.limit);
+  candidates.forEach((c, i) => {
+    c.id = String(i);
+  });
+  return candidates;
+}
+function buildContextSystemPrompt() {
+  return [
+    "You are a localization context writer for a UI string catalog.",
+    "For each translation key you are given: its dot-path name, its source string, and one or more code snippets showing where the string is referenced in the codebase.",
+    "Your task: write a concise 1\u20132 sentence context note that describes WHERE in the UI this string appears and WHAT the user is doing at that point.",
+    "The context is read by human translators AND by an AI translation engine. It must answer: what screen is this on, what element is this (button, label, error, etc.), and what action does it relate to?",
+    "Rules:",
+    "- Use the code snippets as your primary signal. Look at the component name, surrounding labels, event handlers, and variable names.",
+    "- Do NOT restate the source string itself.",
+    "- Do NOT say 'This string is...' \u2014 write the context as a direct description.",
+    "- Keep it under 500 characters.",
+    "- If no code snippets are available, infer from the key path and source value."
+  ].join("\n");
+}
+function buildContextBatchPrompt(reqs) {
+  const items = reqs.map((r) => {
+    const snippetText = r.usageSnippets.length > 0 ? r.usageSnippets.map((s) => {
+      const extra = s.extraRefs ? ` (and ${s.extraRefs} more call site${s.extraRefs > 1 ? "s" : ""} not shown)` : "";
+      return `File: ${s.file} (lines ${s.startLine}+, scanner: ${s.scanner})${extra}
+\`\`\`
+${s.lines}
+\`\`\``;
+    }).join("\n\n") : "(no code references found \u2014 infer from key path and source value)";
+    return { id: r.id, key: r.key, source: r.source, codeSnippets: snippetText };
+  });
+  return 'Write a context note for each key. Return JSON {"items":[{"id","context"}]}.\n' + JSON.stringify(items, null, 2);
+}
+function applyContext(state, reqs, results, clock = systemClock, force = false) {
+  const byId = new Map(reqs.map((r) => [r.id, r]));
+  let written = 0;
+  const errors = [];
+  for (const res of results) {
+    const req = byId.get(res.id);
+    if (!req) continue;
+    if (res.error) {
+      errors.push({ key: req.key, error: res.error });
+      continue;
+    }
+    const context = res.context?.trim() ?? "";
+    if (!context) {
+      errors.push({ key: req.key, error: "AI returned empty context" });
+      continue;
+    }
+    if (context.length > MAX_CONTEXT_LENGTH) {
+      errors.push({ key: req.key, error: `Context too long (${context.length} chars, max ${MAX_CONTEXT_LENGTH})` });
+      continue;
+    }
+    const entry = state.keys[req.key];
+    if (!entry || entry.context && !force) continue;
+    entry.context = context;
+    entry.contextSource = "ai";
+    entry.contextAt = clock();
+    written++;
+  }
+  return { written, errors };
+}
+var MAX_CONTEXT_LENGTH, SNIPPET_WINDOW, MAX_SNIPPETS, EXCLUDED_DIRS, CONTEXT_BATCH_SCHEMA;
+var init_context = __esm({
+  "src/server/ai/context.ts"() {
+    "use strict";
+    init_state();
+    MAX_CONTEXT_LENGTH = 500;
+    SNIPPET_WINDOW = 15;
+    MAX_SNIPPETS = 3;
+    EXCLUDED_DIRS = ["node_modules/", "vendor/", "dist/", ".git/", ".glotfile/"];
+    CONTEXT_BATCH_SCHEMA = {
+      type: "object",
+      properties: {
+        items: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string" },
+              context: { type: "string" },
+              error: { type: "string" }
+            },
+            required: ["id"],
+            additionalProperties: false
+          }
+        }
+      },
+      required: ["items"],
+      additionalProperties: false
+    };
+  }
+});
+
+// src/server/ai/pending-context-batch.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync4, rmSync as rmSync5 } from "fs";
+import { join as join4 } from "path";
+function pendingContextBatchPath(projectRoot) {
+  return join4(projectRoot, ".glotfile", "context-batch.json");
+}
+function loadPendingContextBatch(projectRoot) {
+  const path = pendingContextBatchPath(projectRoot);
+  if (!existsSync9(path)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync9(path, "utf8"));
+    if (parsed?.version !== 1) return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function savePendingContextBatch(projectRoot, pending) {
+  const dir = join4(projectRoot, ".glotfile");
+  mkdirSync5(dir, { recursive: true });
+  const gitignore = join4(dir, ".gitignore");
+  if (!existsSync9(gitignore)) writeFileSync4(gitignore, "*\n");
+  writeFileSync4(pendingContextBatchPath(projectRoot), JSON.stringify(pending, null, 2) + "\n");
+}
+function clearPendingContextBatch(projectRoot) {
+  rmSync5(pendingContextBatchPath(projectRoot), { force: true });
+}
+var init_pending_context_batch = __esm({
+  "src/server/ai/pending-context-batch.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/ai/context-batch-run.ts
+function completionRequestFor(chunk2) {
+  return {
+    system: buildContextSystemPrompt(),
+    content: [{ type: "text", text: buildContextBatchPrompt(chunk2) }],
+    schema: CONTEXT_BATCH_SCHEMA
+  };
+}
+async function submitContextBatch(provider, targets, batchSize, model, projectRoot, force) {
+  if (loadPendingContextBatch(projectRoot)) {
+    throw new Error("A context batch is already pending. Apply or cancel it first.");
+  }
+  const chunks = [];
+  const size = Math.max(1, batchSize);
+  for (let i = 0; i < targets.length; i += size) chunks.push(targets.slice(i, i + size));
+  const jobs = chunks.map((chunk2, i) => ({ customId: `ctx_${i}`, chunk: chunk2 }));
+  const batchId = await provider.submitCompletionBatch(
+    jobs.map((j) => ({ customId: j.customId, request: completionRequestFor(j.chunk) }))
+  );
+  const pending = {
+    version: 1,
+    // Only Anthropic implements completion batches today.
+    provider: "anthropic",
+    model,
+    batchId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    total: targets.length,
+    force,
+    jobs: jobs.map((j) => ({
+      customId: j.customId,
+      requests: j.chunk.map(({ image: _image, ...rest }) => rest)
+    }))
+  };
+  savePendingContextBatch(projectRoot, pending);
+  return pending;
+}
+async function applyContextBatchResults(load, persist, provider, pending, projectRoot, ai) {
+  provider.takeUsage?.();
+  const outcomes = await provider.completionBatchResults(pending.batchId);
+  const batchUsage = provider.takeUsage?.();
+  const applied = [];
+  const items = [];
+  const errors = [];
+  const jobFailures = [];
+  const retryChunks = [];
+  for (const job of pending.jobs) {
+    const outcome = outcomes.get(job.customId);
+    if (outcome?.type === "json") {
+      const batch = outcome.value;
+      applied.push(...job.requests);
+      items.push(...batch.items ?? []);
+      continue;
+    }
+    if (!outcome) jobFailures.push({ customId: job.customId, locale: "", type: "missing" });
+    else if (outcome.type === "malformed") jobFailures.push({ customId: job.customId, locale: "", type: "malformed", raw: outcome.raw });
+    else jobFailures.push({ customId: job.customId, locale: "", type: "failed", error: outcome.error });
+    retryChunks.push(job.requests);
+  }
+  for (const chunk2 of retryChunks) {
+    try {
+      const raw = await provider.complete(completionRequestFor(chunk2));
+      const batch = raw;
+      applied.push(...chunk2);
+      items.push(...batch.items ?? []);
+    } catch (e) {
+      errors.push(...chunk2.map((t) => ({ key: t.key, error: e.message })));
+    }
+  }
+  const retryUsage = provider.takeUsage?.();
+  const pricing = resolvePricing({ ...ai, model: pending.model });
+  let estimatedCostUsd;
+  if (pricing && (batchUsage || retryUsage)) {
+    estimatedCostUsd = (batchUsage ? estimateUsageCostUsd(batchUsage, pricing, BATCH_PRICE_MULTIPLIER) : 0) + (retryUsage ? estimateUsageCostUsd(retryUsage, pricing) : 0);
+  }
+  let usage;
+  if (batchUsage || retryUsage) {
+    usage = batchUsage ?? { inputTokens: 0, outputTokens: 0, cacheCreationInputTokens: 0, cacheReadInputTokens: 0 };
+    if (retryUsage) addUsage(usage, retryUsage);
+  }
+  const fresh = load();
+  const { written, errors: applyErrors } = applyContext(fresh, applied, items, void 0, pending.force);
+  errors.push(...applyErrors);
+  persist(fresh);
+  clearPendingContextBatch(projectRoot);
+  const costSuffix = estimatedCostUsd !== void 0 ? ` (~$${estimatedCostUsd.toFixed(2)})` : "";
+  appendLog(projectRoot, {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    kind: "context",
+    summary: `Applied context batch ${pending.batchId}: wrote ${written}, ${errors.length} error(s), ${retryChunks.length} job(s) retried${costSuffix}`,
+    model: pending.model,
+    items: applied.map((r) => ({ id: r.id, key: r.key, source: r.source })),
+    results: items.map((r) => ({ id: r.id, value: r.context, error: r.error })),
+    jobFailures: jobFailures.length ? jobFailures : void 0,
+    usage,
+    estimatedCostUsd
+  });
+  return { written, errors, retried: retryChunks.length };
+}
+var init_context_batch_run = __esm({
+  "src/server/ai/context-batch-run.ts"() {
+    "use strict";
+    init_context();
+    init_pending_context_batch();
+    init_log();
+    init_pricing();
+  }
+});
+
+// src/server/ai/estimate.ts
+function estimateTokens(text) {
+  const cjk = text.match(CJK_RE)?.length ?? 0;
+  return Math.ceil((text.length - cjk) / 4 + cjk / 2);
+}
+function estimateOutputTokens(req) {
+  const translated = Math.ceil(estimateTokens(req.source) * EXPANSION);
+  if (req.plural) {
+    return ITEM_REPLY_OVERHEAD + req.plural.categories.length * (translated + FORM_REPLY_OVERHEAD);
+  }
+  return ITEM_REPLY_OVERHEAD + translated;
+}
+function estimateTranslation(state, ai, opts) {
+  const reqs = selectRequests(state, opts);
+  const byLocale = /* @__PURE__ */ new Map();
+  for (const r of reqs) {
+    let group = byLocale.get(r.targetLocale);
+    if (!group) {
+      group = [];
+      byLocale.set(r.targetLocale, group);
+    }
+    group.push(r);
+  }
+  const perLocale = [];
+  for (const [locale, group] of byLocale) {
+    let inputTokens2 = 0;
+    let outputTokens2 = 0;
+    const batches = chunk(group, Math.max(1, ai.batchSize));
+    for (const batch of batches) {
+      const system = buildSystemPrompt(batch.some((r) => r.plural !== void 0));
+      inputTokens2 += estimateTokens(system) + estimateTokens(buildBatchPrompt(batch));
+      for (const r of batch) outputTokens2 += estimateOutputTokens(r);
+    }
+    perLocale.push({ locale, requests: group.length, batches: batches.length, inputTokens: inputTokens2, outputTokens: outputTokens2 });
+  }
+  const inputTokens = perLocale.reduce((n, l) => n + l.inputTokens, 0);
+  const outputTokens = perLocale.reduce((n, l) => n + l.outputTokens, 0);
+  const pricing = resolvePricing(ai);
+  return {
     requests: reqs.length,
     batches: perLocale.reduce((n, l) => n + l.batches, 0),
     perLocale,
@@ -3349,45 +3800,21 @@ var init_estimate = __esm({
   }
 });
 
-// src/server/log.ts
-import { appendFileSync, readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
-import { resolve as resolve5 } from "path";
-function logPath(projectRoot) {
-  return resolve5(projectRoot, ".glotfile", "log.jsonl");
-}
-function appendLog(projectRoot, entry) {
-  ensureGlotfileDir(projectRoot);
-  appendFileSync(logPath(projectRoot), JSON.stringify(entry) + "\n", "utf8");
-}
-function readLog(projectRoot, limit = 100) {
-  const path = logPath(projectRoot);
-  if (!existsSync7(path)) return [];
-  const lines = readFileSync7(path, "utf8").split("\n").filter((l) => l.trim() !== "");
-  const entries = lines.map((l) => JSON.parse(l));
-  return entries.reverse().slice(0, limit);
-}
-var init_log = __esm({
-  "src/server/log.ts"() {
-    "use strict";
-    init_glotfile_dir();
-  }
-});
-
 // src/server/scan.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve6 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve7 } from "path";
 function loadUsageCache(projectRoot) {
-  const path = resolve6(projectRoot, ".glotfile", "usage.json");
-  if (!existsSync8(path)) return null;
+  const path = resolve7(projectRoot, ".glotfile", "usage.json");
+  if (!existsSync10(path)) return null;
   try {
-    return JSON.parse(readFileSync8(path, "utf8"));
+    return JSON.parse(readFileSync10(path, "utf8"));
   } catch {
     return null;
   }
 }
 function saveUsageCache(projectRoot, cache2) {
   ensureGlotfileDir(projectRoot);
-  const path = resolve6(projectRoot, ".glotfile", "usage.json");
+  const path = resolve7(projectRoot, ".glotfile", "usage.json");
   writeFileAtomic(path, JSON.stringify(cache2, null, 2) + "\n");
 }
 function findMissing(state) {
@@ -3445,8 +3872,8 @@ var init_scan = __esm({
 });
 
 // src/server/scanner.ts
-import { readdirSync as readdirSync3, statSync as statSync2, readFileSync as readFileSync9 } from "fs";
-import { join as join4, extname as extname2, relative } from "path";
+import { readdirSync as readdirSync3, statSync as statSync2, readFileSync as readFileSync11 } from "fs";
+import { join as join5, extname as extname2, relative } from "path";
 function scannerForExt(ext) {
   return EXT_SCANNER[ext] ?? null;
 }
@@ -3598,7 +4025,7 @@ function* walkFiles(dir, root, exclude) {
   }
   for (const name of entries) {
     if (ALWAYS_EXCLUDE.has(name)) continue;
-    const abs = join4(dir, name);
+    const abs = join5(dir, name);
     const rel = relative(root, abs);
     let st;
     try {
@@ -3628,7 +4055,7 @@ function runScan(projectRoot, opts, existing) {
     const ext = extname2(relPath);
     const scanner = scannerForExt(ext);
     if (!scanner) continue;
-    const abs = join4(projectRoot, relPath);
+    const abs = join5(projectRoot, relPath);
     let st;
     try {
       st = statSync2(abs);
@@ -3644,279 +4071,118 @@ function runScan(projectRoot, opts, existing) {
     }
     let content;
     try {
-      content = readFileSync9(abs, "utf8");
+      content = readFileSync11(abs, "utf8");
     } catch {
-      continue;
-    }
-    cache2.files[relPath] = {
-      mtime,
-      size,
-      refs: extractRefs(content, scanner, opts),
-      prefixes: extractPrefixes(content, scanner),
-      literals: extractLiterals(content)
-    };
-  }
-  saveUsageCache(projectRoot, cache2);
-  return cache2;
-}
-var PATTERNS, PREFIX_PATTERNS, CACHE_VERSION, EXT_SCANNER, ALWAYS_EXCLUDE, FLUTTER_ACCESSOR_DEFAULTS, KEY_SHAPE, STRING_LITERALS;
-var init_scanner = __esm({
-  "src/server/scanner.ts"() {
-    "use strict";
-    init_scan();
-    PATTERNS = {
-      laravel: [
-        /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*'([^']+)'/g,
-        /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*"([^"]+)"/g,
-        /@(?:lang|choice)\s*\(\s*'([^']+)'/g,
-        /@(?:lang|choice)\s*\(\s*"([^"]+)"/g
-      ],
-      "js-i18n": [
-        /\$t\s*\(\s*'([^']+)'/g,
-        /\$t\s*\(\s*"([^"]+)"/g,
-        /\$t\s*\(\s*`([^`$\n]+)`/g,
-        /\bi18n\.t\s*\(\s*'([^']+)'/g,
-        /\bi18n\.t\s*\(\s*"([^"]+)"/g,
-        /\bi18next\.t\s*\(\s*'([^']+)'/g,
-        /\bi18next\.t\s*\(\s*"([^"]+)"/g,
-        // t('key') — word boundary before t, not preceded by dot (excludes i18n.t which is above)
-        /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*'([^']+)'/g,
-        /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*"([^"]+)"/g,
-        /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*`([^`$\n]+)`/g
-      ],
-      gettext: [
-        /\b(?:gettext|ngettext)\s*\(\s*'([^']+)'/g,
-        /\b(?:gettext|ngettext)\s*\(\s*"([^"]+)"/g,
-        // _() — word boundary, not preceded by alphanumeric
-        /(?<![a-zA-Z0-9_$])_\s*\(\s*'([^']+)'/g,
-        /(?<![a-zA-Z0-9_$])_\s*\(\s*"([^"]+)"/g
-      ],
-      apple: [
-        /NSLocalizedString\s*\(\s*@?"([^"]+)"/g,
-        /String\s*\(\s*localized:\s*"([^"]+)"/g,
-        /localizedString\s*\(\s*forKey:\s*"([^"]+)"/g,
-        // The "key".localized / "key".localised String-extension idiom, where the
-        // literal IS the key (common when keys are natural-language source text).
-        /"([^"]+)"\s*\.\s*localized\b/g,
-        /"([^"]+)"\s*\.\s*localised\b/g
-      ]
-    };
-    PREFIX_PATTERNS = {
-      laravel: [
-        /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*'([^']*)'\s*\./g,
-        /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*"([^"]*)"\s*\./g,
-        /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*"([^"${]*)\{?\$/g
-      ],
-      "js-i18n": [
-        /(?:\$t|i18n\.t|i18next\.t)\s*\(\s*'([^']*)'\s*\+/g,
-        /(?:\$t|i18n\.t|i18next\.t)\s*\(\s*"([^"]*)"\s*\+/g,
-        /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*'([^']*)'\s*\+/g,
-        /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*"([^"]*)"\s*\+/g,
-        /(?:\$t|i18n\.t|i18next\.t)\s*\(\s*`([^`$]*)\$\{/g,
-        /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*`([^`$]*)\$\{/g
-      ]
-    };
-    CACHE_VERSION = 6;
-    EXT_SCANNER = {
-      ".php": "laravel",
-      ".vue": "js-i18n",
-      ".js": "js-i18n",
-      ".ts": "js-i18n",
-      ".jsx": "js-i18n",
-      ".tsx": "js-i18n",
-      ".mjs": "js-i18n",
-      ".cjs": "js-i18n",
-      ".dart": "flutter",
-      ".py": "gettext",
-      ".c": "gettext",
-      ".cpp": "gettext",
-      ".h": "gettext",
-      ".swift": "apple",
-      ".m": "apple",
-      ".mm": "apple"
-    };
-    ALWAYS_EXCLUDE = /* @__PURE__ */ new Set([
-      "node_modules",
-      ".git",
-      ".glotfile",
-      ".claude",
-      "dist",
-      "build",
-      "vendor",
-      "coverage",
-      ".next",
-      ".nuxt",
-      ".turbo",
-      "__pycache__"
-    ]);
-    FLUTTER_ACCESSOR_DEFAULTS = ["l10n", "loc", "localizations", "translations"];
-    KEY_SHAPE = /^[A-Za-z0-9_][A-Za-z0-9_/-]*(?:\.(?:[A-Za-z0-9_-]+|%[sd]))+\.?$/;
-    STRING_LITERALS = [
-      /'([^'\\\n]+)'/g,
-      /"([^"\\\n]+)"/g,
-      /`([^`\\\n]+)`/g
-    ];
-  }
-});
-
-// src/server/ai/context.ts
-import { existsSync as existsSync9, readFileSync as readFileSync10 } from "fs";
-import { resolve as resolve7 } from "path";
-function globToRegExp2(glob) {
-  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`);
-}
-function extractSnippets(refs, projectRoot, fileCache) {
-  const filtered = refs.filter((r) => !EXCLUDED_DIRS.some((d) => r.file.startsWith(d)));
-  const sorted = [...filtered].sort((a, b) => a.file.length - b.file.length);
-  const selected = sorted.slice(0, MAX_SNIPPETS);
-  const extraRefs = filtered.length > MAX_SNIPPETS ? filtered.length - MAX_SNIPPETS : 0;
-  const snippets = [];
-  for (const ref of selected) {
-    const absPath = resolve7(projectRoot, ref.file);
-    if (!fileCache.has(ref.file)) {
-      if (!existsSync9(absPath)) continue;
-      const content = readFileSync10(absPath, "utf8");
-      fileCache.set(ref.file, content.split("\n"));
-    }
-    const lines = fileCache.get(ref.file);
-    const start = Math.max(0, ref.line - 1 - SNIPPET_WINDOW);
-    const end = Math.min(lines.length, ref.line + SNIPPET_WINDOW);
-    snippets.push({
-      file: ref.file,
-      startLine: start + 1,
-      lines: lines.slice(start, end).join("\n"),
-      scanner: ref.scanner,
-      ...snippets.length === 0 && extraRefs > 0 ? { extraRefs } : {}
-    });
-  }
-  return snippets;
-}
-function buildUsageIndex(cache2) {
-  const index = /* @__PURE__ */ new Map();
-  for (const [file, entry] of Object.entries(cache2.files)) {
-    for (const ref of entry.refs) {
-      const existing = index.get(ref.key) ?? [];
-      existing.push({ key: ref.key, file, line: ref.line, col: ref.col, scanner: ref.scanner });
-      index.set(ref.key, existing);
-    }
-  }
-  return index;
-}
-function selectContextTargets(state, opts, cache2, lastRunAt) {
-  const cutoff = opts.all ? void 0 : opts.since ?? lastRunAt;
-  const keyRe = opts.keyGlob ? globToRegExp2(opts.keyGlob) : null;
-  const keySet = opts.keys ? new Set(opts.keys) : null;
-  const usageIndex = buildUsageIndex(cache2);
-  let candidates = [];
-  for (const key of Object.keys(state.keys).sort()) {
-    const entry = state.keys[key];
-    if (entry.context && !opts.force) continue;
-    if (keySet && !keySet.has(key)) continue;
-    if (keyRe && !keyRe.test(key)) continue;
-    if (cutoff) {
-      if (!entry.createdAt) continue;
-      if (entry.createdAt < cutoff) continue;
-    }
-    const source = entry.values[state.config.sourceLocale]?.value ?? "";
-    candidates.push({ id: String(candidates.length), key, source, usageSnippets: [] });
-  }
-  candidates.sort((a, b) => {
-    const ta = state.keys[a.key].createdAt ?? "";
-    const tb = state.keys[b.key].createdAt ?? "";
-    return tb.localeCompare(ta);
-  });
-  if (opts.limit !== void 0) candidates = candidates.slice(0, opts.limit);
-  candidates.forEach((c, i) => {
-    c.id = String(i);
-  });
-  return candidates;
-}
-function buildContextSystemPrompt() {
-  return [
-    "You are a localization context writer for a UI string catalog.",
-    "For each translation key you are given: its dot-path name, its source string, and one or more code snippets showing where the string is referenced in the codebase.",
-    "Your task: write a concise 1\u20132 sentence context note that describes WHERE in the UI this string appears and WHAT the user is doing at that point.",
-    "The context is read by human translators AND by an AI translation engine. It must answer: what screen is this on, what element is this (button, label, error, etc.), and what action does it relate to?",
-    "Rules:",
-    "- Use the code snippets as your primary signal. Look at the component name, surrounding labels, event handlers, and variable names.",
-    "- Do NOT restate the source string itself.",
-    "- Do NOT say 'This string is...' \u2014 write the context as a direct description.",
-    "- Keep it under 500 characters.",
-    "- If no code snippets are available, infer from the key path and source value."
-  ].join("\n");
-}
-function buildContextBatchPrompt(reqs) {
-  const items = reqs.map((r) => {
-    const snippetText = r.usageSnippets.length > 0 ? r.usageSnippets.map((s) => {
-      const extra = s.extraRefs ? ` (and ${s.extraRefs} more call site${s.extraRefs > 1 ? "s" : ""} not shown)` : "";
-      return `File: ${s.file} (lines ${s.startLine}+, scanner: ${s.scanner})${extra}
-\`\`\`
-${s.lines}
-\`\`\``;
-    }).join("\n\n") : "(no code references found \u2014 infer from key path and source value)";
-    return { id: r.id, key: r.key, source: r.source, codeSnippets: snippetText };
-  });
-  return 'Write a context note for each key. Return JSON {"items":[{"id","context"}]}.\n' + JSON.stringify(items, null, 2);
-}
-function applyContext(state, reqs, results, clock = systemClock, force = false) {
-  const byId = new Map(reqs.map((r) => [r.id, r]));
-  let written = 0;
-  const errors = [];
-  for (const res of results) {
-    const req = byId.get(res.id);
-    if (!req) continue;
-    if (res.error) {
-      errors.push({ key: req.key, error: res.error });
-      continue;
-    }
-    const context = res.context?.trim() ?? "";
-    if (!context) {
-      errors.push({ key: req.key, error: "AI returned empty context" });
-      continue;
-    }
-    if (context.length > MAX_CONTEXT_LENGTH) {
-      errors.push({ key: req.key, error: `Context too long (${context.length} chars, max ${MAX_CONTEXT_LENGTH})` });
-      continue;
-    }
-    const entry = state.keys[req.key];
-    if (!entry || entry.context && !force) continue;
-    entry.context = context;
-    entry.contextSource = "ai";
-    entry.contextAt = clock();
-    written++;
-  }
-  return { written, errors };
-}
-var MAX_CONTEXT_LENGTH, SNIPPET_WINDOW, MAX_SNIPPETS, EXCLUDED_DIRS, CONTEXT_BATCH_SCHEMA;
-var init_context = __esm({
-  "src/server/ai/context.ts"() {
-    "use strict";
-    init_state();
-    MAX_CONTEXT_LENGTH = 500;
-    SNIPPET_WINDOW = 15;
-    MAX_SNIPPETS = 3;
-    EXCLUDED_DIRS = ["node_modules/", "vendor/", "dist/", ".git/", ".glotfile/"];
-    CONTEXT_BATCH_SCHEMA = {
-      type: "object",
-      properties: {
-        items: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              id: { type: "string" },
-              context: { type: "string" },
-              error: { type: "string" }
-            },
-            required: ["id"],
-            additionalProperties: false
-          }
-        }
-      },
-      required: ["items"],
-      additionalProperties: false
+      continue;
+    }
+    cache2.files[relPath] = {
+      mtime,
+      size,
+      refs: extractRefs(content, scanner, opts),
+      prefixes: extractPrefixes(content, scanner),
+      literals: extractLiterals(content)
+    };
+  }
+  saveUsageCache(projectRoot, cache2);
+  return cache2;
+}
+var PATTERNS, PREFIX_PATTERNS, CACHE_VERSION, EXT_SCANNER, ALWAYS_EXCLUDE, FLUTTER_ACCESSOR_DEFAULTS, KEY_SHAPE, STRING_LITERALS;
+var init_scanner = __esm({
+  "src/server/scanner.ts"() {
+    "use strict";
+    init_scan();
+    PATTERNS = {
+      laravel: [
+        /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*'([^']+)'/g,
+        /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*"([^"]+)"/g,
+        /@(?:lang|choice)\s*\(\s*'([^']+)'/g,
+        /@(?:lang|choice)\s*\(\s*"([^"]+)"/g
+      ],
+      "js-i18n": [
+        /\$t\s*\(\s*'([^']+)'/g,
+        /\$t\s*\(\s*"([^"]+)"/g,
+        /\$t\s*\(\s*`([^`$\n]+)`/g,
+        /\bi18n\.t\s*\(\s*'([^']+)'/g,
+        /\bi18n\.t\s*\(\s*"([^"]+)"/g,
+        /\bi18next\.t\s*\(\s*'([^']+)'/g,
+        /\bi18next\.t\s*\(\s*"([^"]+)"/g,
+        // t('key') — word boundary before t, not preceded by dot (excludes i18n.t which is above)
+        /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*'([^']+)'/g,
+        /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*"([^"]+)"/g,
+        /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*`([^`$\n]+)`/g
+      ],
+      gettext: [
+        /\b(?:gettext|ngettext)\s*\(\s*'([^']+)'/g,
+        /\b(?:gettext|ngettext)\s*\(\s*"([^"]+)"/g,
+        // _() — word boundary, not preceded by alphanumeric
+        /(?<![a-zA-Z0-9_$])_\s*\(\s*'([^']+)'/g,
+        /(?<![a-zA-Z0-9_$])_\s*\(\s*"([^"]+)"/g
+      ],
+      apple: [
+        /NSLocalizedString\s*\(\s*@?"([^"]+)"/g,
+        /String\s*\(\s*localized:\s*"([^"]+)"/g,
+        /localizedString\s*\(\s*forKey:\s*"([^"]+)"/g,
+        // The "key".localized / "key".localised String-extension idiom, where the
+        // literal IS the key (common when keys are natural-language source text).
+        /"([^"]+)"\s*\.\s*localized\b/g,
+        /"([^"]+)"\s*\.\s*localised\b/g
+      ]
+    };
+    PREFIX_PATTERNS = {
+      laravel: [
+        /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*'([^']*)'\s*\./g,
+        /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*"([^"]*)"\s*\./g,
+        /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*"([^"${]*)\{?\$/g
+      ],
+      "js-i18n": [
+        /(?:\$t|i18n\.t|i18next\.t)\s*\(\s*'([^']*)'\s*\+/g,
+        /(?:\$t|i18n\.t|i18next\.t)\s*\(\s*"([^"]*)"\s*\+/g,
+        /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*'([^']*)'\s*\+/g,
+        /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*"([^"]*)"\s*\+/g,
+        /(?:\$t|i18n\.t|i18next\.t)\s*\(\s*`([^`$]*)\$\{/g,
+        /(?<!\.)(?<![a-zA-Z0-9_$])\bt\s*\(\s*`([^`$]*)\$\{/g
+      ]
+    };
+    CACHE_VERSION = 6;
+    EXT_SCANNER = {
+      ".php": "laravel",
+      ".vue": "js-i18n",
+      ".js": "js-i18n",
+      ".ts": "js-i18n",
+      ".jsx": "js-i18n",
+      ".tsx": "js-i18n",
+      ".mjs": "js-i18n",
+      ".cjs": "js-i18n",
+      ".dart": "flutter",
+      ".py": "gettext",
+      ".c": "gettext",
+      ".cpp": "gettext",
+      ".h": "gettext",
+      ".swift": "apple",
+      ".m": "apple",
+      ".mm": "apple"
     };
+    ALWAYS_EXCLUDE = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      ".glotfile",
+      ".claude",
+      "dist",
+      "build",
+      "vendor",
+      "coverage",
+      ".next",
+      ".nuxt",
+      ".turbo",
+      "__pycache__"
+    ]);
+    FLUTTER_ACCESSOR_DEFAULTS = ["l10n", "loc", "localizations", "translations"];
+    KEY_SHAPE = /^[A-Za-z0-9_][A-Za-z0-9_/-]*(?:\.(?:[A-Za-z0-9_-]+|%[sd]))+\.?$/;
+    STRING_LITERALS = [
+      /'([^'\\\n]+)'/g,
+      /"([^"\\\n]+)"/g,
+      /`([^`\\\n]+)`/g
+    ];
   }
 });
 
@@ -4292,7 +4558,7 @@ var init_run2 = __esm({
 });
 
 // src/server/lint/outputs.ts
-import { readFileSync as readFileSync11, existsSync as existsSync10 } from "fs";
+import { readFileSync as readFileSync12, existsSync as existsSync11 } from "fs";
 import { resolve as resolve8 } from "path";
 function checkOutputs(state, root) {
   const out = [];
@@ -4300,7 +4566,7 @@ function checkOutputs(state, root) {
     const result = getAdapter(output.adapter).export(state, output);
     for (const file of result.files) {
       const abs = resolve8(root, file.path);
-      const current = existsSync10(abs) ? readFileSync11(abs, "utf8") : null;
+      const current = existsSync11(abs) ? readFileSync12(abs, "utf8") : null;
       if (current === null) {
         out.push({ ruleId: "output-stale", key: file.path, locale: "", severity: "error", message: "output file is missing; run `glotfile export`" });
       } else if (current !== file.contents) {
@@ -4345,8 +4611,8 @@ var init_accept = __esm({
 });
 
 // src/server/import/detect.ts
-import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync13, statSync as statSync3 } from "fs";
+import { join as join6 } from "path";
 function safeIsDir(p) {
   try {
     return statSync3(p).isDirectory();
@@ -4355,7 +4621,7 @@ function safeIsDir(p) {
   }
 }
 function listDirs(dir) {
-  return readdirSync4(dir).filter((e) => safeIsDir(join5(dir, e)));
+  return readdirSync4(dir).filter((e) => safeIsDir(join6(dir, e)));
 }
 function fileCount(dir) {
   try {
@@ -4369,23 +4635,23 @@ function pickSource(locales, sizeOf) {
   return [...locales].sort((a, b) => sizeOf(b) - sizeOf(a) || a.localeCompare(b))[0] ?? "en";
 }
 function detectLaravel(root) {
-  const localeRoot = [join5(root, "resources", "lang"), join5(root, "lang")].find(safeIsDir);
+  const localeRoot = [join6(root, "resources", "lang"), join6(root, "lang")].find(safeIsDir);
   if (!localeRoot) return null;
   const locales = listDirs(localeRoot).filter((d) => LOCALE_RE.test(d));
   if (locales.length === 0) return null;
-  const sourceLocale = pickSource(locales, (loc) => fileCount(join5(localeRoot, loc)));
+  const sourceLocale = pickSource(locales, (loc) => fileCount(join6(localeRoot, loc)));
   return { format: "laravel-php", localeRoot, locales, sourceLocale };
 }
 function detectVue(root, forced = false) {
   for (const rel of VUE_DIR_CANDIDATES) {
-    const localeRoot = join5(root, rel);
+    const localeRoot = join6(root, rel);
     if (!safeIsDir(localeRoot)) continue;
     const locales = readdirSync4(localeRoot).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5)).filter((l) => LOCALE_RE.test(l));
     const enough = locales.length >= 2 || locales.length === 1 && (forced || locales[0] === "en" || locales[0].startsWith("en-") || locales[0].startsWith("en_"));
     if (enough) {
       const sourceLocale = pickSource(locales, (loc) => {
         try {
-          return statSync3(join5(localeRoot, `${loc}.json`)).size;
+          return statSync3(join6(localeRoot, `${loc}.json`)).size;
         } catch {
           return 0;
         }
@@ -4397,7 +4663,7 @@ function detectVue(root, forced = false) {
 }
 function detectArb(root) {
   for (const rel of ["lib/l10n", "l10n", "lib/src/l10n"]) {
-    const localeRoot = join5(root, rel);
+    const localeRoot = join6(root, rel);
     if (!safeIsDir(localeRoot)) continue;
     const locales = readdirSync4(localeRoot).map((f) => f.match(/^(?:app_)?(.+)\.arb$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l));
     if (locales.length >= 1) {
@@ -4407,10 +4673,10 @@ function detectArb(root) {
   return null;
 }
 function lprojLocales(dir) {
-  return listDirs(dir).map((d) => d.match(/^(.+)\.lproj$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l) && existsSync11(join5(dir, `${l}.lproj`, "Localizable.strings")));
+  return listDirs(dir).map((d) => d.match(/^(.+)\.lproj$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l) && existsSync12(join6(dir, `${l}.lproj`, "Localizable.strings")));
 }
 function detectApple(root) {
-  const candidates = [root, ...listDirs(root).map((d) => join5(root, d))];
+  const candidates = [root, ...listDirs(root).map((d) => join6(root, d))];
   let best = null;
   for (const dir of candidates) {
     const locales = lprojLocales(dir);
@@ -4422,7 +4688,7 @@ function detectApple(root) {
         locales,
         sourceLocale: pickSource(locales, (loc) => {
           try {
-            return statSync3(join5(dir, `${loc}.lproj`, "Localizable.strings")).size;
+            return statSync3(join6(dir, `${loc}.lproj`, "Localizable.strings")).size;
           } catch {
             return 0;
           }
@@ -4434,7 +4700,7 @@ function detectApple(root) {
 }
 function detectAngularXliff(root) {
   for (const rel of ANGULAR_DIR_CANDIDATES) {
-    const localeRoot = rel === "." ? root : join5(root, rel);
+    const localeRoot = rel === "." ? root : join6(root, rel);
     if (!safeIsDir(localeRoot)) continue;
     const files = readdirSync4(localeRoot).filter((f) => /^messages(\..+)?\.xlf$/.test(f)).sort();
     if (files.length === 0) continue;
@@ -4442,7 +4708,7 @@ function detectAngularXliff(root) {
     const attrFile = files.includes("messages.xlf") ? "messages.xlf" : files[0];
     let sourceLocale;
     try {
-      sourceLocale = readFileSync12(join5(localeRoot, attrFile), "utf8").match(/source-language="([^"]+)"/)?.[1];
+      sourceLocale = readFileSync13(join6(localeRoot, attrFile), "utf8").match(/source-language="([^"]+)"/)?.[1];
     } catch {
     }
     if (!sourceLocale && locales.length === 0) continue;
@@ -4453,14 +4719,14 @@ function detectAngularXliff(root) {
   return null;
 }
 function detectRails(root) {
-  const localeRoot = join5(root, "config", "locales");
+  const localeRoot = join6(root, "config", "locales");
   if (!safeIsDir(localeRoot)) return null;
   const locales = [];
   for (const file of readdirSync4(localeRoot).sort()) {
     if (!/\.ya?ml$/.test(file)) continue;
     let text;
     try {
-      text = readFileSync12(join5(localeRoot, file), "utf8");
+      text = readFileSync13(join6(localeRoot, file), "utf8");
     } catch {
       continue;
     }
@@ -4474,15 +4740,15 @@ function detectRails(root) {
 }
 function detectI18next(root) {
   for (const rel of I18NEXT_DIR_CANDIDATES) {
-    const localeRoot = join5(root, rel);
+    const localeRoot = join6(root, rel);
     if (!safeIsDir(localeRoot)) continue;
     const locales = listDirs(localeRoot).filter(
-      (d) => LOCALE_RE.test(d) && readdirSync4(join5(localeRoot, d)).some((f) => f.endsWith(".json"))
+      (d) => LOCALE_RE.test(d) && readdirSync4(join6(localeRoot, d)).some((f) => f.endsWith(".json"))
     );
     if (locales.length === 0) continue;
     const sourceLocale = pickSource(locales, (loc) => {
       try {
-        return readdirSync4(join5(localeRoot, loc)).filter((f) => f.endsWith(".json")).reduce((sum, f) => sum + statSync3(join5(localeRoot, loc, f)).size, 0);
+        return readdirSync4(join6(localeRoot, loc)).filter((f) => f.endsWith(".json")).reduce((sum, f) => sum + statSync3(join6(localeRoot, loc, f)).size, 0);
       } catch {
         return 0;
       }
@@ -4499,8 +4765,8 @@ function gettextLocales(dir) {
       if (!locales.includes(flat)) locales.push(flat);
       continue;
     }
-    if (!LOCALE_RE.test(entry) || !safeIsDir(join5(dir, entry))) continue;
-    const sub = join5(dir, entry);
+    if (!LOCALE_RE.test(entry) || !safeIsDir(join6(dir, entry))) continue;
+    const sub = join6(dir, entry);
     const hasPo = (d) => {
       try {
         return readdirSync4(d).some((f) => f.endsWith(".po"));
@@ -4508,7 +4774,7 @@ function gettextLocales(dir) {
         return false;
       }
     };
-    if (hasPo(join5(sub, "LC_MESSAGES")) || hasPo(sub)) {
+    if (hasPo(join6(sub, "LC_MESSAGES")) || hasPo(sub)) {
       if (!locales.includes(entry)) locales.push(entry);
     }
   }
@@ -4516,7 +4782,7 @@ function gettextLocales(dir) {
 }
 function detectGettext(root) {
   for (const rel of GETTEXT_DIR_CANDIDATES) {
-    const localeRoot = join5(root, rel);
+    const localeRoot = join6(root, rel);
     if (!safeIsDir(localeRoot)) continue;
     const locales = gettextLocales(localeRoot);
     if (locales.length === 0) continue;
@@ -4525,10 +4791,10 @@ function detectGettext(root) {
   return null;
 }
 function detectAppleStringsdict(root) {
-  const candidates = [root, ...listDirs(root).map((d) => join5(root, d))];
+  const candidates = [root, ...listDirs(root).map((d) => join6(root, d))];
   let best = null;
   for (const dir of candidates) {
-    const locales = listDirs(dir).map((d) => d.match(/^(.+)\.lproj$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l) && existsSync11(join5(dir, `${l}.lproj`, "Localizable.stringsdict")));
+    const locales = listDirs(dir).map((d) => d.match(/^(.+)\.lproj$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l) && existsSync12(join6(dir, `${l}.lproj`, "Localizable.stringsdict")));
     if (locales.length === 0) continue;
     if (!best || locales.length > best.locales.length) {
       best = { format: "apple-stringsdict", localeRoot: dir, locales, sourceLocale: pickSource(locales, () => 0) };
@@ -4537,7 +4803,7 @@ function detectAppleStringsdict(root) {
   return best;
 }
 function detect(root, formatOverride) {
-  if (!existsSync11(root)) return null;
+  if (!existsSync12(root)) return null;
   if (formatOverride) {
     const fn = BY_FORMAT[formatOverride];
     if (!fn) throw new Error(`Unknown format: ${formatOverride}`);
@@ -4611,8 +4877,8 @@ var init_flatten = __esm({
 });
 
 // src/server/import/parsers/vue-i18n-json.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync13 } from "fs";
-import { join as join6 } from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync14 } from "fs";
+import { join as join7 } from "path";
 var LOCALE_RE2, vueI18nJson2;
 var init_vue_i18n_json2 = __esm({
   "src/server/import/parsers/vue-i18n-json.ts"() {
@@ -4632,7 +4898,7 @@ var init_vue_i18n_json2 = __esm({
           if (opts?.locales && !opts.locales.includes(locale)) continue;
           let data;
           try {
-            data = JSON.parse(readFileSync13(join6(localeRoot, file), "utf8"));
+            data = JSON.parse(readFileSync14(join7(localeRoot, file), "utf8"));
           } catch (e) {
             warnings.push(`vue-i18n-json: failed to parse ${file}: ${e.message}`);
             continue;
@@ -4660,16 +4926,16 @@ var init_placeholders2 = __esm({
 
 // src/server/import/parsers/laravel-php.ts
 import { readdirSync as readdirSync6, statSync as statSync4 } from "fs";
-import { join as join7, relative as relative2 } from "path";
+import { join as join8, relative as relative2 } from "path";
 import { execFileSync } from "child_process";
 function listDirs2(dir) {
-  return readdirSync6(dir).filter((e) => statSync4(join7(dir, e)).isDirectory());
+  return readdirSync6(dir).filter((e) => statSync4(join8(dir, e)).isDirectory());
 }
 function listPhpFiles(dir) {
   const out = [];
   const walk = (d) => {
     for (const e of readdirSync6(d)) {
-      const full = join7(d, e);
+      const full = join8(d, e);
       if (statSync4(full).isDirectory()) walk(full);
       else if (e.endsWith(".php")) out.push(full);
     }
@@ -4712,7 +4978,7 @@ var init_laravel_php2 = __esm({
         for (const locale of listDirs2(localeRoot).sort()) {
           if (locale === "vendor") continue;
           if (opts?.locales && !opts.locales.includes(locale)) continue;
-          const localeDir = join7(localeRoot, locale);
+          const localeDir = join8(localeRoot, locale);
           locales.push(locale);
           for (const file of listPhpFiles(localeDir)) {
             const group = relative2(localeDir, file).replace(/\\/g, "/").replace(/\.php$/, "");
@@ -4737,8 +5003,8 @@ var init_laravel_php2 = __esm({
 });
 
 // src/server/import/parsers/flutter-arb.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync14 } from "fs";
-import { join as join8 } from "path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync15 } from "fs";
+import { join as join9 } from "path";
 function localeFromArbName(file) {
   const m = file.match(/^(.+)\.arb$/);
   if (!m) return null;
@@ -4778,7 +5044,7 @@ var init_flutter_arb2 = __esm({
           if (opts?.locales && !opts.locales.includes(locale)) continue;
           let data;
           try {
-            data = JSON.parse(readFileSync14(join8(localeRoot, file), "utf8"));
+            data = JSON.parse(readFileSync15(join9(localeRoot, file), "utf8"));
           } catch (e) {
             warnings.push(`flutter-arb: failed to parse ${file}: ${e.message}`);
             continue;
@@ -4805,8 +5071,8 @@ var init_flutter_arb2 = __esm({
 });
 
 // src/server/import/parsers/apple-strings.ts
-import { readdirSync as readdirSync8, readFileSync as readFileSync15, statSync as statSync5 } from "fs";
-import { join as join9 } from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync16, statSync as statSync5 } from "fs";
+import { join as join10 } from "path";
 function localeFromLproj(dir) {
   const m = dir.match(/^(.+)\.lproj$/);
   if (!m) return null;
@@ -4914,16 +5180,16 @@ var init_apple_strings2 = __esm({
           const locale = localeFromLproj(dir);
           if (!locale) continue;
           if (opts?.locales && !opts.locales.includes(locale)) continue;
-          const file = join9(localeRoot, dir, TABLE);
+          const file = join10(localeRoot, dir, TABLE);
           let text;
           try {
             if (!statSync5(file).isFile()) continue;
-            text = readFileSync15(file, "utf8");
+            text = readFileSync16(file, "utf8");
           } catch {
             continue;
           }
           locales.push(locale);
-          const others = readdirSync8(join9(localeRoot, dir)).filter((f) => f.endsWith(".strings") && f !== TABLE);
+          const others = readdirSync8(join10(localeRoot, dir)).filter((f) => f.endsWith(".strings") && f !== TABLE);
           if (others.length) {
             warnings.push(`apple-strings: ${dir} has other .strings tables (${others.join(", ")}); only ${TABLE} is imported`);
           }
@@ -4938,8 +5204,8 @@ var init_apple_strings2 = __esm({
 });
 
 // src/server/import/parsers/angular-xliff.ts
-import { readdirSync as readdirSync9, readFileSync as readFileSync16 } from "fs";
-import { join as join10 } from "path";
+import { readdirSync as readdirSync9, readFileSync as readFileSync17 } from "fs";
+import { join as join11 } from "path";
 function decodeEntities(s) {
   return s.replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d))).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
 }
@@ -4991,7 +5257,7 @@ var init_angular_xliff2 = __esm({
           if (fnameLocale !== void 0 && !LOCALE_RE5.test(fnameLocale)) continue;
           let xml;
           try {
-            xml = readFileSync16(join10(localeRoot, file), "utf8");
+            xml = readFileSync17(join11(localeRoot, file), "utf8");
           } catch (e) {
             warnings.push(`angular-xliff: failed to read ${file}: ${e.message}`);
             continue;
@@ -5034,8 +5300,8 @@ var init_angular_xliff2 = __esm({
 });
 
 // src/server/import/parsers/gettext-po.ts
-import { readdirSync as readdirSync10, readFileSync as readFileSync17 } from "fs";
-import { join as join11 } from "path";
+import { readdirSync as readdirSync10, readFileSync as readFileSync18 } from "fs";
+import { join as join12 } from "path";
 function unescapePo(s) {
   return s.replace(
     /\\([\\"ntr])/g,
@@ -5106,17 +5372,17 @@ function discoverPoFiles(root) {
   for (const e of entries) {
     if (e.isFile() && e.name.endsWith(".po")) {
       const base = e.name.slice(0, -3);
-      found.push({ path: join11(root, e.name), rel: e.name, locale: LOCALE_RE6.test(base) ? base : null });
+      found.push({ path: join12(root, e.name), rel: e.name, locale: LOCALE_RE6.test(base) ? base : null });
     } else if (e.isDirectory() && LOCALE_RE6.test(e.name)) {
-      for (const sub of [join11(e.name, "LC_MESSAGES"), e.name]) {
+      for (const sub of [join12(e.name, "LC_MESSAGES"), e.name]) {
         let names;
         try {
-          names = readdirSync10(join11(root, sub)).sort();
+          names = readdirSync10(join12(root, sub)).sort();
         } catch {
           continue;
         }
         for (const f of names) {
-          if (f.endsWith(".po")) found.push({ path: join11(root, sub, f), rel: join11(sub, f), locale: e.name });
+          if (f.endsWith(".po")) found.push({ path: join12(root, sub, f), rel: join12(sub, f), locale: e.name });
         }
       }
     }
@@ -5140,7 +5406,7 @@ var init_gettext_po2 = __esm({
         for (const file of discoverPoFiles(localeRoot)) {
           let entries;
           try {
-            entries = parseEntries(readFileSync17(file.path, "utf8"));
+            entries = parseEntries(readFileSync18(file.path, "utf8"));
           } catch (e) {
             warnings.push(`gettext-po: failed to parse ${file.rel}: ${e.message}`);
             continue;
@@ -5187,8 +5453,8 @@ var init_gettext_po2 = __esm({
 });
 
 // src/server/import/parsers/i18next-json.ts
-import { readdirSync as readdirSync11, readFileSync as readFileSync18, statSync as statSync6 } from "fs";
-import { join as join12 } from "path";
+import { readdirSync as readdirSync11, readFileSync as readFileSync19, statSync as statSync6 } from "fs";
+import { join as join13 } from "path";
 function safeIsDir2(p) {
   try {
     return statSync6(p).isDirectory();
@@ -5203,7 +5469,7 @@ function fromI18next(value) {
 function ingestFile(path, label, prefix, locale, keys, warnings) {
   let data;
   try {
-    data = JSON.parse(readFileSync18(path, "utf8"));
+    data = JSON.parse(readFileSync19(path, "utf8"));
   } catch (e) {
     warnings.push(`i18next-json: failed to parse ${label}: ${e.message}`);
     return false;
@@ -5256,7 +5522,7 @@ var init_i18next_json2 = __esm({
         const keys = {};
         const locales = [];
         for (const entry of readdirSync11(localeRoot).sort()) {
-          const full = join12(localeRoot, entry);
+          const full = join13(localeRoot, entry);
           if (safeIsDir2(full)) {
             if (!LOCALE_RE7.test(entry)) continue;
             if (opts?.locales && !opts.locales.includes(entry)) continue;
@@ -5265,7 +5531,7 @@ var init_i18next_json2 = __esm({
               if (!file.endsWith(".json")) continue;
               const ns = file.slice(0, -".json".length);
               const prefix = ns === DEFAULT_NAMESPACE ? "" : `${ns}.`;
-              if (ingestFile(join12(full, file), `${entry}/${file}`, prefix, entry, keys, warnings)) any = true;
+              if (ingestFile(join13(full, file), `${entry}/${file}`, prefix, entry, keys, warnings)) any = true;
             }
             if (any && !locales.includes(entry)) locales.push(entry);
           } else if (entry.endsWith(".json")) {
@@ -5284,8 +5550,8 @@ var init_i18next_json2 = __esm({
 });
 
 // src/server/import/parsers/rails-yaml.ts
-import { readdirSync as readdirSync12, readFileSync as readFileSync19 } from "fs";
-import { join as join13 } from "path";
+import { readdirSync as readdirSync12, readFileSync as readFileSync20 } from "fs";
+import { join as join14 } from "path";
 function fromRuby(value) {
   return value.replace(/%\{(\w+)\}/g, "{$1}");
 }
@@ -5502,7 +5768,7 @@ var init_rails_yaml2 = __esm({
           if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
           let text;
           try {
-            text = readFileSync19(join13(localeRoot, file), "utf8");
+            text = readFileSync20(join14(localeRoot, file), "utf8");
           } catch (e) {
             warnings.push(`rails-yaml: failed to read ${file}: ${e.message}`);
             continue;
@@ -5525,8 +5791,8 @@ var init_rails_yaml2 = __esm({
 });
 
 // src/server/import/parsers/apple-stringsdict.ts
-import { readdirSync as readdirSync13, readFileSync as readFileSync20, statSync as statSync7 } from "fs";
-import { join as join14 } from "path";
+import { readdirSync as readdirSync13, readFileSync as readFileSync21, statSync as statSync7 } from "fs";
+import { join as join15 } from "path";
 function localeFromLproj2(dir) {
   const m = dir.match(/^(.+)\.lproj$/);
   if (!m) return null;
@@ -5668,16 +5934,16 @@ var init_apple_stringsdict2 = __esm({
           const locale = localeFromLproj2(dir);
           if (!locale) continue;
           if (opts?.locales && !opts.locales.includes(locale)) continue;
-          const file = join14(localeRoot, dir, TABLE2);
+          const file = join15(localeRoot, dir, TABLE2);
           let text;
           try {
             if (!statSync7(file).isFile()) continue;
-            text = readFileSync20(file, "utf8");
+            text = readFileSync21(file, "utf8");
           } catch {
             continue;
           }
           locales.push(locale);
-          const others = readdirSync13(join14(localeRoot, dir)).filter(
+          const others = readdirSync13(join15(localeRoot, dir)).filter(
             (f) => f.endsWith(".stringsdict") && f !== TABLE2
           );
           if (others.length) {
@@ -6136,12 +6402,12 @@ var init_checks = __esm({
 });
 
 // src/server/ui-prefs.ts
-import { readFileSync as readFileSync21 } from "fs";
+import { readFileSync as readFileSync22 } from "fs";
 import { homedir } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 function readJson2(path) {
   try {
-    const parsed = JSON.parse(readFileSync21(path, "utf8"));
+    const parsed = JSON.parse(readFileSync22(path, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -6166,7 +6432,7 @@ var init_ui_prefs = __esm({
     THEMES = ["system", "light", "dark"];
     isThemeMode = (v) => THEMES.includes(v);
     isPanelWidth = (v) => typeof v === "number" && Number.isFinite(v) && v >= 120 && v <= 1200;
-    defaultUiPrefsPath = () => join15(homedir(), ".glotfile", "ui.json");
+    defaultUiPrefsPath = () => join16(homedir(), ".glotfile", "ui.json");
     DEFAULTS = { theme: "system" };
   }
 });
@@ -6174,19 +6440,34 @@ var init_ui_prefs = __esm({
 // src/server/api.ts
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
-import { readFileSync as readFileSync22, existsSync as existsSync12, readdirSync as readdirSync14, statSync as statSync8, rmSync as rmSync5 } from "fs";
+import { readFileSync as readFileSync23, existsSync as existsSync13, readdirSync as readdirSync14, statSync as statSync8, rmSync as rmSync6 } from "fs";
 import { dirname as dirname3, resolve as resolve9, basename, relative as relative4, sep as sep2 } from "path";
 function projectName(root) {
   const nameFile = resolve9(root, ".idea", ".name");
-  if (existsSync12(nameFile)) {
+  if (existsSync13(nameFile)) {
     try {
-      const name = readFileSync22(nameFile, "utf8").trim();
+      const name = readFileSync23(nameFile, "utf8").trim();
       if (name) return name;
     } catch {
     }
   }
   return basename(root);
 }
+function attachUsageSnippets(targets, cache2, projectRoot) {
+  const fileCache = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const allRefs = Object.entries(cache2.files).flatMap(
+      ([file, entry]) => entry.refs.filter((r) => r.key === target.key).map((r) => ({
+        key: r.key,
+        file,
+        line: r.line,
+        col: r.col,
+        scanner: r.scanner
+      }))
+    );
+    target.usageSnippets = extractSnippets(allRefs, projectRoot, fileCache);
+  }
+}
 function createApi(deps) {
   const app = new Hono();
   const load = () => loadState(deps.statePath);
@@ -6313,7 +6594,7 @@ function createApi(deps) {
         if (name.startsWith(".") || name === "node_modules") continue;
         const abs = resolve9(dir, name);
         let filePath = null;
-        if ((name === "glotfile" || name.endsWith(".glotfile")) && existsSync12(resolve9(abs, "config.json"))) {
+        if ((name === "glotfile" || name.endsWith(".glotfile")) && existsSync13(resolve9(abs, "config.json"))) {
           filePath = resolve9(dir, `${name}.json`);
         } else if (name === "glotfile.json" || name.endsWith(".glotfile.json")) {
           filePath = abs;
@@ -6347,7 +6628,7 @@ function createApi(deps) {
     const resolved = resolve9(projectRoot, path);
     const inside = resolved === projectRoot || resolved.startsWith(projectRoot + sep2);
     if (!inside) return c.json({ error: "file is outside the project" }, 400);
-    if (!existsSync12(resolved)) return c.json({ error: "file not found" }, 400);
+    if (!existsSync13(resolved)) return c.json({ error: "file not found" }, 400);
     loadState(resolved);
     deps.statePath = resolved;
     return c.json({ ok: true, path: resolved, name: basename(resolved), dir: projectRoot, project: basename(projectRoot) });
@@ -6408,9 +6689,9 @@ function createApi(deps) {
     const abs = resolve9(root, screenshot);
     const rel = relative4(root, abs);
     const seg0 = rel.split(sep2)[0] ?? "";
-    if (!rel.startsWith("..") && seg0.endsWith("-screenshots") && existsSync12(abs)) {
+    if (!rel.startsWith("..") && seg0.endsWith("-screenshots") && existsSync13(abs)) {
       try {
-        rmSync5(abs);
+        rmSync6(abs);
       } catch {
       }
     }
@@ -6836,6 +7117,7 @@ function createApi(deps) {
           persist(fresh);
           totalWritten += written;
           allErrors.push(...errors);
+          const usage = provider.takeUsage?.();
           appendLog(projectRoot, {
             at: (/* @__PURE__ */ new Date()).toISOString(),
             kind: "translate",
@@ -6846,7 +7128,9 @@ function createApi(deps) {
               const req = reqById.get(r.id);
               return { id: r.id, key: req?.key ?? "", source: req?.source ?? "", targetLocale: req?.targetLocale, context: req?.context, glossary: req?.glossary, screenshot: req ? fresh.keys[req.key]?.screenshot : void 0 };
             }),
-            results: batchResults
+            results: batchResults,
+            usage,
+            estimatedCostUsd: usageCostUsd(usage, aiCfg)
           });
           const ld = (localeDone.get(locale) ?? 0) + batchResults.length;
           localeDone.set(locale, ld);
@@ -6918,11 +7202,14 @@ function createApi(deps) {
       }, aiCfg.concurrency, void 0, aiCfg.batchSize);
       const latest = load();
       ({ written, errors } = applyResults(latest, toTranslate, results, void 0, force));
+      const usage = provider.takeUsage?.();
       const entry = {
         at: (/* @__PURE__ */ new Date()).toISOString(),
         kind: "translate",
         summary: `Translated ${toTranslate.length} item(s)`,
         model: aiCfg.model,
+        usage,
+        estimatedCostUsd: usageCostUsd(usage, aiCfg),
         system: buildSystemPrompt(toTranslate.some((r) => r.plural !== void 0)),
         // Log the screenshot PATH only — never the image bytes.
         items: toTranslate.map((r) => ({
@@ -7020,17 +7307,7 @@ function createApi(deps) {
     if (!supportsBatchTranslate(provider)) {
       return c.json({ error: `Provider "${aiCfg.provider}" does not support batch mode.` }, 400);
     }
-    const outcome = await applyBatchResults(load, persist, provider, pending, projectRoot, {
-      batchSize: aiCfg.batchSize,
-      concurrency: aiCfg.concurrency
-    });
-    appendLog(projectRoot, {
-      at: (/* @__PURE__ */ new Date()).toISOString(),
-      kind: "translate",
-      summary: `Applied batch ${pending.batchId}: wrote ${outcome.written}, ${outcome.retried} retried, ${outcome.staleSkipped} stale`,
-      model: aiCfg.model,
-      results: []
-    });
+    const outcome = await applyBatchResults(load, persist, provider, pending, projectRoot, aiCfg);
     console.log(`[batch] applied ${pending.batchId} \u2014 wrote ${outcome.written}, ${outcome.errors.length} error(s)`);
     return c.json(outcome);
   }));
@@ -7142,19 +7419,7 @@ function createApi(deps) {
         return;
       }
       await stream.writeSSE({ event: "start", data: JSON.stringify({ total: targets.length }) });
-      const fileCache = /* @__PURE__ */ new Map();
-      for (const target of targets) {
-        const allRefs = Object.entries(cache2.files).flatMap(
-          ([file, entry]) => entry.refs.filter((r) => r.key === target.key).map((r) => ({
-            key: r.key,
-            file,
-            line: r.line,
-            col: r.col,
-            scanner: r.scanner
-          }))
-        );
-        target.usageSnippets = extractSnippets(allRefs, projectRoot, fileCache);
-      }
+      attachUsageSnippets(targets, cache2, projectRoot);
       const system = buildContextSystemPrompt();
       const batchSize = aiCfg.contextBatchSize ?? aiCfg.batchSize ?? 10;
       const concurrency = aiCfg.contextConcurrency ?? aiCfg.concurrency ?? 3;
@@ -7181,6 +7446,7 @@ function createApi(deps) {
           const batch = raw;
           const fresh = load();
           const { written, errors } = applyContext(fresh, chunk2, batch.items ?? [], void 0, body.force === true);
+          const usage = provider.takeUsage?.();
           appendLog(projectRoot, {
             at: (/* @__PURE__ */ new Date()).toISOString(),
             kind: "context",
@@ -7188,7 +7454,9 @@ function createApi(deps) {
             model: aiCfg.model,
             system,
             items: chunk2.map((t) => ({ id: t.id, key: t.key, source: t.source })),
-            results: (batch.items ?? []).map((r) => ({ id: r.id, value: r.context, error: r.error }))
+            results: (batch.items ?? []).map((r) => ({ id: r.id, value: r.context, error: r.error })),
+            usage,
+            estimatedCostUsd: usageCostUsd(usage, aiCfg)
           });
           persist(fresh);
           totalWritten += written;
@@ -7203,6 +7471,100 @@ function createApi(deps) {
       await stream.writeSSE({ event: "done", data: JSON.stringify({ requested: targets.length, written: totalWritten, errors: allErrors }) });
     });
   });
+  app.get("/context/batch/status", async (c) => {
+    const aiCfg = loadLocalSettings(projectRoot).ai;
+    let supported = false;
+    let provider;
+    try {
+      provider = deps.makeProvider ? deps.makeProvider() : makeProvider(aiCfg);
+      supported = supportsBatchComplete(provider);
+    } catch {
+    }
+    const pending = loadPendingContextBatch(projectRoot);
+    if (!pending) return c.json({ supported, pending: null });
+    const base = { batchId: pending.batchId, createdAt: pending.createdAt, model: pending.model, total: pending.total };
+    if (!provider || !supportsBatchComplete(provider)) {
+      return c.json({ supported, pending: { ...base, status: "unknown", counts: null } });
+    }
+    try {
+      const status = await provider.translationBatchStatus(pending.batchId);
+      return c.json({ supported, pending: { ...base, status: status.status, counts: status.counts } });
+    } catch (e) {
+      return c.json({ supported, pending: { ...base, status: "unknown", counts: null, error: e.message } });
+    }
+  });
+  app.post("/context/batch", (c) => withTranslateLock(async () => {
+    const body = await c.req.json().catch(() => ({}));
+    const s = load();
+    const cache2 = loadUsageCache(projectRoot);
+    if (!cache2) return c.json({ error: "No usage index found. Run 'glotfile scan' first." }, 400);
+    const targets = selectContextTargets(s, {
+      all: body.all,
+      keyGlob: body.keyGlob,
+      limit: body.limit,
+      since: body.since,
+      keys: body.keys,
+      force: body.force
+    }, cache2, body.lastRunAt);
+    if (!targets.length) return c.json({ error: "Nothing to build." }, 400);
+    const aiCfg = loadLocalSettings(projectRoot).ai;
+    let provider;
+    try {
+      provider = deps.makeProvider ? deps.makeProvider() : makeProvider(aiCfg);
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+    if (!supportsBatchComplete(provider)) {
+      return c.json({ error: `Provider "${aiCfg.provider}" does not support batch mode.` }, 400);
+    }
+    attachUsageSnippets(targets, cache2, projectRoot);
+    const batchSize = aiCfg.contextBatchSize ?? aiCfg.batchSize ?? 10;
+    let pending;
+    try {
+      pending = await submitContextBatch(provider, targets, batchSize, aiCfg.model, projectRoot, body.force === true);
+    } catch (e) {
+      return c.json({ error: e.message }, 409);
+    }
+    appendLog(projectRoot, {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      kind: "context",
+      summary: `Submitted context batch ${pending.batchId} (${pending.total} keys)`,
+      model: aiCfg.model,
+      system: buildContextSystemPrompt(),
+      items: targets.map((t) => ({ id: t.id, key: t.key, source: t.source }))
+    });
+    console.log(`[context-batch] submitted ${pending.batchId} \u2014 ${pending.total} key(s)`);
+    return c.json({ batchId: pending.batchId, total: pending.total });
+  }));
+  app.post("/context/batch/apply", (c) => withTranslateLock(async () => {
+    const pending = loadPendingContextBatch(projectRoot);
+    if (!pending) return c.json({ error: "No pending context batch." }, 404);
+    const aiCfg = loadLocalSettings(projectRoot).ai;
+    let provider;
+    try {
+      provider = deps.makeProvider ? deps.makeProvider() : makeProvider(aiCfg);
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+    if (!supportsBatchComplete(provider)) {
+      return c.json({ error: `Provider "${aiCfg.provider}" does not support batch mode.` }, 400);
+    }
+    const outcome = await applyContextBatchResults(load, persist, provider, pending, projectRoot, aiCfg);
+    console.log(`[context-batch] applied ${pending.batchId} \u2014 wrote ${outcome.written}, ${outcome.errors.length} error(s)`);
+    return c.json(outcome);
+  }));
+  app.post("/context/batch/cancel", async (c) => {
+    const pending = loadPendingContextBatch(projectRoot);
+    if (!pending) return c.json({ error: "No pending context batch." }, 404);
+    const aiCfg = loadLocalSettings(projectRoot).ai;
+    try {
+      const provider = deps.makeProvider ? deps.makeProvider() : makeProvider(aiCfg);
+      if (supportsBatchComplete(provider)) await provider.cancelTranslationBatch(pending.batchId);
+    } catch {
+    }
+    clearPendingContextBatch(projectRoot);
+    return c.json({ canceled: pending.batchId });
+  });
   app.onError(
     (err, c) => c.json({ error: err.message }, err instanceof GlotfileError ? 400 : 500)
   );
@@ -7228,7 +7590,10 @@ var init_api = __esm({
     init_provider();
     init_batch_run();
     init_pending_batch();
+    init_context_batch_run();
+    init_pending_context_batch();
     init_estimate();
+    init_pricing();
     init_log();
     init_schema();
     init_run3();
@@ -7250,7 +7615,7 @@ __export(server_exports, {
 import { Hono as Hono2 } from "hono";
 import { serve } from "@hono/node-server";
 import { fileURLToPath } from "url";
-import { dirname as dirname4, join as join16, resolve as resolve10, extname as extname3, sep as sep3 } from "path";
+import { dirname as dirname4, join as join17, resolve as resolve10, extname as extname3, sep as sep3 } from "path";
 import { readFile, stat } from "fs/promises";
 import { createServer } from "net";
 import open from "open";
@@ -7293,7 +7658,7 @@ function buildApp(opts) {
         const file = await readFileResponse(target);
         if (file) return file;
       }
-      const index = await readFileResponse(join16(root, "index.html"));
+      const index = await readFileResponse(join17(root, "index.html"));
       if (index) return index;
       return c.notFound();
     });
@@ -7351,7 +7716,7 @@ var init_server = __esm({
     init_scan();
     init_scanner();
     here = dirname4(fileURLToPath(import.meta.url));
-    DEFAULT_UI_DIR = join16(here, "..", "ui");
+    DEFAULT_UI_DIR = join17(here, "..", "ui");
     MIME = {
       ".html": "text/html; charset=utf-8",
       ".js": "text/javascript; charset=utf-8",
@@ -7390,15 +7755,18 @@ init_run();
 init_provider();
 init_batch_run();
 init_pending_batch();
+init_context_batch_run();
+init_pending_context_batch();
 init_estimate();
+init_pricing();
 init_log();
 init_scan();
 init_scanner();
 init_context();
 init_run2();
 init_outputs();
-import { resolve as resolve11, dirname as dirname5, join as join17 } from "path";
-import { readFileSync as readFileSync23, existsSync as existsSync13, mkdirSync as mkdirSync5, cpSync } from "fs";
+import { resolve as resolve11, dirname as dirname5, join as join18 } from "path";
+import { readFileSync as readFileSync24, existsSync as existsSync14, mkdirSync as mkdirSync6, cpSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/server/lint/locate.ts
@@ -7713,11 +8081,14 @@ async function runTranslate(args) {
     if (!batchCallbackFired) {
       ({ written, errors } = applyResults(state, toTranslate, results));
     }
+    const usage = provider.takeUsage?.();
     appendLog(projectRoot, {
       at: (/* @__PURE__ */ new Date()).toISOString(),
       kind: "translate",
       summary: `Translated ${toTranslate.length} item(s)`,
       model: ai.model,
+      usage,
+      estimatedCostUsd: usageCostUsd(usage, ai),
       system: buildSystemPrompt(toTranslate.some((r) => r.plural !== void 0)),
       items: toTranslate.map((r) => ({
         id: r.id,
@@ -7752,7 +8123,7 @@ async function applyPending(args, provider, pending, ai) {
     provider,
     pending,
     projectRoot,
-    { batchSize: ai.batchSize, concurrency: ai.concurrency }
+    ai
   );
   reportApply(outcome);
 }
@@ -7770,11 +8141,16 @@ async function waitAndApply(args, provider, pending, ai) {
 async function runBatch(args) {
   const projectRoot = dirname5(resolve11(args.statePath));
   const pending = loadPendingBatch(projectRoot);
-  if (!pending) {
-    console.log("No pending batch. Start one with `glotfile translate --batch`.");
+  const ctxPending = loadPendingContextBatch(projectRoot);
+  if (!pending && !ctxPending) {
+    console.log("No pending batch. Start one with `glotfile translate --batch` or `glotfile build-context --batch`.");
     return;
   }
   const action = args.batchAction ?? "status";
+  if (pending) await runTranslationBatchAction(args, pending, action, projectRoot);
+  if (ctxPending) await runContextBatchAction(args, ctxPending, action, projectRoot);
+}
+async function runTranslationBatchAction(args, pending, action, projectRoot) {
   if (action === "cancel") {
     let remoteFailed = false;
     try {
@@ -7811,6 +8187,53 @@ async function runBatch(args) {
   }
   await applyPending(args, provider, pending, ai);
 }
+async function runContextBatchAction(args, pending, action, projectRoot) {
+  if (action === "cancel") {
+    let remoteFailed = false;
+    try {
+      const ai2 = loadLocalSettings(projectRoot).ai;
+      const provider2 = makeProvider(ai2);
+      if (supportsBatchComplete(provider2)) {
+        await provider2.cancelTranslationBatch(pending.batchId);
+      } else {
+        remoteFailed = true;
+      }
+    } catch {
+      remoteFailed = true;
+    }
+    clearPendingContextBatch(projectRoot);
+    const suffix = remoteFailed ? " (remote cancel failed \u2014 it will expire server-side)" : "";
+    console.log(`Canceled context batch ${pending.batchId}.${suffix}`);
+    return;
+  }
+  const ai = loadLocalSettings(projectRoot).ai;
+  const provider = makeProviderOrExit(ai);
+  if (!provider) return;
+  if (!supportsBatchComplete(provider)) {
+    console.error(`Pending context batch was submitted via anthropic, but the configured provider "${ai.provider}" has no batch support.`);
+    process.exitCode = 1;
+    return;
+  }
+  const status = await provider.translationBatchStatus(pending.batchId);
+  const c = status.counts;
+  console.log(`Context batch ${pending.batchId} (${pending.total} key(s), submitted ${pending.createdAt})`);
+  console.log(`  ${status.status} \u2014 ${c.succeeded} succeeded, ${c.processing} processing, ${c.errored} errored, ${c.expired} expired, ${c.canceled} canceled`);
+  if (status.status !== "ended") {
+    if (action === "apply") console.log("Not finished yet \u2014 try again later.");
+    return;
+  }
+  const outcome = await applyContextBatchResults(
+    () => loadState(args.statePath),
+    (s) => saveState(args.statePath, s),
+    provider,
+    pending,
+    projectRoot,
+    ai
+  );
+  console.log(`Wrote context for ${outcome.written} key(s).`);
+  if (outcome.retried) console.log(`${outcome.retried} job(s) re-run synchronously (batch entries failed or were malformed).`);
+  for (const e of outcome.errors) console.warn(`skip ${e.key}: ${e.error}`);
+}
 function printReport(report, format, rawText) {
   if (format === "json") console.log(formatJson(report).trimEnd());
   else if (format === "sarif") console.log(formatSarif(report, rawText).trimEnd());
@@ -7830,7 +8253,7 @@ async function runLintCmd(args) {
     }
     return;
   }
-  const rawText = existsSync13(args.statePath) ? readFileSync23(args.statePath, "utf8") : "";
+  const rawText = existsSync14(args.statePath) ? readFileSync24(args.statePath, "utf8") : "";
   const report = await runLint(state, {
     locales: args.locales,
     ruleIds: args.ruleIds,
@@ -7854,7 +8277,7 @@ async function runCheck(args) {
     process.exitCode = 1;
     return;
   }
-  const rawText = existsSync13(args.statePath) ? readFileSync23(args.statePath, "utf8") : "";
+  const rawText = existsSync14(args.statePath) ? readFileSync24(args.statePath, "utf8") : "";
   const root = dirname5(resolve11(args.statePath));
   const lint = await runLint(state, {});
   const findings = sortFindings([...lint.findings, ...checkOutputs(state, root)]);
@@ -7867,7 +8290,7 @@ async function runImportCmd(args) {
   const { runImport: runImport2 } = await Promise.resolve().then(() => (init_run3(), run_exports));
   const projectRoot = args.importSource ? resolve11(args.importSource) : dirname5(resolve11(args.statePath));
   const out = resolve11(projectRoot, "glotfile.json");
-  if (existsSync13(out) && !args.importForce) {
+  if (existsSync14(out) && !args.importForce) {
     console.error(`${out} already exists; pass --force to overwrite`);
     process.exitCode = 1;
     return;
@@ -7934,6 +8357,32 @@ async function runBuildContext(args) {
   const aiCfg = loadLocalSettings(projectRoot).ai;
   const batchSize = aiCfg.contextBatchSize ?? aiCfg.batchSize ?? 10;
   const concurrency = aiCfg.contextConcurrency ?? aiCfg.concurrency ?? 3;
+  if (args.batch) {
+    if (!supportsBatchComplete(provider)) {
+      console.error(`Provider "${aiCfg.provider}" does not support batch mode. Currently anthropic only.`);
+      process.exitCode = 1;
+      return;
+    }
+    let pending;
+    try {
+      pending = await submitContextBatch(provider, targets, batchSize, aiCfg.model, projectRoot, false);
+    } catch (e) {
+      console.error(e.message);
+      process.exitCode = 1;
+      return;
+    }
+    appendLog(projectRoot, {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      kind: "context",
+      summary: `Submitted context batch ${pending.batchId} (${pending.total} keys)`,
+      model: aiCfg.model,
+      system,
+      items: targets.map((t) => ({ id: t.id, key: t.key, source: t.source }))
+    });
+    console.log(`Submitted context batch ${pending.batchId} \u2014 ${pending.total} key(s) at 50% batch pricing.`);
+    console.log("Check progress with `glotfile batch`; it applies results automatically when finished.");
+    return;
+  }
   const chunks = [];
   for (let i = 0; i < targets.length; i += batchSize) chunks.push(targets.slice(i, i + batchSize));
   let written = 0;
@@ -8015,19 +8464,19 @@ function runSplit(args) {
     `Split catalog into ${splitDirFor(args.statePath)}/ (config.json, keys.json, locales/ \u2014 up to ${state.config.locales.length} locale files). Removed ${args.statePath}.`
   );
 }
-var SKILL_SRC = join17(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "skill");
+var SKILL_SRC = join18(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "skill");
 function runSkill(args) {
   if (args.print) {
-    console.log(readFileSync23(join17(SKILL_SRC, "SKILL.md"), "utf8").trimEnd());
+    console.log(readFileSync24(join18(SKILL_SRC, "SKILL.md"), "utf8").trimEnd());
     return;
   }
   const dest = resolve11(process.cwd(), ".claude", "skills", "glotfile");
-  if (existsSync13(dest) && !args.importForce) {
+  if (existsSync14(dest) && !args.importForce) {
     console.error(`${dest} already exists; pass --force to overwrite`);
     process.exitCode = 1;
     return;
   }
-  mkdirSync5(dirname5(dest), { recursive: true });
+  mkdirSync6(dirname5(dest), { recursive: true });
   cpSync(SKILL_SRC, dest, { recursive: true });
   console.log(`Installed the glotfile skill to ${dest}. Restart Claude Code to pick it up.`);
 }
@@ -8092,7 +8541,7 @@ var COMMAND_HELP = {
   },
   "build-context": {
     summary: "AI-generate per-key context to improve translation (requires a prior scan).",
-    usage: "glotfile build-context [--all] [--key <glob>] [--limit <n>] [--since <date>]",
+    usage: "glotfile build-context [--all] [--key <glob>] [--limit <n>] [--since <date>] [--batch]",
     options: [
       ["--all", "(Re)build context for every key, not just those missing it"],
       ["--key <glob>", "Only keys matching this glob"],
@@ -8167,8 +8616,8 @@ ${formatOpts([...options, ...GLOBAL_OPTS])}`);
   );
 }
 function printVersion() {
-  const pkgPath = join17(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "package.json");
-  console.log(JSON.parse(readFileSync23(pkgPath, "utf8")).version);
+  const pkgPath = join18(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "package.json");
+  console.log(JSON.parse(readFileSync24(pkgPath, "utf8")).version);
 }
 async function main(argv) {
   const args = parseArgs(argv);