glotfile 0.2.0 → 0.3.1

package/dist/server/server.js

@@ -29,7 +29,7 @@ var init_dictionary_en = __esm({
 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 resolve7, extname as extname3, sep as sep2 } from "path";
+import { dirname as dirname3, join as join9, resolve as resolve9, extname as extname3, sep as sep2 } from "path";
 import { readFile, stat } from "fs/promises";
 import { createServer } from "net";
 import open from "open";
@@ -39,8 +39,7 @@ import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 
 // 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";
 
 // src/server/format.ts
@@ -61,6 +60,26 @@ function serializeJson(value, opts) {
   return opts.finalNewline ? body + "\n" : body;
 }
 
+// src/server/atomic-write.ts
+import { writeFileSync, renameSync, mkdirSync, rmSync } from "fs";
+import { dirname, join } from "path";
+var counter = 0;
+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;
+  }
+}
+
 // src/server/lint/registry.ts
 var RULE_IDS = [
   "empty-source",
@@ -83,7 +102,7 @@ function isPluralForm(key) {
   return PLURAL_CATEGORIES.includes(key) || EXACT_SELECTOR_RE.test(key);
 }
 var LOCALE_CASES = ["lower-hyphen", "lower-underscore", "bcp47-hyphen", "bcp47-underscore"];
-var PROVIDERS = ["anthropic", "openai", "bedrock", "openrouter"];
+var PROVIDERS = ["anthropic", "openai", "bedrock", "openrouter", "ollama", "claude-code"];
 var GlotfileError = class extends Error {
 };
 function isObject(v) {
@@ -138,17 +157,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");
@@ -279,7 +287,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
@@ -402,13 +409,13 @@ function gettextPluralForms(locale) {
 }
 
 // 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 +445,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 +465,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 +480,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++;
     }
   }
@@ -539,10 +545,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) {
@@ -681,6 +686,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);
@@ -736,11 +744,29 @@ function applyMachineTranslationForms(state, key, locale, forms, clock = systemC
 }
 
 // src/server/scan.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { resolve, dirname as dirname3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/server/glotfile-dir.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { resolve } from "path";
