glotfile 0.2.0 → 0.3.1

package/dist/server/cli.js

@@ -31,6 +31,32 @@ var init_format = __esm({
   }
 });
 
+// src/server/atomic-write.ts
+import { writeFileSync, renameSync, mkdirSync, rmSync } from "fs";
+import { dirname, join } from "path";
+function writeFileAtomic(path, data) {
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true });
+  const tmp = join(dir, `.${process.pid}.${counter++}.tmp`);
+  try {
+    writeFileSync(tmp, data);
+    renameSync(tmp, path);
+  } catch (e) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+    }
+    throw e;
+  }
+}
+var counter;
+var init_atomic_write = __esm({
+  "src/server/atomic-write.ts"() {
+    "use strict";
+    counter = 0;
+  }
+});
+
 // src/server/lint/registry.ts
 var RULE_IDS, DEFAULT_SEVERITY;
 var init_registry = __esm({
@@ -117,17 +143,6 @@ function validate(raw) {
       }
     }
   }
-  if (!isObject(config.ai)) fail("config.ai must be an object");
-  const ai = config.ai;
-  if (typeof ai.provider !== "string" || !PROVIDERS.includes(ai.provider)) {
-    fail(`config.ai.provider must be one of: ${PROVIDERS.join(", ")}`);
-  }
-  if (typeof ai.model !== "string") fail("config.ai.model must be a string");
-  if (!(ai.endpoint === null || typeof ai.endpoint === "string")) fail("config.ai.endpoint must be a string or null");
-  if (!(ai.region === void 0 || ai.region === null || typeof ai.region === "string")) {
-    fail("config.ai.region must be a string or null");
-  }
-  if (typeof ai.batchSize !== "number") fail("config.ai.batchSize must be a number");
   if (!isObject(config.format)) fail("config.format must be an object");
   const fmt = config.format;
   if (typeof fmt.indent !== "number") fail("config.format.indent must be a number");
@@ -258,7 +273,6 @@ function defaultState() {
         { adapter: "flutter-arb", path: "lib/l10n/app_{locale}.arb" },
         { adapter: "laravel-php", path: "lang/{locale}/{namespace}.php" }
       ],
-      ai: { provider: "anthropic", model: "claude-haiku-4-5-20251001", endpoint: null, region: null, batchSize: 25 },
       format: { indent: 2, sortKeys: true, finalNewline: true },
       spelling: { customWords: [] },
       autoExport: true
@@ -277,7 +291,7 @@ var init_schema = __esm({
     PLURAL_CATEGORIES = ["zero", "one", "two", "few", "many", "other"];
     EXACT_SELECTOR_RE = /^=\d+$/;
     LOCALE_CASES = ["lower-hyphen", "lower-underscore", "bcp47-hyphen", "bcp47-underscore"];
-    PROVIDERS = ["anthropic", "openai", "bedrock", "openrouter"];
+    PROVIDERS = ["anthropic", "openai", "bedrock", "openrouter", "ollama", "claude-code"];
     GlotfileError = class extends Error {
     };
   }
@@ -402,13 +416,13 @@ var init_plurals = __esm({
 });
 
 // src/server/storage.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync } from "fs";
-import { join, dirname } from "path";
+import { existsSync, readFileSync, mkdirSync as mkdirSync2, readdirSync, rmSync as rmSync2 } from "fs";
+import { join as join2 } from "path";
 function splitDirFor(statePath) {
   return statePath.replace(/\.json$/i, "");
 }
 function detectFormat(statePath) {
-  if (existsSync(join(splitDirFor(statePath), "config.json"))) return "split";
+  if (existsSync(join2(splitDirFor(statePath), "config.json"))) return "split";
   if (existsSync(statePath)) return "single";
   return "none";
 }
@@ -438,15 +452,15 @@ function assemble(parts) {
   return { ...parts.manifest, keys };
 }
 function loadSplit(splitDir) {
-  const readJson = (p) => JSON.parse(readFileSync(p, "utf8"));
-  const manifest = readJson(join(splitDir, "config.json"));
-  const keysPath = join(splitDir, "keys.json");
-  const keys = existsSync(keysPath) ? readJson(keysPath) : {};
-  const localesDir = join(splitDir, "locales");
+  const readJson3 = (p) => JSON.parse(readFileSync(p, "utf8"));
+  const manifest = readJson3(join2(splitDir, "config.json"));
+  const keysPath = join2(splitDir, "keys.json");
+  const keys = existsSync(keysPath) ? readJson3(keysPath) : {};
+  const localesDir = join2(splitDir, "locales");
   const locales = {};
   if (existsSync(localesDir)) {
     for (const name of readdirSync(localesDir)) {
-      if (name.endsWith(".json")) locales[name.slice(0, -5)] = readJson(join(localesDir, name));
+      if (name.endsWith(".json")) locales[name.slice(0, -5)] = readJson3(join2(localesDir, name));
     }
   }
   return assemble({ manifest, keys, locales });
@@ -458,15 +472,14 @@ function writeIfChanged(path, contents) {
   } catch {
   }
   if (current === contents) return false;
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, contents, "utf8");
+  writeFileAtomic(path, contents);
   return true;
 }
 function saveSplit(splitDir, state) {
   const fmt = state.config.format;
   const parts = disassemble(state);
-  const localesDir = join(splitDir, "locales");
-  mkdirSync(localesDir, { recursive: true });
+  const localesDir = join2(splitDir, "locales");
+  mkdirSync2(localesDir, { recursive: true });
   let written = 0;
   let skipped = 0;
   let deleted = 0;
@@ -474,15 +487,15 @@ function saveSplit(splitDir, state) {
     if (changed) written++;
     else skipped++;
   };
-  track(writeIfChanged(join(splitDir, "config.json"), serializeJson(parts.manifest, fmt)));
-  track(writeIfChanged(join(splitDir, "keys.json"), serializeJson(parts.keys, fmt)));
+  track(writeIfChanged(join2(splitDir, "config.json"), serializeJson(parts.manifest, fmt)));
+  track(writeIfChanged(join2(splitDir, "keys.json"), serializeJson(parts.keys, fmt)));
   for (const [locale, entries] of Object.entries(parts.locales)) {
-    track(writeIfChanged(join(localesDir, `${locale}.json`), serializeJson(entries, fmt)));
+    track(writeIfChanged(join2(localesDir, `${locale}.json`), serializeJson(entries, fmt)));
   }
   const live = new Set(Object.keys(parts.locales).map((l) => `${l}.json`));
   for (const name of readdirSync(localesDir)) {
     if (name.endsWith(".json") && !live.has(name)) {
-      rmSync(join(localesDir, name));
+      rmSync2(join2(localesDir, name));
       deleted++;
     }
   }
@@ -492,6 +505,7 @@ var init_storage = __esm({
   "src/server/storage.ts"() {
     "use strict";
     init_format();
+    init_atomic_write();
   }
 });
 
@@ -506,8 +520,7 @@ var init_normalize = __esm({
 });
 
 // src/server/state.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, rmSync as rmSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync2, rmSync as rmSync3 } from "fs";
 import { randomUUID } from "crypto";
 function canonLocale(locale) {
   return locale.trim().toLowerCase().replace(/_/g, "-");
@@ -552,10 +565,9 @@ function saveState(path, state) {
   normalizeState(state);
   if (state.config.storage === "split") {
     saveSplit(splitDirFor(path), state);
-    if (existsSync2(path)) rmSync2(path);
+    if (existsSync2(path)) rmSync3(path);
   } else {
-    mkdirSync2(dirname2(path), { recursive: true });
-    writeFileSync2(path, serializeJson(state, state.config.format), "utf8");
+    writeFileAtomic(path, serializeJson(state, state.config.format));
   }
 }
 function requireKey(state, key) {
@@ -703,6 +715,9 @@ function setMetadata(state, key, partial) {
     delete entry.contextAt;
   }
   Object.assign(entry, safe);
+  if ("context" in safe && !entry.context) delete entry.context;
+  if ("tags" in safe && !entry.tags?.length) delete entry.tags;
+  if ("maxLength" in safe && !entry.maxLength) delete entry.maxLength;
 }
 function addNote(state, key, text, clock = systemClock) {
   const entry = requireKey(state, key);
@@ -761,6 +776,7 @@ var init_state = __esm({
   "src/server/state.ts"() {
     "use strict";
     init_format();
+    init_atomic_write();
     init_schema();
     init_plurals();
     init_storage();
@@ -1494,8 +1510,8 @@ var init_adapters = __esm({
 });
 
 // src/server/export-run.ts
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname3, resolve } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { resolve } from "path";
 function effectiveLocales(config) {
   const limit = config.exportLocales;
   if (!limit || limit.length === 0) return config.locales;
@@ -1532,8 +1548,7 @@ function exportToDisk(state, projectRoot, opts) {
         skipped++;
         continue;
       }
-      mkdirSync3(dirname3(abs), { recursive: true });
-      writeFileSync3(abs, f.contents, "utf8");
+      writeFileAtomic(abs, f.contents);
       written++;
     }
   }
@@ -1543,6 +1558,7 @@ var init_export_run = __esm({
   "src/server/export-run.ts"() {
     "use strict";
     init_adapters();
+    init_atomic_write();
   }
 });
 
@@ -1636,7 +1652,7 @@ function validateTranslation(req, translation) {
     return { id: req.id, error: "Placeholder mismatch between source and translation." };
   }
   if (req.maxLength !== void 0 && translation.length > req.maxLength) {
-    return { id: req.id, error: `Exceeds maxLength (${translation.length} > ${req.maxLength}).` };
+    return { id: req.id, translation, error: `Exceeds maxLength (${translation.length} > ${req.maxLength}).` };
   }
   return { id: req.id, translation };
 }
@@ -1888,7 +1904,7 @@ var init_bedrock = __esm({
         }
         const region = config.region ?? process.env.AWS_REGION;
         if (!region) {
-          throw new Error("AWS region is not set. Set config.ai.region or the AWS_REGION environment variable for the bedrock provider.");
+          throw new Error("AWS region is not set. Set the Region in your local AI settings (.glotfile/settings.json) or the AWS_REGION environment variable for the bedrock provider.");
         }
         const require2 = createRequire2(import.meta.url);
         let sdk;
@@ -2016,9 +2032,131 @@ var init_openrouter = __esm({
   }
 });
 
+// src/server/ai/ollama.ts
+function ollamaClientOptions(config) {
+  return {
+    apiKey: process.env.OLLAMA_API_KEY ?? "ollama",
+    baseURL: config.endpoint ?? OLLAMA_BASE_URL
+  };
+}
+var OLLAMA_BASE_URL, OllamaProvider;
+var init_ollama = __esm({
+  "src/server/ai/ollama.ts"() {
+    "use strict";
+    init_openai();
+    OLLAMA_BASE_URL = "http://localhost:11434/v1";
+    OllamaProvider = class extends OpenAIProvider {
+      constructor(config, client) {
+        super(config, client ?? loadOpenAIClient(ollamaClientOptions(config)));
+      }
+      supportsVision() {
+        return this.config.vision === true;
+      }
+    };
+  }
+});
+
+// src/server/ai/claudecode.ts
+import { spawn } from "child_process";
+function stripFences(s) {
+  return s.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
+}
+function defaultSpawn(prompt, systemPrompt, model) {
+  return new Promise((resolve12, reject) => {
+    const args = [
+      "--print",
+      "--output-format",
+      "json",
+      "--system-prompt",
+      systemPrompt,
+      // Only pass --model when explicitly configured; otherwise use the session default.
+      ...model ? ["--model", model] : []
+    ];
+    const child = spawn("claude", args, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk2) => {
+      stdout += chunk2.toString();
+    });
+    child.stderr.on("data", (chunk2) => {
+      stderr += chunk2.toString();
+    });
+    child.stdin.write(prompt);
+    child.stdin.end();
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`claude exited with code ${code}: ${stderr.trim() || stdout.trim()}`));
+        return;
+      }
+      try {
+        const envelope = JSON.parse(stdout.trim());
+        if (envelope.is_error) {
+          reject(new Error(`claude error: ${envelope.result ?? "unknown error"}`));
+          return;
+        }
+        resolve12(envelope.result ?? "");
+      } catch {
+        reject(new Error(`Failed to parse claude JSON output: ${stdout.slice(0, 200)}`));
+      }
+    });
+    child.on("error", (err) => {
+      reject(new Error(`Failed to spawn claude: ${err.message}. Is Claude Code installed?`));
+    });
+  });
+}
+var ClaudeCodeProvider;
+var init_claudecode = __esm({
+  "src/server/ai/claudecode.ts"() {
+    "use strict";
+    init_provider();
+    init_batch();
+    ClaudeCodeProvider = class {
+      constructor(config, spawnFn) {
+        this.config = config;
+        this.spawnFn = spawnFn ?? defaultSpawn;
+      }
+      config;
+      spawnFn;
+      supportsVision() {
+        return false;
+      }
+      translate(reqs, onBatchComplete, signal) {
+        return runBatched(reqs, this.config.batchSize, (batch, sig) => this.callBatch(batch, sig), onBatchComplete, signal);
+      }
+      async complete(req) {
+        const systemParts = [req.system, `Respond with valid JSON matching this schema: ${JSON.stringify(req.schema)}`];
+        const textBlocks = req.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
+        const result = await this.spawnFn(textBlocks, systemParts.join("\n\n"), this.config.model);
+        try {
+          return JSON.parse(stripFences(result));
+        } catch {
+          return {};
+        }
+      }
+      async callBatch(batch, signal) {
+        if (signal?.aborted) return [];
+        const prompt = buildBatchPrompt(batch);
+        let result;
+        try {
+          result = await this.spawnFn(prompt, buildSystemPrompt(), this.config.model);
+        } catch (err) {
+          if (signal?.aborted) return [];
+          throw err;
+        }
+        if (signal?.aborted) return [];
+        try {
+          const parsed = JSON.parse(stripFences(result));
+          return parsed.items ?? [];
+        } catch {
+          return [];
+        }
+      }
+    };
+  }
+});
+
 // src/server/ai/index.ts