+function ensureGlotfileDir(projectRoot) {
+  const dir = resolve(projectRoot, ".glotfile");
+  mkdirSync3(dir, { recursive: true });
+  const ignore = resolve(dir, ".gitignore");
+  if (!existsSync3(ignore)) {
+    try {
+      writeFileSync2(ignore, "*\n");
+    } catch {
+    }
+  }
+  return dir;
+}
+
+// src/server/scan.ts
 function loadUsageCache(projectRoot) {
-  const path = resolve(projectRoot, ".glotfile", "usage.json");
-  if (!existsSync3(path)) return null;
+  const path = resolve2(projectRoot, ".glotfile", "usage.json");
+  if (!existsSync4(path)) return null;
   try {
     return JSON.parse(readFileSync3(path, "utf8"));
   } catch {
@@ -748,9 +774,9 @@ function loadUsageCache(projectRoot) {
   }
 }
 function saveUsageCache(projectRoot, cache2) {
-  const path = resolve(projectRoot, ".glotfile", "usage.json");
-  mkdirSync3(dirname3(path), { recursive: true });
-  writeFileSync3(path, JSON.stringify(cache2, null, 2) + "\n", "utf8");
+  ensureGlotfileDir(projectRoot);
+  const path = resolve2(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();
@@ -777,7 +803,7 @@ function computeUsedKeys(state, cache2) {
 
 // src/server/scanner.ts
 import { readdirSync as readdirSync2, statSync, readFileSync as readFileSync4 } from "fs";
-import { join as join2, extname, relative } from "path";
+import { join as join3, extname, relative } from "path";
 var PATTERNS = {
   laravel: [
     /\b(?:__|trans|trans_choice|Lang::(?:get|choice))\s*\(\s*'([^']+)'/g,
@@ -985,7 +1011,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 {
@@ -1015,7 +1041,7 @@ function runScan(projectRoot, opts, existing) {
     const ext = extname(relPath);
     const scanner = scannerForExt(ext);
     if (!scanner) continue;
-    const abs = join2(projectRoot, relPath);
+    const abs = join3(projectRoot, relPath);
     let st;
     try {
       st = statSync(abs);
@@ -1047,8 +1073,8 @@ function runScan(projectRoot, opts, existing) {
 }
 
 // src/server/ai/context.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
-import { resolve as resolve2 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve3 } from "path";
 var MAX_CONTEXT_LENGTH = 500;
 var SNIPPET_WINDOW = 15;
 var MAX_SNIPPETS = 3;
@@ -1064,9 +1090,9 @@ 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 = resolve2(projectRoot, ref.file);
+    const absPath = resolve3(projectRoot, ref.file);
     if (!fileCache.has(ref.file)) {
-      if (!existsSync4(absPath)) continue;
+      if (!existsSync5(absPath)) continue;
       const content = readFileSync5(absPath, "utf8");
       fileCache.set(ref.file, content.split("\n"));
     }
@@ -1372,8 +1398,8 @@ function pluralFormPlaceholdersMatch(category, source, form) {
 }
 
 // src/server/ai/run.ts
-import { readFileSync as readFileSync6, existsSync as existsSync5 } from "fs";
-import { resolve as resolve3, extname as extname2 } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
+import { resolve as resolve4, extname as extname2 } from "path";
 
 // src/server/glob.ts
 function globToRegExp2(glob) {
@@ -1468,8 +1494,8 @@ function attachScreenshots(reqs, state, projectRoot) {
     const mediaType = MEDIA_TYPES[extname2(screenshot).toLowerCase()];
     if (!mediaType) continue;
     if (!cache2.has(screenshot)) {
-      const abs = resolve3(projectRoot, screenshot);
-      if (!existsSync5(abs)) {
+      const abs = resolve4(projectRoot, screenshot);
+      if (!existsSync6(abs)) {
         cache2.set(screenshot, null);
       } else {
         const buf = readFileSync6(abs);
@@ -1489,7 +1515,7 @@ function attachScreenshotsForProvider(reqs, state, projectRoot, supportsVision)
   return { skipped: keys.size };
 }
 var DEFAULT_LOCALE_CONCURRENCY = 3;
-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) {
@@ -1509,11 +1535,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);
@@ -1535,10 +1564,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 };
@@ -2310,8 +2340,8 @@ function getAdapter(name) {
 }
 
 // src/server/api.ts
-import { writeFileSync as writeFileSync5, readFileSync as readFileSync11, mkdirSync as mkdirSync6, existsSync as existsSync8, readdirSync as readdirSync7, rmSync as rmSync3 } from "fs";
-import { dirname as dirname5, resolve as resolve6, basename, relative as relative3, sep } from "path";
+import { readFileSync as readFileSync13, existsSync as existsSync9, readdirSync as readdirSync7, statSync as statSync4, rmSync as rmSync4 } from "fs";
+import { dirname as dirname2, resolve as resolve8, basename, relative as relative3, sep } from "path";
 
 // src/server/ai/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
@@ -2400,7 +2430,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 };
 }
@@ -2623,7 +2653,7 @@ var BedrockProvider = class {
     }
     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;
@@ -2742,9 +2772,116 @@ var OpenRouterProvider = class extends OpenAIProvider {
   }
 };
 
+// src/server/ai/ollama.ts
+var OLLAMA_BASE_URL = "http://localhost:11434/v1";
+function ollamaClientOptions(config) {
+  return {
+    apiKey: process.env.OLLAMA_API_KEY ?? "ollama",
+    baseURL: config.endpoint ?? OLLAMA_BASE_URL
+  };
+}
+var 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((resolve10, 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;
+        }
+        resolve10(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 = 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);
@@ -2754,36 +2891,36 @@ 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.`);
   }
 }
 
-// src/server/ai/log.ts
-import { appendFileSync, readFileSync as readFileSync7, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
-import { resolve as resolve4 } from "path";
+// src/server/log.ts
+import { appendFileSync, readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
+import { resolve as resolve5 } from "path";
 function logPath(projectRoot) {
-  return resolve4(projectRoot, ".glotfile", "ai-log.jsonl");
+  return resolve5(projectRoot, ".glotfile", "log.jsonl");
 }
-function appendAiLog(projectRoot, entry) {
-  mkdirSync4(resolve4(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 (!existsSync6(path)) return [];
+  if (!existsSync7(path)) return [];
   const lines = readFileSync7(path, "utf8").split("\n").filter((l) => l.trim() !== "");
-  const entries = lines.map((l) => {
-    const e = JSON.parse(l);
-    e.kind ??= "translate";
-    return e;
-  });
+  const entries = lines.map((l) => JSON.parse(l));
   return entries.reverse().slice(0, limit);
 }
 
 // src/server/import/detect.ts
-import { existsSync as existsSync7, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join4 } from "path";
 var LOCALE_RE = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
 var VUE_DIR_CANDIDATES = ["src/locale", "src/locales", "src/i18n/locales", "locales", "lang"];
 function safeIsDir(p) {
@@ -2794,7 +2931,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 {
@@ -2808,22 +2945,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;
         }
@@ -2835,7 +2972,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) {
@@ -2851,7 +2988,7 @@ var BY_FORMAT = {
   "flutter-arb": detectArb
 };
 function detect(root, formatOverride) {
-  if (!existsSync7(root)) return null;
+  if (!existsSync8(root)) return null;
   if (formatOverride) {
     const fn = BY_FORMAT[formatOverride];
     if (!fn) throw new Error(`Unknown format: ${formatOverride}`);
@@ -2866,7 +3003,7 @@ function detect(root, formatOverride) {
 
 // src/server/import/parsers/vue-i18n-json.ts
 import { readdirSync as readdirSync4, readFileSync as readFileSync8 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/server/import/flatten.ts
 function flattenObject(value, prefix, warnings) {
@@ -2905,7 +3042,7 @@ var vueI18nJson2 = {
       if (opts?.locales && !opts.locales.includes(locale)) continue;
       let data;
       try {
-        data = JSON.parse(readFileSync8(join4(localeRoot, file), "utf8"));
+        data = JSON.parse(readFileSync8(join5(localeRoot, file), "utf8"));
       } catch (e) {
         warnings.push(`vue-i18n-json: failed to parse ${file}: ${e.message}`);
         continue;
@@ -2921,7 +3058,7 @@ var vueI18nJson2 = {
 
 // 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";
 
 // src/server/import/placeholders.ts
@@ -2931,13 +3068,13 @@ function laravelToCanonical(value) {
 
 // src/server/import/parsers/laravel-php.ts
 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);
     }
@@ -2974,7 +3111,7 @@ var laravelPhp2 = {
     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$/, "");
@@ -2998,7 +3135,7 @@ var laravelPhp2 = {
 
 // src/server/import/parsers/flutter-arb.ts
 import { readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var LOCALE_RE3 = /^[a-z]{2,3}([_-][A-Za-z]{2,4}){0,2}$/;
 function localeFromArbName(file) {
   const m = file.match(/^(.+)\.arb$/);
@@ -3034,7 +3171,7 @@ var flutterArb2 = {
       if (opts?.locales && !opts.locales.includes(locale)) continue;
       let data;
       try {
-        data = JSON.parse(readFileSync9(join6(localeRoot, file), "utf8"));
+        data = JSON.parse(readFileSync9(join7(localeRoot, file), "utf8"));
       } catch (e) {
         warnings.push(`flutter-arb: failed to parse ${file}: ${e.message}`);
         continue;
@@ -3132,7 +3269,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: [] }
     },
@@ -3189,8 +3325,8 @@ function runImport(opts) {
 }
 
 // src/server/export-run.ts
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync10 } from "fs";
-import { dirname as dirname4, resolve as resolve5 } from "path";
+import { readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve6 } from "path";
 function effectiveLocales(config) {
   const limit = config.exportLocales;
   if (!limit || limit.length === 0) return config.locales;
@@ -3212,7 +3348,7 @@ function exportToDisk(state, projectRoot, opts) {
     warnings.push(...result.warnings);
     const writtenPaths = /* @__PURE__ */ new Set();
     for (const f of result.files) {
-      const abs = resolve5(projectRoot, f.path);
+      const abs = resolve6(projectRoot, f.path);
       if (writtenPaths.has(abs)) {
         skipped++;
         continue;
@@ -3227,22 +3363,104 @@ function exportToDisk(state, projectRoot, opts) {
         skipped++;
         continue;
       }
-      mkdirSync5(dirname4(abs), { recursive: true });
-      writeFileSync4(abs, f.contents, "utf8");
+      writeFileAtomic(abs, f.contents);
       written++;
     }
   }
   return { written, skipped, warnings };
 }
 
+// src/server/ui-prefs.ts
+import { readFileSync as readFileSync11 } from "fs";
+import { homedir } from "os";
+import { join as join8 } from "path";
+var THEMES = ["system", "light", "dark"];
+var isThemeMode = (v) => THEMES.includes(v);
+var defaultUiPrefsPath = () => join8(homedir(), ".glotfile", "ui.json");
+var DEFAULTS = { theme: "system" };
+function readJson(path) {
+  try {
+    const parsed = JSON.parse(readFileSync11(path, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function loadUiPrefs(path) {
+  const raw = readJson(path);
+  return { theme: isThemeMode(raw.theme) ? raw.theme : DEFAULTS.theme };
+}
+function saveUiPrefs(path, prefs) {
+  const merged = { ...readJson(path), ...prefs };
+  writeFileAtomic(path, JSON.stringify(merged, null, 2) + "\n");
+}
+
+// src/server/local-settings.ts
+import { readFileSync as readFileSync12 } from "fs";
+import { resolve as resolve7 } from "path";
+var EDITOR_IDS = ["vscode", "zed", "phpstorm"];
+var isEditorId = (v) => EDITOR_IDS.includes(v);
+var DEFAULT_AI = {
+  provider: "anthropic",
+  model: "claude-haiku-4-5-20251001",
+  endpoint: null,
+  region: null,
+  batchSize: 25
+};
+var DEFAULT_EDITOR = "vscode";
+var settingsPath = (projectRoot) => resolve7(projectRoot, ".glotfile", "settings.json");
+function readJson2(path) {
+  try {
+    const parsed = JSON.parse(readFileSync12(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 = readJson2(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 = { ...readJson2(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;
+}
+
 // src/server/api.ts
 var sanitize = (s) => s.replace(/[^\w.\-]+/g, "_");
 var screenshotDirName = (statePath) => basename(statePath).replace(/\.[^.]+$/, "") + "-screenshots";
 function projectName(root) {
-  const nameFile = resolve6(root, ".idea", ".name");
-  if (existsSync8(nameFile)) {
+  const nameFile = resolve8(root, ".idea", ".name");
+  if (existsSync9(nameFile)) {
     try {
-      const name = readFileSync11(nameFile, "utf8").trim();
+      const name = readFileSync13(nameFile, "utf8").trim();
       if (name) return name;
     } catch {
     }
@@ -3252,7 +3470,7 @@ function projectName(root) {
 function createApi(deps) {
   const app = new Hono();
   const load = () => loadState(deps.statePath);
-  const projectRoot = dirname5(resolve6(deps.statePath));
+  const projectRoot = dirname2(resolve8(deps.statePath));
   let translateQueue = Promise.resolve();
   const withTranslateLock = (fn) => {
     const next = translateQueue.then(fn, fn);
@@ -3276,42 +3494,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")) && existsSync8(resolve6(projectRoot, name, "config.json"))) {
-        abs = resolve6(projectRoot, `${name}.json`);
-      } else if (name === "glotfile.json" || name.endsWith(".glotfile.json")) {
-        abs = resolve6(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 = resolve8(dir, name);
+        let filePath = null;
+        if ((name === "glotfile" || name.endsWith(".glotfile")) && existsSync9(resolve8(abs, "config.json"))) {
+          filePath = resolve8(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 = resolve6(projectRoot, path);
+    const resolved = resolve8(projectRoot, path);
     const inside = resolved === projectRoot || resolved.startsWith(projectRoot + sep);
     if (!inside) return c.json({ error: "file is outside the project" }, 400);
-    if (!existsSync8(resolved)) return c.json({ error: "file not found" }, 400);
+    if (!existsSync9(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) });
@@ -3326,6 +3594,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 });
   });
@@ -3335,37 +3604,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(resolve6(deps.statePath));
-    const abs = resolve6(root, screenshot);
+    const root = dirname2(resolve8(deps.statePath));
+    const abs = resolve8(root, screenshot);
     const rel = relative3(root, abs);
     const seg0 = rel.split(sep)[0] ?? "";
-    if (!rel.startsWith("..") && seg0.endsWith("-screenshots") && existsSync8(abs)) {
+    if (!rel.startsWith("..") && seg0.endsWith("-screenshots") && existsSync9(abs)) {
       try {
-        rmSync3(abs);
+        rmSync4(abs);
       } catch {
       }
     }
@@ -3374,9 +3651,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 });
   });
@@ -3400,6 +3679,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 });
   });
@@ -3417,6 +3697,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 });
   });
@@ -3442,6 +3723,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 });
   });
@@ -3465,6 +3747,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 });
   });
@@ -3474,15 +3757,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) => {
@@ -3491,52 +3780,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) => {
@@ -3545,6 +3850,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];
@@ -3552,7 +3858,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));
@@ -3560,14 +3867,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) => {
@@ -3575,18 +3887,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(resolve6(deps.statePath));
+    const root = dirname2(resolve8(deps.statePath));
     const dirName = screenshotDirName(deps.statePath);
-    const dir = resolve6(root, dirName);
-    mkdirSync6(dir, { recursive: true });
+    const dir = resolve8(root, dirName);
     const filename = `${sanitize(key)}__${sanitize(file.name)}`;
-    writeFileSync5(resolve6(dir, filename), Buffer.from(await file.arrayBuffer()));
+    writeFileAtomic(resolve8(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) => {
@@ -3596,6 +3908,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) => {
@@ -3640,12 +3953,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(resolve6(deps.statePath));
+    const root = dirname2(resolve8(deps.statePath));
     const warnings = [];
     let count = 0;
     for (const output of s.config.outputs) {
@@ -3653,9 +3967,8 @@ function createApi(deps) {
       const result = adapter.export(s, output);
       warnings.push(...result.warnings);
       for (const f of result.files) {
-        const abs = resolve6(root, f.path);
-        mkdirSync6(dirname5(abs), { recursive: true });
-        writeFileSync5(abs, f.contents, "utf8");
+        const abs = resolve8(root, f.path);
+        writeFileAtomic(abs, f.contents);
         count++;
       }
     }
@@ -3674,41 +3987,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)`);
@@ -3731,19 +4066,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) => ({
@@ -3757,12 +4095,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);
@@ -3786,7 +4124,7 @@ function createApi(deps) {
     const refs = [];
     const prefixRefs = [];
     for (const [file, entry] of Object.entries(cache2.files)) {
-      const abs = resolve6(projectRoot, file);
+      const abs = resolve8(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 });
       }
@@ -3827,9 +4165,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);
     }
@@ -3851,10 +4190,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 }))
@@ -3870,8 +4210,8 @@ function createApi(deps) {
 }
 
 // src/server/server.ts
-var here = dirname6(fileURLToPath(import.meta.url));
-var DEFAULT_UI_DIR = join7(here, "..", "ui");
+var here = dirname3(fileURLToPath(import.meta.url));
+var DEFAULT_UI_DIR = join9(here, "..", "ui");
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -3900,14 +4240,14 @@ async function readFileResponse(absPath) {
 function buildApp(opts) {
   const app = new Hono2();
   app.route("/api", createApi({ statePath: opts.statePath, autoExport: true }));
-  const projectRoot = dirname6(resolve7(opts.statePath));
+  const projectRoot = dirname3(resolve9(opts.statePath));
   app.get("/:dir/*", async (c, next) => {
     const dirSeg = c.req.param("dir");
     if (!dirSeg.endsWith("-screenshots")) return next();
-    const shotsRoot = resolve7(projectRoot, dirSeg);
+    const shotsRoot = resolve9(projectRoot, dirSeg);
     const pathname = decodeURIComponent(new URL(c.req.url).pathname);
     const rest = pathname.slice(`/${dirSeg}`.length);
-    const target = resolve7(shotsRoot, "." + rest);
+    const target = resolve9(shotsRoot, "." + rest);
     const inside = target === shotsRoot || target.startsWith(shotsRoot + sep2);
     if (inside) {
       const file = await readFileResponse(target);
@@ -3916,24 +4256,35 @@ function buildApp(opts) {
     return c.notFound();
   });
   if (!opts.dev) {
-    const root = resolve7(opts.uiDir ?? DEFAULT_UI_DIR);
+    const root = resolve9(opts.uiDir ?? DEFAULT_UI_DIR);
     app.get("/*", async (c) => {
       const pathname = decodeURIComponent(new URL(c.req.url).pathname);
-      const target = resolve7(root, "." + pathname);
+      const target = resolve9(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;
 }
 var DEFAULT_PORT = 3e3;
 var DEV_PORT = 8787;
+var DEV_UI_URL = "http://localhost:5173";
+var 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>`;
 function findAvailablePort(start) {
   return new Promise((resolveP, reject) => {
     const probe = createServer();
@@ -3962,7 +4313,7 @@ async function startServer(opts) {
   });
 }
 function backgroundScan(statePath) {
-  const projectRoot = dirname6(resolve7(statePath));
+  const projectRoot = dirname3(resolve9(statePath));
   Promise.resolve().then(() => {
     const state = loadState(statePath);
     const existing = loadUsageCache(projectRoot);