-function makeProvider(config) {
-  const ai = config.ai;
+function makeProvider(ai) {
   switch (ai.provider) {
     case "anthropic":
       return new AnthropicProvider(ai);
@@ -2028,8 +2166,12 @@ function makeProvider(config) {
       return new BedrockProvider(ai);
     case "openrouter":
       return new OpenRouterProvider(ai);
+    case "ollama":
+      return new OllamaProvider(ai);
+    case "claude-code":
+      return new ClaudeCodeProvider(ai);
     default:
-      throw new Error(`Unknown AI provider "${String(ai.provider)}". Supported: anthropic, openai, bedrock, openrouter.`);
+      throw new Error(`Unknown AI provider "${String(ai.provider)}". Supported: anthropic, openai, bedrock, openrouter, ollama, claude-code.`);
   }
 }
 var init_ai = __esm({
@@ -2039,6 +2181,96 @@ var init_ai = __esm({
     init_openai();
     init_bedrock();
     init_openrouter();
+    init_ollama();
+    init_claudecode();
+  }
+});
+
+// src/server/glotfile-dir.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+function ensureGlotfileDir(projectRoot) {
+  const dir = resolve2(projectRoot, ".glotfile");
+  mkdirSync3(dir, { recursive: true });
+  const ignore = resolve2(dir, ".gitignore");
+  if (!existsSync3(ignore)) {
+    try {
+      writeFileSync2(ignore, "*\n");
+    } catch {
+    }
+  }
+  return dir;
+}
+var init_glotfile_dir = __esm({
+  "src/server/glotfile-dir.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/local-settings.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve3 } from "path";
+function readJson(path) {
+  try {
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function coerceAi(raw) {
+  const a = raw && typeof raw === "object" ? raw : {};
+  return {
+    provider: PROVIDERS.includes(a.provider) ? a.provider : DEFAULT_AI.provider,
+    model: typeof a.model === "string" && a.model ? a.model : DEFAULT_AI.model,
+    endpoint: typeof a.endpoint === "string" ? a.endpoint : null,
+    region: typeof a.region === "string" ? a.region : null,
+    batchSize: typeof a.batchSize === "number" && a.batchSize > 0 ? a.batchSize : DEFAULT_AI.batchSize,
+    vision: typeof a.vision === "boolean" ? a.vision : void 0
+  };
+}
+function loadLocalSettings(projectRoot) {
+  const raw = readJson(settingsPath(projectRoot));
+  return { ai: coerceAi(raw.ai), editor: isEditorId(raw.editor) ? raw.editor : DEFAULT_EDITOR };
+}
+function saveLocalSettings(projectRoot, patch) {
+  const path = settingsPath(projectRoot);
+  const merged = { ...readJson(path) };
+  if (patch.ai !== void 0) merged.ai = patch.ai;
+  if (patch.editor !== void 0) merged.editor = patch.editor;
+  ensureGlotfileDir(projectRoot);
+  writeFileAtomic(path, JSON.stringify(merged, null, 2) + "\n");
+}
+function aiConfigError(ai) {
+  if (!ai || typeof ai !== "object") return "ai must be an object";
+  const a = ai;
+  if (typeof a.provider !== "string" || !PROVIDERS.includes(a.provider)) {
+    return `ai.provider must be one of: ${PROVIDERS.join(", ")}`;
+  }
+  if (typeof a.model !== "string") return "ai.model must be a string";
+  if (!(a.endpoint === null || a.endpoint === void 0 || typeof a.endpoint === "string")) return "ai.endpoint must be a string or null";
+  if (!(a.region === void 0 || a.region === null || typeof a.region === "string")) return "ai.region must be a string or null";
+  if (typeof a.batchSize !== "number") return "ai.batchSize must be a number";
+  return null;
+}
+var EDITOR_IDS, isEditorId, DEFAULT_AI, DEFAULT_EDITOR, settingsPath;
+var init_local_settings = __esm({
+  "src/server/local-settings.ts"() {
+    "use strict";
+    init_atomic_write();
+    init_glotfile_dir();
+    init_schema();
+    EDITOR_IDS = ["vscode", "zed", "phpstorm"];
+    isEditorId = (v) => EDITOR_IDS.includes(v);
+    DEFAULT_AI = {
+      provider: "anthropic",
+      model: "claude-haiku-4-5-20251001",
+      endpoint: null,
+      region: null,
+      batchSize: 25
+    };
+    DEFAULT_EDITOR = "vscode";
+    settingsPath = (projectRoot) => resolve3(projectRoot, ".glotfile", "settings.json");
   }
 });
 
@@ -2054,8 +2286,8 @@ var init_glob = __esm({
 });
 
 // src/server/ai/run.ts
-import { readFileSync as readFileSync4, existsSync as existsSync3 } from "fs";
-import { resolve as resolve2, extname } from "path";
+import { readFileSync as readFileSync5, existsSync as existsSync4 } from "fs";
+import { resolve as resolve4, extname } from "path";
 function selectRequests(state, opts) {
   const targets = (opts.locales ?? state.config.locales).filter((l) => l !== state.config.sourceLocale);
   const keyRe = opts.keyGlob ? globToRegExp(opts.keyGlob) : null;
@@ -2134,11 +2366,11 @@ function attachScreenshots(reqs, state, projectRoot) {
     const mediaType = MEDIA_TYPES[extname(screenshot).toLowerCase()];
     if (!mediaType) continue;
     if (!cache2.has(screenshot)) {
-      const abs = resolve2(projectRoot, screenshot);
-      if (!existsSync3(abs)) {
+      const abs = resolve4(projectRoot, screenshot);
+      if (!existsSync4(abs)) {
         cache2.set(screenshot, null);
       } else {
-        const buf = readFileSync4(abs);
+        const buf = readFileSync5(abs);
         cache2.set(screenshot, buf.length > MAX_IMAGE_BYTES ? null : { mediaType, base64: buf.toString("base64") });
       }
     }
@@ -2154,7 +2386,7 @@ function attachScreenshotsForProvider(reqs, state, projectRoot, supportsVision)
   const keys = new Set(reqs.filter((r) => state.keys[r.key]?.screenshot).map((r) => r.key));
   return { skipped: keys.size };
 }
-async function runLocaleParallel(reqs, provider, onBatchComplete, concurrency = DEFAULT_LOCALE_CONCURRENCY, signal) {
+async function runLocaleParallel(reqs, provider, hooks = {}, concurrency = DEFAULT_LOCALE_CONCURRENCY, signal) {
   if (!reqs.length) return [];
   const byLocale = /* @__PURE__ */ new Map();
   for (const req of reqs) {
@@ -2174,11 +2406,14 @@ async function runLocaleParallel(reqs, provider, onBatchComplete, concurrency =
     while (next < groups.length) {
       if (signal?.aborted) break;
       const group = groups[next++];
+      const locale = group[0].targetLocale;
+      hooks.onLocaleStart?.(locale);
       const localeResults = await provider.translate(group, (_localeDone, _localeTotal, batchResults) => {
         done += batchResults.length;
-        onBatchComplete?.(done, total, batchResults);
+        hooks.onBatchComplete?.(done, total, batchResults, locale);
       }, signal);
       allResults.push(...localeResults);
+      if (!signal?.aborted) hooks.onLocaleDone?.(locale);
     }
   }
   const workers = Array.from({ length: Math.min(concurrency, groups.length) }, worker);
@@ -2200,10 +2435,11 @@ function applyResults(state, reqs, results, clock = systemClock, force = false)
       if (applyMachineTranslationForms(state, req.key, req.targetLocale, res.forms, clock, force)) written++;
       continue;
     }
-    if (res.error || res.translation === void 0) {
+    if (res.translation === void 0) {
       errors.push({ key: req.key, locale: req.targetLocale, error: res.error ?? "no translation" });
       continue;
     }
+    if (res.error) errors.push({ key: req.key, locale: req.targetLocale, error: res.error });
     if (applyMachineTranslation(state, req.key, req.targetLocale, res.translation, clock, force)) written++;
   }
   return { written, errors };
@@ -2228,49 +2464,46 @@ var init_run = __esm({
   }
 });
 
-// src/server/ai/log.ts
-import { appendFileSync, readFileSync as readFileSync5, existsSync as existsSync4, mkdirSync as mkdirSync4 } from "fs";
-import { resolve as resolve3 } from "path";
+// src/server/log.ts
+import { appendFileSync, readFileSync as readFileSync6, existsSync as existsSync5 } from "fs";
+import { resolve as resolve5 } from "path";
 function logPath(projectRoot) {
-  return resolve3(projectRoot, ".glotfile", "ai-log.jsonl");
+  return resolve5(projectRoot, ".glotfile", "log.jsonl");
 }
-function appendAiLog(projectRoot, entry) {
-  mkdirSync4(resolve3(projectRoot, ".glotfile"), { recursive: true });
+function appendLog(projectRoot, entry) {
+  ensureGlotfileDir(projectRoot);
   appendFileSync(logPath(projectRoot), JSON.stringify(entry) + "\n", "utf8");
 }
-function readAiLog(projectRoot, limit = 100) {
+function readLog(projectRoot, limit = 100) {
   const path = logPath(projectRoot);
-  if (!existsSync4(path)) return [];
-  const lines = readFileSync5(path, "utf8").split("\n").filter((l) => l.trim() !== "");
-  const entries = lines.map((l) => {
-    const e = JSON.parse(l);
-    e.kind ??= "translate";
-    return e;
-  });
+  if (!existsSync5(path)) return [];
+  const lines = readFileSync6(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/ai/log.ts"() {
+  "src/server/log.ts"() {
     "use strict";
+    init_glotfile_dir();
   }
 });
 
 // src/server/scan.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve4, dirname as dirname4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve6 } from "path";
 function loadUsageCache(projectRoot) {
-  const path = resolve4(projectRoot, ".glotfile", "usage.json");
-  if (!existsSync5(path)) return null;
+  const path = resolve6(projectRoot, ".glotfile", "usage.json");
+  if (!existsSync6(path)) return null;
   try {
-    return JSON.parse(readFileSync6(path, "utf8"));
+    return JSON.parse(readFileSync7(path, "utf8"));
   } catch {
     return null;
   }
 }
 function saveUsageCache(projectRoot, cache2) {
-  const path = resolve4(projectRoot, ".glotfile", "usage.json");
-  mkdirSync5(dirname4(path), { recursive: true });
-  writeFileSync4(path, JSON.stringify(cache2, null, 2) + "\n", "utf8");
+  ensureGlotfileDir(projectRoot);
+  const path = resolve6(projectRoot, ".glotfile", "usage.json");
+  writeFileAtomic(path, JSON.stringify(cache2, null, 2) + "\n");
 }
 function findMissing(state) {
   const targets = state.config.locales.filter((l) => l !== state.config.sourceLocale).sort();
@@ -2297,12 +2530,14 @@ function computeUsedKeys(state, cache2) {
 var init_scan = __esm({
   "src/server/scan.ts"() {
     "use strict";
+    init_atomic_write();
+    init_glotfile_dir();
   }
 });
 
 // src/server/scanner.ts
-import { readdirSync as readdirSync2, statSync, readFileSync as readFileSync7 } from "fs";
-import { join as join2, extname as extname2, relative } from "path";
+import { readdirSync as readdirSync2, statSync, readFileSync as readFileSync8 } from "fs";
+import { join as join3, extname as extname2, relative } from "path";
 function scannerForExt(ext) {
   return EXT_SCANNER[ext] ?? null;
 }
@@ -2428,7 +2663,7 @@ function* walkFiles(dir, root, exclude) {
   }
   for (const name of entries) {
     if (ALWAYS_EXCLUDE.has(name)) continue;
-    const abs = join2(dir, name);
+    const abs = join3(dir, name);
     const rel = relative(root, abs);
     let st;
     try {
@@ -2458,7 +2693,7 @@ function runScan(projectRoot, opts, existing) {
     const ext = extname2(relPath);
     const scanner = scannerForExt(ext);
     if (!scanner) continue;
-    const abs = join2(projectRoot, relPath);
+    const abs = join3(projectRoot, relPath);
     let st;
     try {
       st = statSync(abs);
@@ -2474,7 +2709,7 @@ function runScan(projectRoot, opts, existing) {
     }
     let content;
     try {
-      content = readFileSync7(abs, "utf8");
+      content = readFileSync8(abs, "utf8");
     } catch {
       continue;
     }
@@ -2579,8 +2814,8 @@ var init_scanner = __esm({
 });
 
 // src/server/ai/context.ts
-import { existsSync as existsSync6, readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve5 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve7 } from "path";
 function globToRegExp2(glob) {
   const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
   return new RegExp(`^${escaped}$`);
@@ -2592,10 +2827,10 @@ function extractSnippets(refs, projectRoot, fileCache) {
   const extraRefs = filtered.length > MAX_SNIPPETS ? filtered.length - MAX_SNIPPETS : 0;
   const snippets = [];
   for (const ref of selected) {
-    const absPath = resolve5(projectRoot, ref.file);
+    const absPath = resolve7(projectRoot, ref.file);
     if (!fileCache.has(ref.file)) {
-      if (!existsSync6(absPath)) continue;
-      const content = readFileSync8(absPath, "utf8");
+      if (!existsSync7(absPath)) continue;
+      const content = readFileSync9(absPath, "utf8");
       fileCache.set(ref.file, content.split("\n"));
     }
     const lines = fileCache.get(ref.file);
@@ -2740,8 +2975,8 @@ var init_context = __esm({
 });
 
 // src/server/import/detect.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join4 } from "path";
 function safeIsDir(p) {
   try {
     return statSync2(p).isDirectory();
@@ -2750,7 +2985,7 @@ function safeIsDir(p) {
   }
 }
 function listDirs(dir) {
-  return readdirSync3(dir).filter((e) => safeIsDir(join3(dir, e)));
+  return readdirSync3(dir).filter((e) => safeIsDir(join4(dir, e)));
 }
 function fileCount(dir) {
   try {
@@ -2764,22 +2999,22 @@ function pickSource(locales, sizeOf) {
   return [...locales].sort((a, b) => sizeOf(b) - sizeOf(a) || a.localeCompare(b))[0] ?? "en";
 }
 function detectLaravel(root) {
-  const localeRoot = [join3(root, "resources", "lang"), join3(root, "lang")].find(safeIsDir);
+  const localeRoot = [join4(root, "resources", "lang"), join4(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(join3(localeRoot, loc)));
+  const sourceLocale = pickSource(locales, (loc) => fileCount(join4(localeRoot, loc)));
   return { format: "laravel-php", localeRoot, locales, sourceLocale };
 }
 function detectVue(root) {
   for (const rel of VUE_DIR_CANDIDATES) {
-    const localeRoot = join3(root, rel);
+    const localeRoot = join4(root, rel);
     if (!safeIsDir(localeRoot)) continue;
     const locales = readdirSync3(localeRoot).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5)).filter((l) => LOCALE_RE.test(l));
     if (locales.length >= 2) {
       const sourceLocale = pickSource(locales, (loc) => {
         try {
-          return statSync2(join3(localeRoot, `${loc}.json`)).size;
+          return statSync2(join4(localeRoot, `${loc}.json`)).size;
         } catch {
           return 0;
         }
@@ -2791,7 +3026,7 @@ function detectVue(root) {
 }
 function detectArb(root) {
   for (const rel of ["lib/l10n", "l10n", "lib/src/l10n"]) {
-    const localeRoot = join3(root, rel);
+    const localeRoot = join4(root, rel);
     if (!safeIsDir(localeRoot)) continue;
     const locales = readdirSync3(localeRoot).map((f) => f.match(/^(?:app_)?(.+)\.arb$/)?.[1]).filter((l) => !!l && LOCALE_RE.test(l));
     if (locales.length >= 1) {
@@ -2801,7 +3036,7 @@ function detectArb(root) {
   return null;
 }
 function detect(root, formatOverride) {
-  if (!existsSync8(root)) return null;
+  if (!existsSync9(root)) return null;
   if (formatOverride) {
     const fn = BY_FORMAT[formatOverride];
     if (!fn) throw new Error(`Unknown format: ${formatOverride}`);
@@ -2856,8 +3091,8 @@ var init_flatten = __esm({
 });
 
 // src/server/import/parsers/vue-i18n-json.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync10 } from "fs";
-import { join as join4 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync11 } from "fs";
+import { join as join5 } from "path";
 var LOCALE_RE2, vueI18nJson2;
 var init_vue_i18n_json2 = __esm({
   "src/server/import/parsers/vue-i18n-json.ts"() {
@@ -2877,7 +3112,7 @@ var init_vue_i18n_json2 = __esm({
           if (opts?.locales && !opts.locales.includes(locale)) continue;
           let data;
           try {
-            data = JSON.parse(readFileSync10(join4(localeRoot, file), "utf8"));
+            data = JSON.parse(readFileSync11(join5(localeRoot, file), "utf8"));
           } catch (e) {
             warnings.push(`vue-i18n-json: failed to parse ${file}: ${e.message}`);
             continue;
@@ -2905,16 +3140,16 @@ var init_placeholders2 = __esm({
 
 // src/server/import/parsers/laravel-php.ts
 import { readdirSync as readdirSync5, statSync as statSync3 } from "fs";
-import { join as join5, relative as relative2 } from "path";
+import { join as join6, relative as relative2 } from "path";
 import { execFileSync } from "child_process";
 function listDirs2(dir) {
-  return readdirSync5(dir).filter((e) => statSync3(join5(dir, e)).isDirectory());
+  return readdirSync5(dir).filter((e) => statSync3(join6(dir, e)).isDirectory());
 }
 function listPhpFiles(dir) {
   const out = [];
   const walk = (d) => {
     for (const e of readdirSync5(d)) {
-      const full = join5(d, e);
+      const full = join6(d, e);
       if (statSync3(full).isDirectory()) walk(full);
       else if (e.endsWith(".php")) out.push(full);
     }
@@ -2957,7 +3192,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 = join5(localeRoot, locale);
+          const localeDir = join6(localeRoot, locale);
           locales.push(locale);
           for (const file of listPhpFiles(localeDir)) {
             const group = relative2(localeDir, file).replace(/\\/g, "/").replace(/\.php$/, "");
@@ -2982,8 +3217,8 @@ var init_laravel_php2 = __esm({
 });
 
 // src/server/import/parsers/flutter-arb.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
-import { join as join6 } from "path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync12 } from "fs";
+import { join as join7 } from "path";
 function localeFromArbName(file) {
   const m = file.match(/^(.+)\.arb$/);
   if (!m) return null;
@@ -3023,7 +3258,7 @@ var init_flutter_arb2 = __esm({
           if (opts?.locales && !opts.locales.includes(locale)) continue;
           let data;
           try {
-            data = JSON.parse(readFileSync11(join6(localeRoot, file), "utf8"));
+            data = JSON.parse(readFileSync12(join7(localeRoot, file), "utf8"));
           } catch (e) {
             warnings.push(`flutter-arb: failed to parse ${file}: ${e.message}`);
             continue;
@@ -3127,7 +3362,6 @@ function assemble2(parsed, opts) {
       sourceLocale,
       locales,
       outputs: [output],
-      ai: { provider: "anthropic", model: "claude-opus-4-8", endpoint: null, batchSize: 25 },
       format: { indent: 2, sortKeys: true, finalNewline: true },
       spelling: { customWords: [] }
     },
@@ -3554,16 +3788,48 @@ var init_checks = __esm({
   }
 });
 
+// src/server/ui-prefs.ts
+import { readFileSync as readFileSync13 } from "fs";
+import { homedir } from "os";
+import { join as join8 } from "path";
+function readJson2(path) {
+  try {
+    const parsed = JSON.parse(readFileSync13(path, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function loadUiPrefs(path) {
+  const raw = readJson2(path);
+  return { theme: isThemeMode(raw.theme) ? raw.theme : DEFAULTS.theme };
+}
+function saveUiPrefs(path, prefs) {
+  const merged = { ...readJson2(path), ...prefs };
+  writeFileAtomic(path, JSON.stringify(merged, null, 2) + "\n");
+}
+var THEMES, isThemeMode, defaultUiPrefsPath, DEFAULTS;
+var init_ui_prefs = __esm({
+  "src/server/ui-prefs.ts"() {
+    "use strict";
+    init_atomic_write();
+    THEMES = ["system", "light", "dark"];
+    isThemeMode = (v) => THEMES.includes(v);
+    defaultUiPrefsPath = () => join8(homedir(), ".glotfile", "ui.json");
+    DEFAULTS = { theme: "system" };
+  }
+});
+
 // src/server/api.ts
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
-import { writeFileSync as writeFileSync5, readFileSync as readFileSync12, mkdirSync as mkdirSync6, existsSync as existsSync9, readdirSync as readdirSync7, rmSync as rmSync3 } from "fs";
-import { dirname as dirname5, resolve as resolve7, basename, relative as relative3, sep } from "path";
+import { readFileSync as readFileSync14, existsSync as existsSync10, readdirSync as readdirSync7, statSync as statSync4, rmSync as rmSync4 } from "fs";
+import { dirname as dirname2, resolve as resolve9, basename, relative as relative3, sep } from "path";
 function projectName(root) {
-  const nameFile = resolve7(root, ".idea", ".name");
-  if (existsSync9(nameFile)) {
+  const nameFile = resolve9(root, ".idea", ".name");
+  if (existsSync10(nameFile)) {
     try {
-      const name = readFileSync12(nameFile, "utf8").trim();
+      const name = readFileSync14(nameFile, "utf8").trim();
       if (name) return name;
     } catch {
     }
@@ -3573,7 +3839,7 @@ function projectName(root) {
 function createApi(deps) {
   const app = new Hono();
   const load = () => loadState(deps.statePath);
-  const projectRoot = dirname5(resolve7(deps.statePath));
+  const projectRoot = dirname2(resolve9(deps.statePath));
   let translateQueue = Promise.resolve();
   const withTranslateLock = (fn) => {
     const next = translateQueue.then(fn, fn);
@@ -3597,42 +3863,92 @@ function createApi(deps) {
     saveState(deps.statePath, s);
     scheduleAutoExport(s);
   };
+  const logChange = (entry) => appendLog(projectRoot, { ...entry, at: (/* @__PURE__ */ new Date()).toISOString() });
+  const valueText = (s, key, locale) => s.keys[key]?.values[locale]?.value;
+  const uiPrefsPath = deps.uiPrefsPath ?? defaultUiPrefsPath();
   app.get("/state", (c) => c.json(load()));
+  app.get("/ui-prefs", (c) => c.json(loadUiPrefs(uiPrefsPath)));
+  app.put("/ui-prefs", async (c) => {
+    const { theme } = await c.req.json();
+    if (!isThemeMode(theme)) return c.json({ error: "theme must be system, light, or dark" }, 400);
+    saveUiPrefs(uiPrefsPath, { theme });
+    return c.json({ ok: true });
+  });
+  app.get("/local-settings", (c) => c.json(loadLocalSettings(projectRoot)));
+  app.put("/local-settings", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const patch = {};
+    if (body.ai !== void 0) {
+      const err = aiConfigError(body.ai);
+      if (err) return c.json({ error: err }, 400);
+      patch.ai = body.ai;
+    }
+    if (body.editor !== void 0) {
+      if (!isEditorId(body.editor)) return c.json({ error: "editor must be one of: vscode, zed, phpstorm" }, 400);
+      patch.editor = body.editor;
+    }
+    if (patch.ai === void 0 && patch.editor === void 0) {
+      return c.json({ error: "provide ai and/or editor" }, 400);
+    }
+    saveLocalSettings(projectRoot, patch);
+    return c.json({ ok: true });
+  });
   app.get("/file", (c) => c.json({ path: deps.statePath, name: basename(deps.statePath), dir: projectRoot, project: basename(projectRoot) }));
   app.get("/files", (c) => {
     const found = /* @__PURE__ */ new Map();
-    found.set(deps.statePath, { name: basename(deps.statePath), path: deps.statePath });
-    let entries = [];
-    try {
-      entries = readdirSync7(projectRoot);
-    } catch {
-    }
-    for (const name of entries) {
-      let abs;
-      if ((name === "glotfile" || name.endsWith(".glotfile")) && existsSync9(resolve7(projectRoot, name, "config.json"))) {
-        abs = resolve7(projectRoot, `${name}.json`);
-      } else if (name === "glotfile.json" || name.endsWith(".glotfile.json")) {
-        abs = resolve7(projectRoot, name);
-      } else {
-        continue;
-      }
-      if (found.has(abs)) continue;
+    const activeRel = relative3(projectRoot, deps.statePath);
+    found.set(deps.statePath, {
+      name: basename(deps.statePath),
+      path: deps.statePath,
+      relDir: activeRel !== basename(activeRel) ? dirname2(activeRel) : void 0
+    });
+    function walk(dir, depth) {
+      if (depth > 4) return;
+      let entries = [];
       try {
-        loadState(abs);
-        found.set(abs, { name: basename(abs), path: abs });
+        entries = readdirSync7(dir);
       } catch {
+        return;
+      }
+      for (const name of entries) {
+        if (name.startsWith(".") || name === "node_modules") continue;
+        const abs = resolve9(dir, name);
+        let filePath = null;
+        if ((name === "glotfile" || name.endsWith(".glotfile")) && existsSync10(resolve9(abs, "config.json"))) {
+          filePath = resolve9(dir, `${name}.json`);
+        } else if (name === "glotfile.json" || name.endsWith(".glotfile.json")) {
+          filePath = abs;
+        } else {
+          try {
+            if (statSync4(abs).isDirectory()) walk(abs, depth + 1);
+          } catch {
+          }
+          continue;
+        }
+        if (found.has(filePath)) continue;
+        try {
+          loadState(filePath);
+          const rel = relative3(projectRoot, filePath);
+          found.set(filePath, { name: basename(filePath), path: filePath, relDir: rel !== basename(filePath) ? dirname2(rel) : void 0 });
+        } catch {
+        }
       }
     }
-    const files = [...found.values()].sort((a, b) => a.name.localeCompare(b.name));
+    walk(projectRoot, 0);
+    const files = [...found.values()].sort((a, b) => {
+      const ka = a.relDir ? `${a.relDir}/${a.name}` : a.name;
+      const kb = b.relDir ? `${b.relDir}/${b.name}` : b.name;
+      return ka.localeCompare(kb);
+    });
     return c.json(files);
   });
   app.post("/file", async (c) => {
     const { path } = await c.req.json();
     if (typeof path !== "string") return c.json({ error: "path must be a string" }, 400);
-    const resolved = resolve7(projectRoot, path);
+    const resolved = resolve9(projectRoot, path);
     const inside = resolved === projectRoot || resolved.startsWith(projectRoot + sep);
     if (!inside) return c.json({ error: "file is outside the project" }, 400);
-    if (!existsSync9(resolved)) return c.json({ error: "file not found" }, 400);
+    if (!existsSync10(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) });
@@ -3647,6 +3963,7 @@ function createApi(deps) {
     const s = load();
     createKey(s, key, value, void 0, plural ? { plural: { arg: plural.arg } } : {});
     persist(s);
+    logChange({ kind: "key", summary: `Created key ${key}`, key, after: value });
     console.log(`[key] created ${key}`);
     return c.json({ ok: true });
   });
@@ -3656,37 +3973,45 @@ function createApi(deps) {
     const s = load();
     addCustomWord(s, word);
     persist(s);
+    logChange({ kind: "dictionary", summary: `Added "${word}" to dictionary`, after: word });
     return c.json({ ok: true });
   });
   app.delete("/dictionary/:word", (c) => {
     const s = load();
-    removeCustomWord(s, c.req.param("word"));
+    const word = c.req.param("word");
+    removeCustomWord(s, word);
     persist(s);
+    logChange({ kind: "dictionary", summary: `Removed "${word}" from dictionary`, before: word });
     return c.json({ ok: true });
   });
   app.patch("/keys/:key", async (c) => {
     const key = c.req.param("key");
     const body = await c.req.json();
     const s = load();
+    const beforeSource = typeof body.source === "string" ? valueText(s, key, s.config.sourceLocale) : void 0;
     if (typeof body.rename === "string") renameKey(s, key, body.rename);
     const target = typeof body.rename === "string" ? body.rename : key;
     if (body.metadata) setMetadata(s, target, body.metadata);
     if (typeof body.source === "string") setSourceValue(s, target, body.source);
     if (typeof body.pluralArg === "string" && body.pluralArg.trim()) setPluralArg(s, target, body.pluralArg.trim());
     persist(s);
+    if (typeof body.rename === "string") logChange({ kind: "key", summary: `Renamed ${key} \u2192 ${body.rename}`, key: target, before: key, after: body.rename });
+    if (body.metadata) logChange({ kind: "metadata", summary: `Updated metadata of ${target}`, key: target, after: body.metadata });
+    if (typeof body.source === "string") logChange({ kind: "translation", summary: `Set source value of ${target}`, key: target, locale: s.config.sourceLocale, before: beforeSource, after: body.source });
+    if (typeof body.pluralArg === "string" && body.pluralArg.trim()) logChange({ kind: "key", summary: `Changed plural arg of ${target}`, key: target, after: body.pluralArg.trim() });
     if (typeof body.rename === "string") console.log(`[key] renamed ${key} \u2192 ${body.rename}`);
     return c.json({ ok: true });
   });
   function removeOrphanScreenshot(s, screenshot) {
     if (!screenshot) return;
     for (const e of Object.values(s.keys)) if (e.screenshot === screenshot) return;
-    const root = dirname5(resolve7(deps.statePath));
-    const abs = resolve7(root, screenshot);
+    const root = dirname2(resolve9(deps.statePath));
+    const abs = resolve9(root, screenshot);
     const rel = relative3(root, abs);
     const seg0 = rel.split(sep)[0] ?? "";
-    if (!rel.startsWith("..") && seg0.endsWith("-screenshots") && existsSync9(abs)) {
+    if (!rel.startsWith("..") && seg0.endsWith("-screenshots") && existsSync10(abs)) {
       try {
-        rmSync3(abs);
+        rmSync4(abs);
       } catch {
       }
     }
@@ -3695,9 +4020,11 @@ function createApi(deps) {
     const s = load();
     const key = c.req.param("key");
     const shot = s.keys[key]?.screenshot;
+    const before = valueText(s, key, s.config.sourceLocale);
     deleteKey(s, key);
     removeOrphanScreenshot(s, shot);
     persist(s);
+    logChange({ kind: "key", summary: `Deleted key ${key}`, key, before });
     console.log(`[key] deleted ${key}`);
     return c.json({ ok: true });
   });
@@ -3721,6 +4048,7 @@ function createApi(deps) {
       }
     }
     persist(s);
+    if (cleared) logChange({ kind: "translation", summary: `Cleared ${cleared} value(s) across ${keys.length} key(s)`, after: { locales } });
     console.log(`[bulk] cleared ${cleared} value(s)`);
     return c.json({ cleared });
   });
@@ -3738,6 +4066,7 @@ function createApi(deps) {
     }
     for (const shot of shots) removeOrphanScreenshot(s, shot);
     persist(s);
+    if (removed.length) logChange({ kind: "key", summary: `Deleted ${removed.length} key(s)`, before: removed });
     console.log(`[bulk] deleted ${removed.length} key(s)`);
     return c.json({ removed });
   });
@@ -3763,6 +4092,7 @@ function createApi(deps) {
       updated++;
     }
     persist(s);
+    if (updated) logChange({ kind: "metadata", summary: `Updated metadata on ${updated} key(s)` });
     console.log(`[bulk] updated metadata on ${updated} key(s)`);
     return c.json({ updated });
   });
@@ -3786,6 +4116,7 @@ function createApi(deps) {
       }
     }
     persist(s);
+    if (updated) logChange({ kind: "translation", summary: `Marked ${updated} value(s) as ${next}`, after: next });
     console.log(`[bulk] set state ${next} on ${updated} value(s)`);
     return c.json({ updated });
   });
@@ -3795,15 +4126,21 @@ function createApi(deps) {
     const s = load();
     const key = c.req.param("key");
     const locale = c.req.param("locale");
+    const before = valueText(s, key, locale);
     if (locale === s.config.sourceLocale) setSourceValue(s, key, value);
     else setTargetValue(s, key, locale, value);
     persist(s);
+    logChange({ kind: "translation", summary: `Set ${locale} value of ${key}`, key, locale, before, after: value });
     return c.json({ ok: true });
   });
   app.delete("/keys/:key/values/:locale", (c) => {
     const s = load();
-    clearValue(s, c.req.param("key"), c.req.param("locale"));
+    const key = c.req.param("key");
+    const locale = c.req.param("locale");
+    const before = valueText(s, key, locale);
+    clearValue(s, key, locale);
     persist(s);
+    logChange({ kind: "translation", summary: `Cleared ${locale} value of ${key}`, key, locale, before });
     return c.json({ ok: true });
   });
   app.put("/keys/:key/plural/:locale", async (c) => {
@@ -3812,52 +4149,68 @@ function createApi(deps) {
     const s = load();
     const key = c.req.param("key");
     const locale = c.req.param("locale");
+    const before = s.keys[key]?.values[locale]?.forms;
     if (locale === s.config.sourceLocale) setSourcePluralForms(s, key, forms);
     else setPluralForms(s, key, locale, forms);
     persist(s);
+    logChange({ kind: "translation", summary: `Set ${locale} plural forms of ${key}`, key, locale, before, after: forms });
     return c.json({ ok: true });
   });
   app.post("/keys/:key/plural", async (c) => {
     const { arg } = await c.req.json();
     if (typeof arg !== "string" || !arg.trim()) return c.json({ error: "arg is required" }, 400);
     const s = load();
-    convertToPlural(s, c.req.param("key"), arg);
+    const key = c.req.param("key");
+    convertToPlural(s, key, arg);
     persist(s);
+    logChange({ kind: "key", summary: `Converted ${key} to plural`, key, after: arg });
     return c.json({ ok: true });
   });
   app.delete("/keys/:key/plural", (c) => {
     const s = load();
-    convertToScalar(s, c.req.param("key"));
+    const key = c.req.param("key");
+    convertToScalar(s, key);
     persist(s);
+    logChange({ kind: "key", summary: `Converted ${key} to scalar`, key });
     return c.json({ ok: true });
   });
   app.put("/keys/:key/values/:locale/state", async (c) => {
     const { state } = await c.req.json();
     const s = load();
-    setKeyState(s, c.req.param("key"), c.req.param("locale"), state);
+    const key = c.req.param("key");
+    const locale = c.req.param("locale");
+    const before = s.keys[key]?.values[locale]?.state;
+    setKeyState(s, key, locale, state);
     persist(s);
+    logChange({ kind: "translation", summary: `Marked ${key} ${locale} as ${state}`, key, locale, before, after: state });
     return c.json({ ok: true });
   });
   app.post("/keys/:key/notes", async (c) => {
     const { text } = await c.req.json();
     if (typeof text !== "string" || !text.trim()) return c.json({ error: "note text is required" }, 400);
     const s = load();
-    const note = addNote(s, c.req.param("key"), text);
+    const key = c.req.param("key");
+    const note = addNote(s, key, text);
     persist(s);
+    logChange({ kind: "note", summary: `Added note to ${key}`, key, after: text });
     return c.json(note);
   });
   app.put("/keys/:key/notes/:id", async (c) => {
     const { text } = await c.req.json();
     if (typeof text !== "string" || !text.trim()) return c.json({ error: "note text is required" }, 400);
     const s = load();
-    editNote(s, c.req.param("key"), c.req.param("id"), text);
+    const key = c.req.param("key");
+    editNote(s, key, c.req.param("id"), text);
     persist(s);
+    logChange({ kind: "note", summary: `Edited note on ${key}`, key, after: text });
     return c.json({ ok: true });
   });
   app.delete("/keys/:key/notes/:id", (c) => {
     const s = load();
-    deleteNote(s, c.req.param("key"), c.req.param("id"));
+    const key = c.req.param("key");
+    deleteNote(s, key, c.req.param("id"));
     persist(s);
+    logChange({ kind: "note", summary: `Deleted note on ${key}`, key });
     return c.json({ ok: true });
   });
   app.put("/config", async (c) => {
@@ -3866,6 +4219,7 @@ function createApi(deps) {
       return c.json({ error: "config.locales must be an array" }, 400);
     }
     const s = load();
+    const beforeCfg = { locales: s.config.locales };
     const removed = s.config.locales.filter((l) => !newConfig.locales.includes(l));
     for (const l of removed) {
       for (const e of Object.values(s.keys)) delete e.values[l];
@@ -3873,7 +4227,8 @@ function createApi(deps) {
     s.config = newConfig;
     validate(s);
     persist(s);
-    console.log(`[config] saved \u2014 ${newConfig.locales.length} locale(s), model ${newConfig.ai.model}`);
+    logChange({ kind: "config", summary: `Saved config (${newConfig.locales.length} locale(s))`, before: beforeCfg, after: { locales: newConfig.locales } });
+    console.log(`[config] saved \u2014 ${newConfig.locales.length} locale(s)`);
     return c.json({ ok: true });
   });
   app.get("/glossary", (c) => c.json(load().glossary));
@@ -3881,14 +4236,19 @@ function createApi(deps) {
     const entry = await c.req.json();
     if (typeof entry?.term !== "string") return c.json({ error: "term must be a string" }, 400);
     const s = load();
+    const before = s.glossary.find((g) => g.term === entry.term);
     upsertGlossaryEntry(s, entry);
     persist(s);
+    logChange({ kind: "glossary", summary: `${before ? "Updated" : "Added"} glossary term "${entry.term}"`, before, after: entry });
     return c.json({ ok: true });
   });
   app.delete("/glossary/:term", (c) => {
     const s = load();
-    deleteGlossaryEntry(s, decodeURIComponent(c.req.param("term")));
+    const term = decodeURIComponent(c.req.param("term"));
+    const before = s.glossary.find((g) => g.term === term);
+    deleteGlossaryEntry(s, term);
     persist(s);
+    logChange({ kind: "glossary", summary: `Deleted glossary term "${term}"`, before });
     return c.json({ ok: true });
   });
   app.post("/keys/:key/screenshot", async (c) => {
@@ -3896,18 +4256,18 @@ function createApi(deps) {
     const body = await c.req.parseBody();
     const file = body["file"];
     if (!file || typeof file === "string") return c.json({ error: "no file uploaded" }, 400);
-    const root = dirname5(resolve7(deps.statePath));
+    const root = dirname2(resolve9(deps.statePath));
     const dirName = screenshotDirName(deps.statePath);
-    const dir = resolve7(root, dirName);
-    mkdirSync6(dir, { recursive: true });
+    const dir = resolve9(root, dirName);
     const filename = `${sanitize(key)}__${sanitize(file.name)}`;
-    writeFileSync5(resolve7(dir, filename), Buffer.from(await file.arrayBuffer()));
+    writeFileAtomic(resolve9(dir, filename), Buffer.from(await file.arrayBuffer()));
     const path = `${dirName}/${filename}`;
     const s = load();
     const prev = s.keys[key]?.screenshot;
     setMetadata(s, key, { screenshot: path });
     if (prev && prev !== path) removeOrphanScreenshot(s, prev);
     persist(s);
+    logChange({ kind: "metadata", summary: `${prev ? "Replaced" : "Added"} screenshot on ${key}`, key, before: prev, after: path });
     return c.json({ path });
   });
   app.delete("/keys/:key/screenshot", (c) => {
@@ -3917,6 +4277,7 @@ function createApi(deps) {
     setMetadata(s, key, { screenshot: void 0 });
     removeOrphanScreenshot(s, shot);
     persist(s);
+    logChange({ kind: "metadata", summary: `Removed screenshot from ${key}`, key, before: shot });
     return c.json({ ok: true });
   });
   app.get("/export/preview", (c) => {
@@ -3961,12 +4322,13 @@ function createApi(deps) {
       return c.json({ error: e.message }, 400);
     }
     persist(result.state);
+    logChange({ kind: "import", summary: `Imported ${result.keyCount} key(s) across ${result.localeCount} locale(s)` });
     console.log(`[import] ${result.keyCount} key(s) across ${result.localeCount} locale(s)${result.warnings.length ? `, ${result.warnings.length} warning(s)` : ""}`);
     return c.json({ keyCount: result.keyCount, localeCount: result.localeCount, warnings: result.warnings });
   });
   app.post("/export", (c) => {
     const s = narrowForExport(load());
-    const root = dirname5(resolve7(deps.statePath));
+    const root = dirname2(resolve9(deps.statePath));
     const warnings = [];
     let count = 0;
     for (const output of s.config.outputs) {
@@ -3974,9 +4336,8 @@ function createApi(deps) {
       const result = adapter.export(s, output);
       warnings.push(...result.warnings);
       for (const f of result.files) {
-        const abs = resolve7(root, f.path);
-        mkdirSync6(dirname5(abs), { recursive: true });
-        writeFileSync5(abs, f.contents, "utf8");
+        const abs = resolve9(root, f.path);
+        writeFileAtomic(abs, f.contents);
         count++;
       }
     }
@@ -3995,41 +4356,63 @@ function createApi(deps) {
         await stream.writeSSE({ event: "done", data: JSON.stringify({ written: 0, errors: [] }) });
         return;
       }
+      const aiCfg = loadLocalSettings(projectRoot).ai;
       let provider;
       try {
-        provider = deps.makeProvider ? deps.makeProvider(s) : makeProvider(s.config);
+        provider = deps.makeProvider ? deps.makeProvider() : makeProvider(aiCfg);
       } catch (e) {
         await stream.writeSSE({ event: "error", data: JSON.stringify({ error: e.message }) });
         return;
       }
       const { skipped } = attachScreenshotsForProvider(reqs, s, projectRoot, provider.supportsVision());
-      if (skipped) console.warn(`Model "${s.config.ai.model}" has no vision support; ${skipped} screenshot(s) ignored.`);
-      console.log(`[translate] ${reqs.length} string(s) \u2192 ${s.config.ai.model}`);
+      if (skipped) console.warn(`Model "${aiCfg.model}" has no vision support; ${skipped} screenshot(s) ignored.`);
+      console.log(`[translate] ${reqs.length} string(s) \u2192 ${aiCfg.model}`);
       let totalWritten = 0;
       const allErrors = [];
       const system = buildSystemPrompt();
       const reqById = new Map(reqs.map((r) => [r.id, r]));
-      await runLocaleParallel(reqs, provider, (done, total, batchResults) => {
-        const { written, errors } = applyResults(s, reqs, batchResults);
-        persist(s);
-        totalWritten += written;
-        allErrors.push(...errors);
-        appendAiLog(projectRoot, {
-          at: (/* @__PURE__ */ new Date()).toISOString(),
-          kind: "translate",
-          model: s.config.ai.model,
-          system,
-          items: batchResults.map((r) => {
-            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 ? s.keys[req.key]?.screenshot : void 0 };
-          }),
-          results: batchResults
-        });
-        console.log(`[translate] ${done}/${total}`);
-        void stream.writeSSE({
-          event: "progress",
-          data: JSON.stringify({ done, total, written: totalWritten, errors })
-        });
+      const localeTotals = /* @__PURE__ */ new Map();
+      for (const r of reqs) localeTotals.set(r.targetLocale, (localeTotals.get(r.targetLocale) ?? 0) + 1);
+      const localeDone = /* @__PURE__ */ new Map();
+      await stream.writeSSE({
+        event: "start",
+        data: JSON.stringify({ total: reqs.length, locales: [...localeTotals].map(([locale, total]) => ({ locale, total })) })
+      });
+      await runLocaleParallel(reqs, provider, {
+        // Announce a language the moment a worker picks it up — this is the
+        // signal that "something is happening" during the long first LLM call.
+        onLocaleStart: (locale) => {
+          void stream.writeSSE({ event: "locale-start", data: JSON.stringify({ locale }) });
+        },
+        onBatchComplete: (done, total, batchResults, locale) => {
+          const fresh = load();
+          const { written, errors } = applyResults(fresh, reqs, batchResults);
+          persist(fresh);
+          totalWritten += written;
+          allErrors.push(...errors);
+          appendLog(projectRoot, {
+            at: (/* @__PURE__ */ new Date()).toISOString(),
+            kind: "translate",
+            summary: `Translated ${batchResults.length} item(s)`,
+            model: aiCfg.model,
+            system,
+            items: batchResults.map((r) => {
+              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 ? s.keys[req.key]?.screenshot : void 0 };
+            }),
+            results: batchResults
+          });
+          const ld = (localeDone.get(locale) ?? 0) + batchResults.length;
+          localeDone.set(locale, ld);
+          console.log(`[translate] ${done}/${total}`);
+          void stream.writeSSE({
+            event: "progress",
+            data: JSON.stringify({ done, total, written: totalWritten, errors, locale, localeDone: ld, localeTotal: localeTotals.get(locale) ?? 0 })
+          });
+        },
+        onLocaleDone: (locale) => {
+          void stream.writeSSE({ event: "locale-done", data: JSON.stringify({ locale }) });
+        }
       }, void 0, signal);
       if (!signal?.aborted) {
         console.log(`[translate] done \u2014 wrote ${totalWritten}, ${allErrors.length} error(s)`);
@@ -4052,19 +4435,22 @@ function createApi(deps) {
     let written = 0;
     let errors = [];
     if (toTranslate.length) {
+      const aiCfg = loadLocalSettings(projectRoot).ai;
       let provider;
       try {
-        provider = deps.makeProvider ? deps.makeProvider(s) : makeProvider(s.config);
+        provider = deps.makeProvider ? deps.makeProvider() : makeProvider(aiCfg);
       } catch (e) {
         return c.json({ error: e.message }, 400);
       }
       const { skipped } = attachScreenshotsForProvider(toTranslate, s, projectRoot, provider.supportsVision());
-      if (skipped) console.warn(`Model "${s.config.ai.model}" has no vision support; ${skipped} screenshot(s) ignored.`);
+      if (skipped) console.warn(`Model "${aiCfg.model}" has no vision support; ${skipped} screenshot(s) ignored.`);
       const results = await runLocaleParallel(toTranslate, provider);
       ({ written, errors } = applyResults(s, toTranslate, results, void 0, force));
       const entry = {
         at: (/* @__PURE__ */ new Date()).toISOString(),
-        model: s.config.ai.model,
+        kind: "translate",
+        summary: `Translated ${toTranslate.length} item(s)`,
+        model: aiCfg.model,
         system: buildSystemPrompt(),
         // Log the screenshot PATH only — never the image bytes.
         items: toTranslate.map((r) => ({
@@ -4078,12 +4464,12 @@ function createApi(deps) {
         })),
         results
       };
-      appendAiLog(projectRoot, entry);
+      appendLog(projectRoot, entry);
     }
     persist(s);
     return c.json({ requested: reqs.length, written, errors });
   }));
-  app.get("/ai-log", (c) => c.json(readAiLog(projectRoot, 100)));
+  app.get("/log", (c) => c.json(readLog(projectRoot, 100)));
   app.post("/scan", async (c) => {
     const s = load();
     const existing = loadUsageCache(projectRoot);
@@ -4107,7 +4493,7 @@ function createApi(deps) {
     const refs = [];
     const prefixRefs = [];
     for (const [file, entry] of Object.entries(cache2.files)) {
-      const abs = resolve7(projectRoot, file);
+      const abs = resolve9(projectRoot, file);
       for (const r of entry.refs) {
         if (r.key === key) refs.push({ file, abs, line: r.line, col: r.col, scanner: r.scanner });
       }
@@ -4148,9 +4534,10 @@ function createApi(deps) {
       keys: body.keys
     }, cache2, body.lastRunAt);
     if (!targets.length) return c.json({ requested: 0, written: 0, errors: [] });
+    const aiCfg = loadLocalSettings(projectRoot).ai;
     let provider;
     try {
-      provider = deps.makeProvider ? deps.makeProvider(s) : makeProvider(s.config);
+      provider = deps.makeProvider ? deps.makeProvider() : makeProvider(aiCfg);
     } catch (e) {
       return c.json({ error: e.message }, 400);
     }
@@ -4172,10 +4559,11 @@ function createApi(deps) {
     const raw = await provider.complete({ system, content: [{ type: "text", text: prompt }], schema: CONTEXT_BATCH_SCHEMA });
     const batch = raw;
     const { written, errors } = applyContext(s, targets, batch.items ?? []);
-    appendAiLog(projectRoot, {
+    appendLog(projectRoot, {
       at: (/* @__PURE__ */ new Date()).toISOString(),
       kind: "context",
-      model: s.config.ai.model,
+      summary: `Generated context for ${targets.length} key(s)`,
+      model: aiCfg.model,
       system,
       items: targets.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 }))
@@ -4207,6 +4595,9 @@ var init_api = __esm({
     init_schema();
     init_run2();
     init_export_run();
+    init_ui_prefs();
+    init_local_settings();
+    init_atomic_write();
     sanitize = (s) => s.replace(/[^\w.\-]+/g, "_");
     screenshotDirName = (statePath) => basename(statePath).replace(/\.[^.]+$/, "") + "-screenshots";
   }
@@ -4221,7 +4612,7 @@ __export(server_exports, {
 import { Hono as Hono2 } from "hono";
 import { serve } from "@hono/node-server";
 import { fileURLToPath } from "url";
-import { dirname as dirname6, join as join7, resolve as resolve8, extname as extname3, sep as sep2 } from "path";
+import { dirname as dirname3, join as join9, resolve as resolve10, extname as extname3, sep as sep2 } from "path";
 import { readFile, stat } from "fs/promises";
 import { createServer } from "net";
 import open from "open";
@@ -4239,14 +4630,14 @@ async function readFileResponse(absPath) {
 function buildApp(opts) {
   const app = new Hono2();
   app.route("/api", createApi({ statePath: opts.statePath, autoExport: true }));
-  const projectRoot = dirname6(resolve8(opts.statePath));
+  const projectRoot = dirname3(resolve10(opts.statePath));
   app.get("/:dir/*", async (c, next) => {
     const dirSeg = c.req.param("dir");
     if (!dirSeg.endsWith("-screenshots")) return next();
-    const shotsRoot = resolve8(projectRoot, dirSeg);
+    const shotsRoot = resolve10(projectRoot, dirSeg);
     const pathname = decodeURIComponent(new URL(c.req.url).pathname);
     const rest = pathname.slice(`/${dirSeg}`.length);
-    const target = resolve8(shotsRoot, "." + rest);
+    const target = resolve10(shotsRoot, "." + rest);
     const inside = target === shotsRoot || target.startsWith(shotsRoot + sep2);
     if (inside) {
       const file = await readFileResponse(target);
@@ -4255,19 +4646,21 @@ function buildApp(opts) {
     return c.notFound();
   });
   if (!opts.dev) {
-    const root = resolve8(opts.uiDir ?? DEFAULT_UI_DIR);
+    const root = resolve10(opts.uiDir ?? DEFAULT_UI_DIR);
     app.get("/*", async (c) => {
       const pathname = decodeURIComponent(new URL(c.req.url).pathname);
-      const target = resolve8(root, "." + pathname);
+      const target = resolve10(root, "." + pathname);
       const inside = target === root || target.startsWith(root + sep2);
       if (inside && pathname !== "/") {
         const file = await readFileResponse(target);
         if (file) return file;
       }
-      const index = await readFileResponse(join7(root, "index.html"));
+      const index = await readFileResponse(join9(root, "index.html"));
       if (index) return index;
       return c.notFound();
     });
+  } else {
+    app.get("/", (c) => c.html(DEV_LANDING_PAGE));
   }
   return app;
 }
@@ -4299,7 +4692,7 @@ async function startServer(opts) {
   });
 }
 function backgroundScan(statePath) {
-  const projectRoot = dirname6(resolve8(statePath));
+  const projectRoot = dirname3(resolve10(statePath));
   Promise.resolve().then(() => {
     const state = loadState(statePath);
     const existing = loadUsageCache(projectRoot);
@@ -4311,7 +4704,7 @@ function backgroundScan(statePath) {
     console.warn("[scan] failed:", err instanceof Error ? err.message : String(err));
   });
 }
-var here, DEFAULT_UI_DIR, MIME, DEFAULT_PORT, DEV_PORT;
+var here, DEFAULT_UI_DIR, MIME, DEFAULT_PORT, DEV_PORT, DEV_UI_URL, DEV_LANDING_PAGE;
 var init_server = __esm({
   "src/server/server.ts"() {
     "use strict";
@@ -4319,8 +4712,8 @@ var init_server = __esm({
     init_state();
     init_scan();
     init_scanner();
-    here = dirname6(fileURLToPath(import.meta.url));
-    DEFAULT_UI_DIR = join7(here, "..", "ui");
+    here = dirname3(fileURLToPath(import.meta.url));
+    DEFAULT_UI_DIR = join9(here, "..", "ui");
     MIME = {
       ".html": "text/html; charset=utf-8",
       ".js": "text/javascript; charset=utf-8",
@@ -4337,6 +4730,15 @@ var init_server = __esm({
     };
     DEFAULT_PORT = 3e3;
     DEV_PORT = 8787;
+    DEV_UI_URL = "http://localhost:5173";
+    DEV_LANDING_PAGE = `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>Glotfile \u2014 dev API</title>
+<style>body{font:16px/1.6 system-ui,sans-serif;max-width:34rem;margin:16vh auto;padding:0 1.5rem;color:#1f2937}h1{font-size:1.4rem}a{color:#2563eb}code{background:#f3f4f6;padding:.1em .35em;border-radius:.3em}</style>
+</head><body>
+<h1>Glotfile \u2014 dev API server</h1>
+<p>This port serves the <strong>API only</strong>. In dev, the app is served by Vite.</p>
+<p>Open the app \u2192 <a href="${DEV_UI_URL}">${DEV_UI_URL}</a> (the <code>[ui] Local:</code> URL in your terminal).</p>
+</body></html>`;
   }
 });
 
@@ -4345,14 +4747,15 @@ init_state();
 init_export_run();
 init_storage();
 init_ai();
+init_local_settings();
 init_run();
 init_provider();
 init_log();
 init_scan();
 init_scanner();
 init_context();
-import { resolve as resolve9, dirname as dirname7 } from "path";
-import { readFileSync as readFileSync13, existsSync as existsSync10 } from "fs";
+import { resolve as resolve11, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync15, existsSync as existsSync11 } from "fs";
 
 // src/server/lint/run.ts
 init_glob();
@@ -4654,15 +5057,15 @@ async function runLint(state, options = {}) {
 
 // src/server/lint/outputs.ts
 init_adapters();
-import { readFileSync as readFileSync9, existsSync as existsSync7 } from "fs";
-import { resolve as resolve6 } from "path";
+import { readFileSync as readFileSync10, existsSync as existsSync8 } from "fs";
+import { resolve as resolve8 } from "path";
 function checkOutputs(state, root) {
   const out = [];
   for (const output of state.config.outputs) {
     const result = getAdapter(output.adapter).export(state, output);
     for (const file of result.files) {
-      const abs = resolve6(root, file.path);
-      const current = existsSync7(abs) ? readFileSync9(abs, "utf8") : null;
+      const abs = resolve8(root, file.path);
+      const current = existsSync8(abs) ? readFileSync10(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) {
@@ -4740,7 +5143,7 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 var COMMANDS = ["serve", "export", "translate", "lint", "check", "import", "build-context", "scan", "prune", "split"];
 var isCommand = (s) => s != null && COMMANDS.includes(s);
 function parseArgs(argv) {
-  const statePath = resolve9(process.cwd(), "glotfile.json");
+  const statePath = resolve11(process.cwd(), "glotfile.json");
   const first = argv[0];
   if (first === "help" || first === "--help" || first === "-h") {
     return isCommand(argv[1]) ? { command: argv[1], statePath, help: true } : { command: "help", statePath };
@@ -4758,7 +5161,7 @@ function parseArgs(argv) {
     if (flag === "--help" || flag === "-h") args.help = true;
     else if (flag === "--dev") args.dev = true;
     else if ((flag === "--file" || flag === "-f") && next) {
-      args.statePath = resolve9(process.cwd(), next);
+      args.statePath = resolve11(process.cwd(), next);
       i++;
     } else if (flag === "--adapter" && next) {
       args.adapter = next;
@@ -4814,7 +5217,7 @@ function watchTargetFor(statePath) {
   return detectFormat(statePath) === "split" ? { path: splitDirFor(statePath), recursive: true } : { path: statePath, recursive: false };
 }
 async function runExport(args) {
-  const root = dirname7(resolve9(args.statePath));
+  const root = dirname4(resolve11(args.statePath));
   const runOnce = () => {
     const state = loadState(args.statePath);
     const result = exportToDisk(state, root, args.adapter ? { adapter: args.adapter } : void 0);
@@ -4850,7 +5253,7 @@ async function runExport(args) {
 }
 async function runTranslate(args) {
   const state = loadState(args.statePath);
-  const projectRoot = dirname7(resolve9(args.statePath));
+  const projectRoot = dirname4(resolve11(args.statePath));
   const reqs = selectRequests(state, {
     // Default to translating only empty values; --all forces a full re-translate
     // (overwriting existing translations). --only missing stays as a no-op alias.
@@ -4862,33 +5265,38 @@ async function runTranslate(args) {
   let written = 0;
   let errors = [];
   if (toTranslate.length) {
+    const ai = loadLocalSettings(projectRoot).ai;
     let provider;
     try {
-      provider = makeProvider(state.config);
+      provider = makeProvider(ai);
     } catch (e) {
       console.error(e.message);
       process.exitCode = 1;
       return;
     }
     const { skipped } = attachScreenshotsForProvider(toTranslate, state, projectRoot, provider.supportsVision());
-    if (skipped) console.warn(`Model "${state.config.ai.model}" has no vision support; ${skipped} screenshot(s) ignored.`);
+    if (skipped) console.warn(`Model "${ai.model}" has no vision support; ${skipped} screenshot(s) ignored.`);
     console.log(`Translating ${toTranslate.length} string(s)\u2026`);
     let batchCallbackFired = false;
-    const results = await runLocaleParallel(toTranslate, provider, (done, total, batchResults) => {
-      batchCallbackFired = true;
-      const batchApplied = applyResults(state, toTranslate, batchResults);
-      written += batchApplied.written;
-      errors.push(...batchApplied.errors);
-      saveState(args.statePath, state);
-      process.stdout.write(`\r  ${done}/${total} translated`);
+    const results = await runLocaleParallel(toTranslate, provider, {
+      onBatchComplete: (done, total, batchResults) => {
+        batchCallbackFired = true;
+        const batchApplied = applyResults(state, toTranslate, batchResults);
+        written += batchApplied.written;
+        errors.push(...batchApplied.errors);
+        saveState(args.statePath, state);
+        process.stdout.write(`\r  ${done}/${total} translated`);
+      }
     });
     process.stdout.write("\n");
     if (!batchCallbackFired) {
       ({ written, errors } = applyResults(state, toTranslate, results));
     }
-    appendAiLog(projectRoot, {
+    appendLog(projectRoot, {
       at: (/* @__PURE__ */ new Date()).toISOString(),
-      model: state.config.ai.model,
+      kind: "translate",
+      summary: `Translated ${toTranslate.length} item(s)`,
+      model: ai.model,
       system: buildSystemPrompt(),
       items: toTranslate.map((r) => ({
         id: r.id,
@@ -4915,7 +5323,7 @@ function printReport(report, format, rawText) {
 }
 async function runLintCmd(args) {
   const state = loadState(args.statePath);
-  const rawText = existsSync10(args.statePath) ? readFileSync13(args.statePath, "utf8") : "";
+  const rawText = existsSync11(args.statePath) ? readFileSync15(args.statePath, "utf8") : "";
   const report = await runLint(state, { locales: args.locales, ruleIds: args.ruleIds });
   printReport(report, args.format, rawText);
   const tooManyWarnings = args.maxWarnings != null && report.counts.warn > args.maxWarnings;
@@ -4935,8 +5343,8 @@ async function runCheck(args) {
     process.exitCode = 1;
     return;
   }
-  const rawText = existsSync10(args.statePath) ? readFileSync13(args.statePath, "utf8") : "";
-  const root = dirname7(resolve9(args.statePath));
+  const rawText = existsSync11(args.statePath) ? readFileSync15(args.statePath, "utf8") : "";
+  const root = dirname4(resolve11(args.statePath));
   const lint = await runLint(state, {});
   const findings = sortFindings([...lint.findings, ...checkOutputs(state, root)]);
   const counts = countSeverities(findings);
@@ -4946,9 +5354,9 @@ async function runCheck(args) {
 }
 async function runImportCmd(args) {
   const { runImport: runImport2 } = await Promise.resolve().then(() => (init_run2(), run_exports));
-  const projectRoot = args.importSource ? resolve9(args.importSource) : dirname7(resolve9(args.statePath));
-  const out = resolve9(projectRoot, "glotfile.json");
-  if (existsSync10(out) && !args.importForce) {
+  const projectRoot = args.importSource ? resolve11(args.importSource) : dirname4(resolve11(args.statePath));
+  const out = resolve11(projectRoot, "glotfile.json");
+  if (existsSync11(out) && !args.importForce) {
     console.error(`${out} already exists; pass --force to overwrite`);
     process.exitCode = 1;
     return;
@@ -4973,7 +5381,7 @@ async function runImportCmd(args) {
 }
 async function runBuildContext(args) {
   const state = loadState(args.statePath);
-  const projectRoot = dirname7(resolve9(args.statePath));
+  const projectRoot = dirname4(resolve11(args.statePath));
   const cache2 = loadUsageCache(projectRoot);
   if (!cache2) {
     console.error("No usage index found. Run 'glotfile scan' first.");
@@ -4992,7 +5400,7 @@ async function runBuildContext(args) {
   }
   let provider;
   try {
-    provider = makeProvider(state.config);
+    provider = makeProvider(loadLocalSettings(projectRoot).ai);
   } catch (e) {
     console.error(e.message);
     process.exitCode = 1;
@@ -5022,7 +5430,7 @@ async function runBuildContext(args) {
 }
 async function runScanCmd(args) {
   const state = loadState(args.statePath);
-  const projectRoot = dirname7(resolve9(args.statePath));
+  const projectRoot = dirname4(resolve11(args.statePath));
   const existing = loadUsageCache(projectRoot);
   const result = runScan(projectRoot, state.config.scan ?? {}, existing);
   const fileCount2 = Object.keys(result.files).length;
@@ -5041,7 +5449,7 @@ async function runPrune(args) {
     for (const k of findEmptySourceKeys(state)) toRemove.add(k);
   }
   if (args.unused) {
-    const projectRoot = dirname7(resolve9(args.statePath));
+    const projectRoot = dirname4(resolve11(args.statePath));
     const cache2 = runScan(projectRoot, state.config.scan ?? {}, loadUsageCache(projectRoot));
     const used = new Set(computeUsedKeys(state, cache2));
     for (const k of Object.keys(state.keys)) {
@@ -5208,9 +5616,10 @@ async function main(argv) {
   if (args.command === "split") return runSplit(args);
   const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const { url } = await startServer2({ statePath: args.statePath, dev: args.dev });
-  console.log(`Glotfile running at ${url}`);
+  if (args.dev) console.log(`Glotfile dev API on ${url} \u2014 open the UI at the Vite "Local:" URL above`);
+  else console.log(`Glotfile running at ${url}`);
 }
-if (resolve9(process.argv[1] ?? "") === resolve9(fileURLToPath2(import.meta.url))) {
+if (resolve11(process.argv[1] ?? "") === resolve11(fileURLToPath2(import.meta.url))) {
   main(process.argv.slice(2)).catch((err) => {
     console.error(err instanceof Error ? err.message : String(err));
     process.exit(1);