qwerty-cli 0.0.1-alpha.5 → 0.0.1-alpha.7

package/dist/cli.js

@@ -1,10 +1,10 @@
 // src/cli.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 
 // package.json
 var package_default = {
   name: "qwerty-cli",
-  version: "0.0.1-alpha.5",
+  version: "0.0.1-alpha.7",
   description: "Terminal clone of qwerty-learner: typing practice for English vocabulary, with chapters, dictation, mistake book, and audio.",
   type: "module",
   bin: {
@@ -40,7 +40,6 @@ var package_default = {
     chalk: "^5.3.0",
     commander: "^12.1.0",
     ink: "^5.0.1",
-    "ink-big-text": "^2.0.0",
     "p-queue": "^8.0.1",
     react: "^18.3.1",
     undici: "^6.19.8",
@@ -150,7 +149,9 @@ var ConfigSchema = z.object({
   }).default({ master: true, keystroke: true, feedback: true, keySoundName: "default" }),
   autoplayPronunciation: z.boolean().default(true),
   defaultMode: z.enum(["order", "dictation", "review", "random", "loop"]).default("order"),
-  defaultDict: z.string().optional()
+  defaultDict: z.string().optional(),
+  language: z.enum(["auto", "zh", "en"]).default("auto"),
+  stealth: z.enum(["off", "menu", "default"]).default("off")
 });
 var DEFAULTS = ConfigSchema.parse({});
 async function loadConfig() {
@@ -506,12 +507,13 @@ ${matches.length} matches`));
 
 // src/commands/practice.ts
 import { Command as Command3 } from "commander";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import { render } from "ink";
 import { createElement } from "react";
 
 // src/ui/App.tsx
-import { useApp as useApp4, useInput as useInput8 } from "ink";
+import { useRef as useRef4 } from "react";
+import { useApp as useApp4, useInput as useInput10 } from "ink";
 
 // src/ui/nav.tsx
 import { createContext, useContext, useState, useCallback } from "react";
@@ -541,17 +543,27 @@ function useNav() {
 }
 
 // src/ui/Fullscreen.tsx
-import { useEffect } from "react";
-import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
-var ENTER = "\x1B[?1049h\x1B[?25l";
+import { useEffect, useState as useState2 } from "react";
+import { Box, useStdout } from "ink";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ENTER = "\x1B[?1049h\x1B[?25l\x1B[2J\x1B[H";
 var LEAVE = "\x1B[?25h\x1B[?1049l";
 function shouldUse() {
   return Boolean(process.stdout.isTTY) && process.env.QWERTY_NO_ALTSCREEN !== "1";
 }
 function Fullscreen({ children }) {
+  const { stdout } = useStdout();
+  const [size, setSize] = useState2(() => ({
+    rows: stdout?.rows ?? 24,
+    cols: stdout?.columns ?? 80
+  }));
   useEffect(() => {
     if (!shouldUse()) return;
     process.stdout.write(ENTER);
+    const onResize = () => {
+      setSize({ rows: process.stdout.rows ?? 24, cols: process.stdout.columns ?? 80 });
+    };
+    process.stdout.on("resize", onResize);
     const leave = () => {
       try {
         process.stdout.write(LEAVE);
@@ -569,14 +581,15 @@ function Fullscreen({ children }) {
       process.off("SIGINT", onSignal);
       process.off("SIGTERM", onSignal);
       process.off("exit", leave);
+      process.stdout.off("resize", onResize);
       leave();
     };
   }, []);
-  return /* @__PURE__ */ jsx2(Fragment, { children });
+  return /* @__PURE__ */ jsx2(Box, { width: size.cols, height: size.rows, flexDirection: "column", children });
 }
 
 // src/ui/audio-context.tsx
-import { createContext as createContext2, useContext as useContext2, useEffect as useEffect2, useState as useState2 } from "react";
+import { createContext as createContext2, useContext as useContext2, useEffect as useEffect2, useState as useState3 } from "react";
 
 // src/infra/audio.ts
 import { spawn } from "child_process";
@@ -738,7 +751,7 @@ function AudioStatusProvider({
   disabled,
   children
 }) {
-  const [status, setStatus] = useState2({ warning: null, ready: false });
+  const [status, setStatus] = useState3({ warning: null, ready: false });
   useEffect2(() => {
     let cancelled = false;
     initAudio(disabled).then(() => {
@@ -759,14 +772,14 @@ function useAudioStatus() {
 }
 
 // src/ui/app-state.tsx
-import { createContext as createContext3, useCallback as useCallback2, useContext as useContext3, useState as useState3 } from "react";
+import { createContext as createContext3, useCallback as useCallback2, useContext as useContext3, useState as useState4 } from "react";
 import { jsx as jsx4 } from "react/jsx-runtime";
 var AppStateContext = createContext3(null);
 function AppStateProvider({
   initialCfg,
   children
 }) {
-  const [cfg, setCfgState] = useState3(initialCfg);
+  const [cfg, setCfgState] = useState4(initialCfg);
   const setCfg = useCallback2(async (next) => {
     setCfgState(next);
     await saveConfig(next);
@@ -779,14 +792,555 @@ function useAppState() {
   return ctx;
 }
 
+// src/i18n/context.tsx
+import { createContext as createContext4, useContext as useContext4, useMemo } from "react";
+
+// src/i18n/strings.ts
+var en = {
+  app: {
+    title: "qwerty",
+    subtitle: "typing practice for the terminal"
+  },
+  common: {
+    back: "back",
+    quit: "quit",
+    on: "on",
+    off: "off",
+    cancel: "cancel"
+  },
+  mainMenu: {
+    items: {
+      practiceLabel: "Practice",
+      practiceHintWith: (name) => `start ${name}`,
+      practiceHintNone: "pick a dictionary",
+      dictLabel: "Dictionaries",
+      dictHint: "browse, pull, set default",
+      wordLabel: "Word lookup",
+      wordHint: "search local dicts",
+      statsLabel: "Stats",
+      statsHint: "history & trends",
+      configLabel: "Config",
+      configHint: "edit preferences",
+      stealthLabel: "Stealth",
+      stealthHint: "quiet practice mode",
+      quitLabel: "Quit",
+      quitHint: "Esc or Ctrl+C also exits"
+    },
+    hint: "\u2191/\u2193 navigate  \xB7  Enter select  \xB7  letters jump",
+    helpHint: "? help"
+  },
+  dict: {
+    title: "Dictionaries",
+    loading: "loading dictionaries\u2026",
+    entries: (n) => `${n} entries`,
+    filterPlaceholder: "type to filter",
+    local: "local \u2713",
+    notLocal: "not local",
+    defaultMark: "default \u2605",
+    tagsLabel: (tags) => `tags: ${tags}`,
+    wordsLabel: (n) => `${n} words`,
+    pulling: (id) => `pulling ${id}\u2026`,
+    removing: (id) => `removing ${id}\u2026`,
+    errorOn: (id, msg) => `error on ${id}: ${msg}`,
+    footer: "\u2191/\u2193 select  \xB7  Enter actions  \xB7  Ctrl+K more  \xB7  Esc back",
+    action: {
+      title: "current dictionary",
+      setDefault: "set as default",
+      practice: "practice now",
+      delete: "delete local"
+    },
+    command: {
+      title: "more actions",
+      pull: "pull selected",
+      import: "import .json",
+      refreshList: "update dictionary list"
+    }
+  },
+  config: {
+    title: "Config",
+    fields: {
+      defaultDict: "default dict",
+      defaultMode: "default mode",
+      accent: "accent",
+      mirror: "dict mirror",
+      chapterSize: "chapter size",
+      autoplayPronunciation: "autoplay pronunciation",
+      soundsMaster: "sounds master",
+      soundsKeystroke: "sounds keystroke",
+      soundsFeedback: "sounds feedback",
+      soundsKeySound: "sounds key sound",
+      language: "language",
+      stealth: "stealth mode"
+    },
+    enumValues: {
+      stealth: { off: "off", menu: "show in menu", default: "default practice" }
+    },
+    hints: {
+      editing: "type to edit  \xB7  Enter save  \xB7  Esc cancel",
+      bool: "space toggle  \xB7  \u2191/\u2193 move  \xB7  Esc back",
+      enum: "\u2190/\u2192 cycle  \xB7  \u2191/\u2193 move  \xB7  Esc back",
+      dictRef: "Enter pick dict  \xB7  \u2191/\u2193 move  \xB7  Esc back",
+      stringOrInt: "Enter edit  \xB7  \u2191/\u2193 move  \xB7  Esc back"
+    }
+  },
+  stats: {
+    title: "Stats \xB7 overview",
+    loading: "loading stats\u2026",
+    none: "No practice history yet.",
+    nonePractice: "Run a practice session first.",
+    lifetime: "lifetime",
+    sessions: "sessions",
+    words: "words",
+    errors: "errors",
+    wpm: "wpm",
+    accuracy: "accuracy",
+    streak: "streak",
+    last: (n) => `last ${n} days  (\u2190/\u2192 cycle window)`,
+    cycleWindow: "\u2190/\u2192 cycle window  \xB7  Esc back",
+    recent: "recent sessions",
+    topMistakes: "top mistakes",
+    footer: "\u2190/\u2192 cycle window  \xB7  Esc back",
+    maxLabel: "max",
+    recentUnits: { words: "w", errors: "err", wpm: "wpm" },
+    multiDictSuffix: (n) => ` +${n} more`
+  },
+  word: {
+    title: "Word lookup",
+    indexing: "indexing local dictionaries\u2026",
+    none: "No local dictionaries.",
+    pullFirst: "Pull one in Dictionaries first.",
+    countAcross: (n) => `${n} words across local dicts`,
+    noMatches: (q) => `no matches for "${q}"`,
+    inDict: (name) => `in: ${name}`,
+    mistakes: (n, date) => `mistakes: ${n} (last ${date})`,
+    footer: "type to filter  \xB7  \u2191/\u2193 select  \xB7  Esc back"
+  },
+  practice: {
+    loading: "loading\u2026",
+    paused: "PAUSED",
+    chapterComplete: "CHAPTER COMPLETE",
+    chapterLabel: (c, t) => `chapter ${c}/${t}`,
+    reviewLabel: "review",
+    statusBar: {
+      mode: "mode",
+      accent: "accent"
+    },
+    modes: {
+      order: "order",
+      dictation: "dictation",
+      review: "review",
+      random: "random",
+      loop: "loop"
+    },
+    accents: {
+      us: "us",
+      uk: "uk"
+    },
+    statCards: {
+      words: "words",
+      errors: "errors",
+      wpm: "wpm",
+      accuracy: "accuracy",
+      elapsed: (t) => `elapsed ${t}`
+    },
+    pause: {
+      title: "PAUSED",
+      chapter: (c, t) => `chapter ${c}/${t}`,
+      progress: (completed, total) => `${completed}/${total}`,
+      hint: "Enter resume  \xB7  Esc back to menu"
+    },
+    summary: {
+      loopAgain: "again",
+      nextChapter: "next chapter",
+      reviewMistakes: "review mistakes",
+      backMenu: "back to menu"
+    },
+    footers: {
+      typing: "Ctrl+N skip  \xB7  Esc pause  \xB7  Tab replay"
+    },
+    errors: {
+      noMistakes: "No mistakes to review yet. Practice some chapters first.",
+      dictEmpty: (id) => `Dictionary ${id} is empty.`,
+      unknown: "Unknown error"
+    }
+  },
+  audio: {
+    noPlayer: "! No audio player found on PATH (looked for afplay/ffplay/mpg123/paplay/aplay/powershell). Sounds disabled."
+  },
+  report: {
+    title: "Session summary",
+    duration: "duration",
+    practiced: "practiced",
+    chapters: "chapters",
+    words: "words",
+    accuracy: "accuracy",
+    wpm: "wpm",
+    newMistakes: "new mistakes",
+    farewell: "see you next time.",
+    notPracticed: "no practice this run"
+  },
+  help: {
+    title: "Help",
+    subtitle: "all shortcuts",
+    sections: {
+      main: "main menu",
+      practice: "practice",
+      dict: "dictionaries",
+      config: "config",
+      stats: "stats",
+      word: "word lookup",
+      global: "global"
+    },
+    keys: {
+      navigate: "\u2191/\u2193 navigate items",
+      select: "Enter confirm / continue",
+      letterJump: "letter jump to menu item",
+      pause: "Esc pause practice",
+      skip: "Ctrl+N skip current word (neutral)",
+      replay: "Tab replay pronunciation",
+      resume: "Enter resume from pause",
+      backMenu: "Esc back to previous screen",
+      backScreen: "Esc close panel or back",
+      nextChapter: "Enter next chapter",
+      reviewMistakes: "m review mistakes",
+      filter: "type to filter list",
+      itemActions: "Enter open actions panel",
+      moreActions: "Ctrl+K more actions panel",
+      cycleWindow: "\u2190/\u2192 cycle day window",
+      stealthToggle: "Ctrl+I toggle stealth info row",
+      helpScreen: "? open this help screen",
+      quit: "Ctrl+C quit immediately"
+    },
+    footer: "Esc back"
+  },
+  stealth: {
+    paused: "paused",
+    chapterDone: "chapter done",
+    resumeHint: "Enter resume  \xB7  Esc menu",
+    nextHint: "Enter next  \xB7  Esc menu",
+    infoFmt: (dict, chapter, completed, total, wpm, accPct) => `${dict} \xB7 ${chapter} \xB7 ${completed}/${total} \xB7 ${wpm} wpm \xB7 ${accPct}%`
+  }
+};
+var zh = {
+  app: {
+    title: "qwerty",
+    subtitle: "\u7EC8\u7AEF\u952E\u76D8\u7EC3\u4E60"
+  },
+  common: {
+    back: "\u8FD4\u56DE",
+    quit: "\u9000\u51FA",
+    on: "\u5F00",
+    off: "\u5173",
+    cancel: "\u53D6\u6D88"
+  },
+  mainMenu: {
+    items: {
+      practiceLabel: "\u7EC3\u4E60",
+      practiceHintWith: (name) => `\u5F00\u59CB ${name}`,
+      practiceHintNone: "\u8BF7\u5148\u9009\u8BCD\u5178",
+      dictLabel: "\u8BCD\u5178",
+      dictHint: "\u6D4F\u89C8\u3001\u4E0B\u8F7D\u3001\u8BBE\u4E3A\u9ED8\u8BA4",
+      wordLabel: "\u67E5\u8BCD",
+      wordHint: "\u5728\u672C\u5730\u8BCD\u5178\u4E2D\u641C\u7D22",
+      statsLabel: "\u7EDF\u8BA1",
+      statsHint: "\u5386\u53F2\u4E0E\u8D8B\u52BF",
+      configLabel: "\u8BBE\u7F6E",
+      configHint: "\u4FEE\u6539\u504F\u597D",
+      stealthLabel: "\u6478\u9C7C",
+      stealthHint: "\u5B89\u9759\u7EC3\u4E60\u6A21\u5F0F",
+      quitLabel: "\u9000\u51FA",
+      quitHint: "Esc \u6216 Ctrl+C \u9000\u51FA"
+    },
+    hint: "\u2191/\u2193 \u79FB\u52A8  \xB7  Enter \u786E\u8BA4  \xB7  \u5B57\u6BCD\u76F4\u8FBE",
+    helpHint: "? \u5E2E\u52A9"
+  },
+  dict: {
+    title: "\u8BCD\u5178",
+    loading: "\u52A0\u8F7D\u8BCD\u5178\u4E2D\u2026",
+    entries: (n) => `${n} \u90E8\u8BCD\u5178`,
+    filterPlaceholder: "\u8F93\u5165\u8FC7\u6EE4",
+    local: "\u5DF2\u4E0B\u8F7D \u2713",
+    notLocal: "\u672A\u4E0B\u8F7D",
+    defaultMark: "\u9ED8\u8BA4 \u2605",
+    tagsLabel: (tags) => `\u6807\u7B7E:${tags}`,
+    wordsLabel: (n) => `${n} \u8BCD`,
+    pulling: (id) => `\u62C9\u53D6 ${id} \u4E2D\u2026`,
+    removing: (id) => `\u5220\u9664 ${id} \u4E2D\u2026`,
+    errorOn: (id, msg) => `${id} \u51FA\u9519:${msg}`,
+    footer: "\u2191/\u2193 \u9009\u62E9  \xB7  Enter \u64CD\u4F5C  \xB7  Ctrl+K \u66F4\u591A  \xB7  Esc \u8FD4\u56DE",
+    action: {
+      title: "\u5F53\u524D\u8BCD\u5178",
+      setDefault: "\u8BBE\u4E3A\u9ED8\u8BA4",
+      practice: "\u7ACB\u5373\u7EC3\u4E60",
+      delete: "\u5220\u9664\u672C\u5730"
+    },
+    command: {
+      title: "\u66F4\u591A\u529F\u80FD",
+      pull: "\u62C9\u53D6\u9009\u4E2D",
+      import: "\u5BFC\u5165 .json",
+      refreshList: "\u66F4\u65B0\u8BCD\u5178\u5217\u8868"
+    }
+  },
+  config: {
+    title: "\u8BBE\u7F6E",
+    fields: {
+      defaultDict: "\u9ED8\u8BA4\u8BCD\u5178",
+      defaultMode: "\u9ED8\u8BA4\u6A21\u5F0F",
+      accent: "\u53D1\u97F3",
+      mirror: "\u8BCD\u5178\u955C\u50CF\u6E90",
+      chapterSize: "\u7AE0\u8282\u5355\u8BCD\u6570",
+      autoplayPronunciation: "\u81EA\u52A8\u64AD\u653E\u53D1\u97F3",
+      soundsMaster: "\u97F3\u6548\u603B\u5F00\u5173",
+      soundsKeystroke: "\u6309\u952E\u97F3",
+      soundsFeedback: "\u53CD\u9988\u97F3",
+      soundsKeySound: "\u6309\u952E\u97F3\u8272",
+      language: "\u8BED\u8A00",
+      stealth: "\u6478\u9C7C\u6A21\u5F0F"
+    },
+    enumValues: {
+      stealth: { off: "\u5173\u95ED", menu: "\u4E3B\u83DC\u5355\u663E\u793A", default: "\u9ED8\u8BA4\u7EC3\u4E60\u6A21\u5F0F" }
+    },
+    hints: {
+      editing: "\u8F93\u5165\u4FEE\u6539  \xB7  Enter \u4FDD\u5B58  \xB7  Esc \u53D6\u6D88",
+      bool: "\u7A7A\u683C\u5207\u6362  \xB7  \u2191/\u2193 \u79FB\u52A8  \xB7  Esc \u8FD4\u56DE",
+      enum: "\u2190/\u2192 \u5207\u6362  \xB7  \u2191/\u2193 \u79FB\u52A8  \xB7  Esc \u8FD4\u56DE",
+      dictRef: "Enter \u9009\u8BCD\u5178  \xB7  \u2191/\u2193 \u79FB\u52A8  \xB7  Esc \u8FD4\u56DE",
+      stringOrInt: "Enter \u7F16\u8F91  \xB7  \u2191/\u2193 \u79FB\u52A8  \xB7  Esc \u8FD4\u56DE"
+    }
+  },
+  stats: {
+    title: "\u7EDF\u8BA1 \xB7 \u6982\u89C8",
+    loading: "\u52A0\u8F7D\u7EDF\u8BA1\u4E2D\u2026",
+    none: "\u8FD8\u6CA1\u6709\u7EC3\u4E60\u8BB0\u5F55\u3002",
+    nonePractice: "\u5148\u6765\u4E00\u6B21\u7EC3\u4E60\u5427\u3002",
+    lifetime: "\u7D2F\u8BA1",
+    sessions: "\u4F1A\u8BDD",
+    words: "\u8BCD\u6570",
+    errors: "\u9519\u8BEF",
+    wpm: "\u901F\u5EA6",
+    accuracy: "\u51C6\u786E\u7387",
+    streak: "\u8FDE\u7EED\u5929\u6570",
+    last: (n) => `\u6700\u8FD1 ${n} \u5929  (\u2190/\u2192 \u5207\u6362\u7A97\u53E3)`,
+    cycleWindow: "\u2190/\u2192 \u5207\u6362\u7A97\u53E3  \xB7  Esc \u8FD4\u56DE",
+    recent: "\u6700\u8FD1\u4F1A\u8BDD",
+    topMistakes: "\u9AD8\u9891\u9519\u8BCD",
+    footer: "\u2190/\u2192 \u5207\u6362\u7A97\u53E3  \xB7  Esc \u8FD4\u56DE",
+    maxLabel: "\u6700\u5927",
+    recentUnits: { words: "\u8BCD", errors: "\u9519", wpm: "\u901F" },
+    multiDictSuffix: (n) => ` \u7B49 ${n} \u90E8`
+  },
+  word: {
+    title: "\u67E5\u8BCD",
+    indexing: "\u7D22\u5F15\u672C\u5730\u8BCD\u5178\u4E2D\u2026",
+    none: "\u6CA1\u6709\u672C\u5730\u8BCD\u5178\u3002",
+    pullFirst: "\u5148\u5728\u300C\u8BCD\u5178\u300D\u4E2D\u62C9\u53D6\u4E00\u90E8\u3002",
+    countAcross: (n) => `\u672C\u5730\u8BCD\u5178\u5171 ${n} \u8BCD`,
+    noMatches: (q) => `\u6CA1\u6709\u5339\u914D\u300C${q}\u300D\u7684\u8BCD`,
+    inDict: (name) => `\u6765\u6E90:${name}`,
+    mistakes: (n, date) => `\u9519\u8FC7 ${n} \u6B21 (\u6700\u8FD1 ${date})`,
+    footer: "\u8F93\u5165\u8FC7\u6EE4  \xB7  \u2191/\u2193 \u9009\u62E9  \xB7  Esc \u8FD4\u56DE"
+  },
+  practice: {
+    loading: "\u52A0\u8F7D\u4E2D\u2026",
+    paused: "\u5DF2\u6682\u505C",
+    chapterComplete: "\u672C\u7AE0\u5B8C\u6210",
+    chapterLabel: (c, t) => `\u7B2C ${c}/${t} \u7AE0`,
+    reviewLabel: "\u590D\u4E60",
+    statusBar: {
+      mode: "\u6A21\u5F0F",
+      accent: "\u53D1\u97F3"
+    },
+    modes: {
+      order: "\u987A\u5E8F",
+      dictation: "\u9ED8\u5199",
+      review: "\u590D\u4E60",
+      random: "\u4E71\u5E8F",
+      loop: "\u5FAA\u73AF"
+    },
+    accents: {
+      us: "\u7F8E",
+      uk: "\u82F1"
+    },
+    statCards: {
+      words: "\u8BCD\u6570",
+      errors: "\u9519\u8BEF",
+      wpm: "\u901F\u5EA6",
+      accuracy: "\u51C6\u786E\u7387",
+      elapsed: (t) => `\u8017\u65F6 ${t}`
+    },
+    pause: {
+      title: "\u5DF2\u6682\u505C",
+      chapter: (c, t) => `\u7B2C ${c}/${t} \u7AE0`,
+      progress: (completed, total) => `${completed}/${total}`,
+      hint: "Enter \u7EE7\u7EED  \xB7  Esc \u8FD4\u56DE\u83DC\u5355"
+    },
+    summary: {
+      loopAgain: "\u518D\u6765\u4E00\u904D",
+      nextChapter: "\u4E0B\u4E00\u7AE0",
+      reviewMistakes: "\u590D\u4E60\u9519\u8BCD",
+      backMenu: "\u8FD4\u56DE\u83DC\u5355"
+    },
+    footers: {
+      typing: "Ctrl+N \u8DF3\u8FC7  \xB7  Esc \u6682\u505C  \xB7  Tab \u91CD\u64AD"
+    },
+    errors: {
+      noMistakes: "\u9519\u8BCD\u672C\u662F\u7A7A\u7684\u3002\u5148\u7EC3\u4E60\u51E0\u7AE0\u5427\u3002",
+      dictEmpty: (id) => `\u8BCD\u5178 ${id} \u662F\u7A7A\u7684\u3002`,
+      unknown: "\u672A\u77E5\u9519\u8BEF"
+    }
+  },
+  audio: {
+    noPlayer: "! \u672A\u5728 PATH \u4E2D\u627E\u5230\u97F3\u9891\u64AD\u653E\u5668(\u5C1D\u8BD5 afplay/ffplay/mpg123/paplay/aplay/powershell)\u3002\u97F3\u6548\u5DF2\u7981\u7528\u3002"
+  },
+  report: {
+    title: "\u672C\u6B21\u4F1A\u8BDD",
+    duration: "\u603B\u65F6\u957F",
+    practiced: "\u7EC3\u4E60\u7528\u65F6",
+    chapters: "\u5B8C\u6210\u7AE0\u8282",
+    words: "\u8BCD\u6570",
+    accuracy: "\u51C6\u786E\u7387",
+    wpm: "\u901F\u5EA6",
+    newMistakes: "\u65B0\u9519\u8BCD",
+    farewell: "\u4E0B\u6B21\u89C1\u3002",
+    notPracticed: "\u672C\u6B21\u672A\u7EC3\u4E60"
+  },
+  help: {
+    title: "\u5E2E\u52A9",
+    subtitle: "\u5168\u90E8\u5FEB\u6377\u952E",
+    sections: {
+      main: "\u4E3B\u83DC\u5355",
+      practice: "\u7EC3\u4E60",
+      dict: "\u8BCD\u5178",
+      config: "\u8BBE\u7F6E",
+      stats: "\u7EDF\u8BA1",
+      word: "\u67E5\u8BCD",
+      global: "\u5168\u5C40"
+    },
+    keys: {
+      navigate: "\u2191/\u2193 \u79FB\u52A8\u9009\u9879",
+      select: "Enter \u786E\u8BA4 / \u7EE7\u7EED",
+      letterJump: "\u5B57\u6BCD\u952E \u76F4\u8FBE\u83DC\u5355\u9879",
+      pause: "Esc \u6682\u505C\u7EC3\u4E60",
+      skip: "Ctrl+N \u8DF3\u8FC7\u5F53\u524D\u8BCD(\u4E0D\u8BA1\u9519)",
+      replay: "Tab \u91CD\u64AD\u53D1\u97F3",
+      resume: "Enter \u7EE7\u7EED\u7EC3\u4E60",
+      backMenu: "Esc \u8FD4\u56DE\u4E0A\u4E00\u5C4F",
+      backScreen: "Esc \u5173\u95ED\u9762\u677F / \u8FD4\u56DE",
+      nextChapter: "Enter \u4E0B\u4E00\u7AE0",
+      reviewMistakes: "m \u590D\u4E60\u9519\u8BCD",
+      filter: "\u8F93\u5165 \u8FC7\u6EE4\u5217\u8868",
+      itemActions: "Enter \u5F39\u51FA\u52A8\u4F5C\u9762\u677F",
+      moreActions: "Ctrl+K \u5F39\u51FA\u66F4\u591A\u529F\u80FD",
+      cycleWindow: "\u2190/\u2192 \u5207\u6362\u65E5\u7A97\u53E3",
+      stealthToggle: "Ctrl+I \u5207\u6362\u6478\u9C7C\u4FE1\u606F\u884C",
+      helpScreen: "? \u6253\u5F00\u672C\u5E2E\u52A9\u9875",
+      quit: "Ctrl+C \u7ACB\u5373\u9000\u51FA"
+    },
+    footer: "Esc \u8FD4\u56DE"
+  },
+  stealth: {
+    paused: "paused",
+    chapterDone: "chapter done",
+    resumeHint: "Enter resume  \xB7  Esc menu",
+    nextHint: "Enter next  \xB7  Esc menu",
+    infoFmt: (dict, chapter, completed, total, wpm, accPct) => `${dict} \xB7 ${chapter} \xB7 ${completed}/${total} \xB7 ${wpm} wpm \xB7 ${accPct}%`
+  }
+};
+
+// src/i18n/locale.ts
+function pickFromString(s) {
+  if (!s) return null;
+  const lower = s.toLowerCase();
+  if (lower.startsWith("zh")) return "zh";
+  if (lower.startsWith("en")) return "en";
+  return null;
+}
+function detectLocale(pref) {
+  if (pref === "zh" || pref === "en") return pref;
+  const env = process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || process.env.LANGUAGE;
+  const fromEnv = pickFromString(env);
+  if (fromEnv) return fromEnv;
+  try {
+    const intlLocale = Intl.DateTimeFormat().resolvedOptions().locale;
+    const fromIntl = pickFromString(intlLocale);
+    if (fromIntl) return fromIntl;
+  } catch {
+  }
+  return "en";
+}
+
+// src/i18n/context.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var StringsContext = createContext4(null);
+function StringsProvider({
+  pref,
+  children
+}) {
+  const value = useMemo(() => {
+    const lang = detectLocale(pref);
+    return { lang, t: lang === "zh" ? zh : en };
+  }, [pref]);
+  return /* @__PURE__ */ jsx5(StringsContext.Provider, { value, children });
+}
+function useStrings() {
+  const ctx = useContext4(StringsContext);
+  if (!ctx) throw new Error("useStrings must be used inside StringsProvider");
+  return ctx.t;
+}
+function pickStrings(pref) {
+  const lang = detectLocale(pref);
+  return { lang, t: lang === "zh" ? zh : en };
+}
+
+// src/ui/registry-context.tsx
+import { createContext as createContext5, useContext as useContext5, useEffect as useEffect3, useState as useState5 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var RegistryContext = createContext5(null);
+function RegistryProvider({ children }) {
+  const [registry, setRegistry] = useState5(null);
+  const [byId, setById] = useState5(/* @__PURE__ */ new Map());
+  useEffect3(() => {
+    let cancelled = false;
+    (async () => {
+      try {
+        const reg = await loadRegistry();
+        if (cancelled) return;
+        const map = /* @__PURE__ */ new Map();
+        for (const e of reg) map.set(e.id, e);
+        setRegistry(reg);
+        setById(map);
+      } catch {
+        if (!cancelled) {
+          setRegistry([]);
+          setById(/* @__PURE__ */ new Map());
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  return /* @__PURE__ */ jsx6(RegistryContext.Provider, { value: { registry, byId }, children });
+}
+function useRegistry() {
+  const ctx = useContext5(RegistryContext);
+  if (!ctx) throw new Error("useRegistry must be used inside RegistryProvider");
+  return ctx;
+}
+function useDictName(id) {
+  const { byId } = useRegistry();
+  if (!id) return "";
+  const entry = byId.get(id);
+  return entry?.name ?? id;
+}
+
 // src/ui/screens/MainMenu.tsx
-import { useState as useState4 } from "react";
-import { Box as Box2, Text as Text2, useApp, useInput } from "ink";
+import { useState as useState6 } from "react";
+import { Box as Box3, Text as Text2, useApp, useInput } from "ink";
 
 // src/ui/components/BigWord.tsx
-import { Box, Text, useStdout } from "ink";
-import BigText from "ink-big-text";
-import { jsx as jsx5, jsxs } from "react/jsx-runtime";
+import { Box as Box2, Text, useStdout as useStdout2 } from "ink";
+import { jsx as jsx7, jsxs } from "react/jsx-runtime";
 var PALETTE = {
   accent: "#5eead4",
   muted: "#6b7280",
@@ -797,66 +1351,127 @@ var PALETTE = {
   error: "#f87171"
 };
 function BigWord({ target, typed, error = false, hideTarget = false }) {
-  const { stdout } = useStdout();
+  const { stdout } = useStdout2();
   const cols = stdout?.columns ?? 80;
   const chars = [...target];
   const typedChars = [...typed];
-  const useBig = cols >= 60 && process.env.QWERTY_NO_BIGTEXT !== "1";
-  if (!useBig) {
-    return /* @__PURE__ */ jsx5(Box, { justifyContent: "center", children: chars.map((ch, i) => {
+  const sep = cols >= 80 ? "   " : cols >= 60 ? "  " : " ";
+  return /* @__PURE__ */ jsxs(Box2, { flexDirection: "column", alignItems: "center", paddingY: 1, children: [
+    /* @__PURE__ */ jsx7(Box2, { children: chars.map((ch, i) => {
       const isTyped = i < typedChars.length;
       const display = hideTarget && !isTyped ? "_" : isTyped ? typedChars[i] : ch;
-      const color = isTyped ? PALETTE.accent : error ? PALETTE.error : PALETTE.muted;
-      return /* @__PURE__ */ jsxs(Text, { bold: isTyped, color, underline: !isTyped && error, children: [
+      const color = error ? PALETTE.error : isTyped ? PALETTE.accent : PALETTE.muted;
+      return /* @__PURE__ */ jsxs(Text, { bold: true, color, children: [
         display,
-        " "
+        i < chars.length - 1 ? sep : ""
       ] }, i);
-    }) });
+    }) }),
+    /* @__PURE__ */ jsx7(Box2, { children: chars.map((ch, i) => {
+      const isTyped = i < typedChars.length;
+      const trackChar = isTyped ? "\u2501" : "\u2500";
+      const color = error ? PALETTE.error : isTyped ? PALETTE.accent : PALETTE.muted;
+      return /* @__PURE__ */ jsxs(Text, { color, children: [
+        trackChar,
+        i < chars.length - 1 ? sep : ""
+      ] }, i);
+    }) })
+  ] });
+}
+
+// src/util/text.ts
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(s) {
+  return s.replace(ANSI_RE, "");
+}
+function visibleWidth2(s) {
+  const plain = stripAnsi(s);
+  let w = 0;
+  for (const ch of plain) {
+    const code = ch.codePointAt(0);
+    w += code > 11904 && code < 64256 ? 2 : 1;
   }
-  return /* @__PURE__ */ jsx5(Box, { justifyContent: "center", flexDirection: "row", children: chars.map((ch, i) => {
-    const isTyped = i < typedChars.length;
-    const display = hideTarget && !isTyped ? "_" : isTyped ? typedChars[i] : ch;
-    const color = isTyped ? PALETTE.accent : error ? PALETTE.error : PALETTE.muted;
-    return /* @__PURE__ */ jsx5(BigText, { text: display, font: "tiny", colors: [color], space: false }, i);
-  }) });
+  return w;
+}
+
+// src/util/dict-name.ts
+function truncateName(name, max) {
+  if (visibleWidth2(name) <= max) return name;
+  let out = "";
+  let w = 0;
+  for (const ch of name) {
+    const code = ch.codePointAt(0);
+    const cw = code > 11904 && code < 64256 ? 2 : 1;
+    if (w + cw > max - 1) break;
+    out += ch;
+    w += cw;
+  }
+  return out + "\u2026";
 }
 
 // src/ui/screens/MainMenu.tsx
-import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx8, jsxs as jsxs2 } from "react/jsx-runtime";
 function MainMenu({ cfg }) {
-  const [selected, setSelected] = useState4(0);
+  const [selected, setSelected] = useState6(0);
   const { exit } = useApp();
   const nav = useNav();
   const audio = useAudioStatus();
+  const t = useStrings();
+  const defaultDictName = useDictName(cfg.defaultDict);
+  const m = t.mainMenu.items;
+  const startPractice = (stealth) => {
+    if (cfg.defaultDict) {
+      nav.navigate({
+        name: "practice",
+        params: {
+          dictId: cfg.defaultDict,
+          chapterIndex: 0,
+          mode: cfg.defaultMode,
+          stealth
+        }
+      });
+    } else {
+      nav.navigate({ name: "dict", params: { pickerMode: "choose-then-practice" } });
+    }
+  };
   const items = [
     {
       key: "p",
-      label: "Practice",
-      hint: cfg.defaultDict ? `start ${cfg.defaultDict}` : "pick a dictionary",
-      run: () => {
-        if (cfg.defaultDict) {
-          nav.navigate({
-            name: "practice",
-            params: { dictId: cfg.defaultDict, chapterIndex: 0, mode: cfg.defaultMode }
-          });
-        } else {
-          nav.navigate({ name: "dict", params: { pickerMode: "choose-then-practice" } });
-        }
-      }
-    },
-    { key: "d", label: "Dictionaries", hint: "browse, pull, set default", run: () => nav.navigate({ name: "dict" }) },
-    { key: "w", label: "Word lookup", hint: "search local dicts", run: () => nav.navigate({ name: "word" }) },
-    { key: "s", label: "Stats", hint: "history & trends", run: () => nav.navigate({ name: "stats" }) },
-    { key: "c", label: "Config", hint: "edit preferences", run: () => nav.navigate({ name: "config" }) },
-    { key: "q", label: "Quit", hint: "Ctrl+C also exits", run: () => exit() }
+      label: m.practiceLabel,
+      hint: cfg.defaultDict ? m.practiceHintWith(truncateName(defaultDictName, 24)) : m.practiceHintNone,
+      run: () => startPractice(cfg.stealth === "default")
+    }
   ];
+  if (cfg.stealth === "menu" || cfg.stealth === "default") {
+    items.push({
+      key: "b",
+      label: m.stealthLabel,
+      hint: m.stealthHint,
+      run: () => startPractice(true)
+    });
+  }
+  items.push(
+    { key: "d", label: m.dictLabel, hint: m.dictHint, run: () => nav.navigate({ name: "dict" }) },
+    { key: "w", label: m.wordLabel, hint: m.wordHint, run: () => nav.navigate({ name: "word" }) },
+    { key: "s", label: m.statsLabel, hint: m.statsHint, run: () => nav.navigate({ name: "stats" }) },
+    { key: "c", label: m.configLabel, hint: m.configHint, run: () => nav.navigate({ name: "config" }) },
+    { key: "q", label: m.quitLabel, hint: m.quitHint, run: () => exit() }
+  );
+  const labelW = Math.max(...items.map((it) => visibleWidth2(it.label))) + 4;
   useInput((input, key) => {
+    if (key.escape) {
+      exit();
+      return;
+    }
     if (key.upArrow) setSelected((i) => (i - 1 + items.length) % items.length);
     if (key.downArrow) setSelected((i) => (i + 1) % items.length);
     if (key.return) {
       items[selected].run();
       return;
     }
+    if (input === "?") {
+      nav.navigate({ name: "help" });
+      return;
+    }
     for (const it of items) {
       if (input === it.key) {
         it.run();
@@ -864,41 +1479,44 @@ function MainMenu({ cfg }) {
       }
     }
   });
-  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", children: [
-    /* @__PURE__ */ jsxs2(Box2, { children: [
-      /* @__PURE__ */ jsx6(Text2, { bold: true, color: PALETTE.accent, children: "qwerty" }),
-      /* @__PURE__ */ jsx6(Text2, { color: PALETTE.muted, children: "  \xB7  typing practice for the terminal" })
+  return /* @__PURE__ */ jsxs2(Box3, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", children: [
+    /* @__PURE__ */ jsxs2(Box3, { children: [
+      /* @__PURE__ */ jsx8(Text2, { bold: true, color: PALETTE.accent, children: t.app.title }),
+      /* @__PURE__ */ jsxs2(Text2, { color: PALETTE.muted, children: [
+        "  \xB7  ",
+        t.app.subtitle
+      ] })
     ] }),
-    /* @__PURE__ */ jsx6(Box2, { marginTop: 2, flexDirection: "column", children: items.map((it, i) => {
+    /* @__PURE__ */ jsx8(Box3, { marginTop: 2, flexDirection: "column", children: items.map((it, i) => {
       const active = i === selected;
-      return /* @__PURE__ */ jsxs2(Box2, { children: [
-        /* @__PURE__ */ jsx6(Text2, { color: active ? PALETTE.accent : PALETTE.muted, children: active ? "\u258C " : "  " }),
+      const pad = " ".repeat(Math.max(0, labelW - visibleWidth2(it.label)));
+      return /* @__PURE__ */ jsxs2(Box3, { children: [
+        /* @__PURE__ */ jsx8(Text2, { color: active ? PALETTE.accent : PALETTE.muted, children: active ? "\u258C " : "  " }),
         /* @__PURE__ */ jsxs2(Text2, { color: active ? PALETTE.accent : PALETTE.muted, children: [
           "[",
           it.key,
           "]"
         ] }),
-        /* @__PURE__ */ jsx6(Text2, { children: " " }),
-        /* @__PURE__ */ jsx6(Text2, { bold: active, color: active ? PALETTE.text : PALETTE.muted, children: it.label.padEnd(14) }),
-        /* @__PURE__ */ jsx6(Text2, { color: PALETTE.muted, children: it.hint })
+        /* @__PURE__ */ jsx8(Text2, { children: " " }),
+        /* @__PURE__ */ jsxs2(Text2, { bold: active, color: active ? PALETTE.text : PALETTE.muted, children: [
+          it.label,
+          pad
+        ] }),
+        /* @__PURE__ */ jsx8(Text2, { color: PALETTE.muted, children: it.hint })
       ] }, it.key);
     }) }),
-    /* @__PURE__ */ jsx6(Box2, { marginTop: 2, children: /* @__PURE__ */ jsxs2(Text2, { color: PALETTE.muted, children: [
-      "default dict: ",
-      cfg.defaultDict ?? "(none \u2014 pick one in Dictionaries)"
+    /* @__PURE__ */ jsx8(Box3, { marginTop: 2, children: /* @__PURE__ */ jsxs2(Text2, { color: PALETTE.muted, children: [
+      t.mainMenu.hint,
+      "  \xB7  ",
+      t.mainMenu.helpHint
     ] }) }),
-    /* @__PURE__ */ jsx6(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text2, { color: PALETTE.muted, children: "\u2191/\u2193 navigate  \xB7  Enter select  \xB7  letters jump" }) }),
-    audio.warning && /* @__PURE__ */ jsx6(Box2, { marginTop: 1, children: /* @__PURE__ */ jsxs2(Text2, { color: PALETTE.warning, children: [
-      "! ",
-      audio.warning
-    ] }) })
+    audio.warning && /* @__PURE__ */ jsx8(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text2, { color: PALETTE.warning, children: t.audio.noPlayer }) })
   ] });
 }
 
 // src/ui/screens/PracticeScreen.tsx
-import { useState as useState6, useEffect as useEffect5, useRef as useRef3 } from "react";
-import { Box as Box3, Text as Text3, useApp as useApp3, useInput as useInput3 } from "ink";
-import BigText2 from "ink-big-text";
+import { useState as useState8, useEffect as useEffect6, useRef as useRef3 } from "react";
+import { Box as Box5, Text as Text4, useApp as useApp3, useInput as useInput3 } from "ink";
 
 // src/util/shuffle.ts
 function shuffle(arr, rng = Math.random) {
@@ -942,25 +1560,25 @@ function buildPlaylist(chapter, mode, seed) {
 function initialState(target) {
   return { target, typed: "", errorsThisWord: 0 };
 }
-function reduce(state, ev) {
+function reduce(state2, ev) {
   switch (ev.type) {
     case "reset":
-      return { state: { ...state, typed: "" }, effect: "none" };
+      return { state: { ...state2, typed: "" }, effect: "none" };
     case "backspace": {
-      if (state.typed.length === 0) return { state, effect: "none" };
-      return { state: { ...state, typed: state.typed.slice(0, -1) }, effect: "none" };
+      if (state2.typed.length === 0) return { state: state2, effect: "none" };
+      return { state: { ...state2, typed: state2.typed.slice(0, -1) }, effect: "none" };
     }
     case "char": {
-      const candidate = state.typed + ev.ch;
-      const targetUpToCandidate = [...state.target].slice(0, [...candidate].length).join("");
+      const candidate = state2.typed + ev.ch;
+      const targetUpToCandidate = [...state2.target].slice(0, [...candidate].length).join("");
       if (candidate === targetUpToCandidate) {
-        if (candidate.length === state.target.length) {
-          return { state: { ...state, typed: candidate }, effect: "correct" };
+        if (candidate.length === state2.target.length) {
+          return { state: { ...state2, typed: candidate }, effect: "correct" };
         }
-        return { state: { ...state, typed: candidate }, effect: "progress" };
+        return { state: { ...state2, typed: candidate }, effect: "progress" };
       }
       return {
-        state: { ...state, typed: "", errorsThisWord: state.errorsThisWord + 1 },
+        state: { ...state2, typed: "", errorsThisWord: state2.errorsThisWord + 1 },
         effect: "wrong"
       };
     }
@@ -982,11 +1600,11 @@ function startSession(playlist, now = Date.now()) {
 }
 function feedSession(session, ev, now = Date.now()) {
   if (!session.current) return { session, effect: "none" };
-  const { state, effect } = reduce(session.current.input, ev);
+  const { state: state2, effect } = reduce(session.current.input, ev);
   if (effect === "correct") {
     const finished = {
-      word: state.target,
-      errors: state.errorsThisWord,
+      word: state2.target,
+      errors: state2.errorsThisWord,
       durationMs: now - session.current.wordStartedAt
     };
     const nextIndex = session.current.wordIndex + 1;
@@ -1013,7 +1631,7 @@ function feedSession(session, ev, now = Date.now()) {
   return {
     session: {
       ...session,
-      current: { ...session.current, input: state }
+      current: { ...session.current, input: state2 }
     },
     effect
   };
@@ -1097,24 +1715,24 @@ function topN(book, n) {
 }
 
 // src/ui/hooks/useWordLoop.ts
-import { useEffect as useEffect3, useReducer, useRef, useState as useState5 } from "react";
+import { useEffect as useEffect4, useReducer, useRef, useState as useState7 } from "react";
 import { useInput as useInput2, useApp as useApp2 } from "ink";
-function reducer(state, action) {
+function reducer(state2, action) {
   if (action.type === "start") {
     return { session: startSession(action.playlist, action.now), lastEffect: null };
   }
   if (action.type === "skip") {
-    const r = skipSession(state.session, action.now);
+    const r = skipSession(state2.session, action.now);
     return { session: r.session, lastEffect: r.effect };
   }
   if (action.type === "event") {
     if (action.key.backspace || action.key.delete) {
-      const r = feedSession(state.session, { type: "backspace" }, action.now);
+      const r = feedSession(state2.session, { type: "backspace" }, action.now);
       return { session: r.session, lastEffect: r.effect };
     }
-    if (action.input.length === 0) return state;
-    let session = state.session;
-    let lastEffect = state.lastEffect;
+    if (action.input.length === 0) return state2;
+    let session = state2.session;
+    let lastEffect = state2.lastEffect;
     for (const c of action.input) {
       const r = feedSession(session, { type: "char", ch: c }, action.now);
       session = r.session;
@@ -1123,15 +1741,15 @@ function reducer(state, action) {
     }
     return { session, lastEffect };
   }
-  return state;
+  return state2;
 }
 function useWordLoop({ playlist, onComplete, onTab, onEscape, onSkip, enabled = true }) {
-  const [state, dispatch] = useReducer(reducer, void 0, () => ({
+  const [state2, dispatch] = useReducer(reducer, void 0, () => ({
     session: startSession(playlist, Date.now()),
     lastEffect: null
   }));
   const completedRef = useRef(false);
-  const [tick, setTick] = useState5(0);
+  const [tick, setTick] = useState7(0);
   const { exit } = useApp2();
   useInput2(
     (input, key) => {
@@ -1163,25 +1781,25 @@ function useWordLoop({ playlist, onComplete, onTab, onEscape, onSkip, enabled =
     },
     { isActive: enabled }
   );
-  useEffect3(() => {
-    if (state.session.finishedAt !== null && !completedRef.current) {
+  useEffect4(() => {
+    if (state2.session.finishedAt !== null && !completedRef.current) {
       completedRef.current = true;
-      onComplete(state.session);
+      onComplete(state2.session);
     }
-  }, [state.session, onComplete]);
-  useEffect3(() => {
-    if (state.session.finishedAt !== null) return;
+  }, [state2.session, onComplete]);
+  useEffect4(() => {
+    if (state2.session.finishedAt !== null) return;
     const id = setInterval(() => setTick((t) => t + 1), 1e3);
     return () => clearInterval(id);
-  }, [state.session.finishedAt]);
-  return { session: state.session, lastEffect: state.lastEffect, tick };
+  }, [state2.session.finishedAt]);
+  return { session: state2.session, lastEffect: state2.lastEffect, tick };
 }
 
 // src/ui/hooks/useAudio.ts
-import { useEffect as useEffect4, useRef as useRef2 } from "react";
+import { useEffect as useEffect5, useRef as useRef2 } from "react";
 function useAudio(opts) {
   const initedRef = useRef2(false);
-  useEffect4(() => {
+  useEffect5(() => {
     if (initedRef.current) return;
     initedRef.current = true;
     initAudio(!opts.enabled).catch(() => void 0);
@@ -1284,6 +1902,43 @@ function dailyBuckets(sessions, days, now = /* @__PURE__ */ new Date()) {
   return out;
 }
 
+// src/infra/session-tracker.ts
+var state = {
+  startedAt: null,
+  chapters: []
+};
+function start(now = Date.now()) {
+  if (state.startedAt === null) state.startedAt = now;
+}
+function addChapter(entry) {
+  if (state.startedAt === null) state.startedAt = Date.now();
+  state.chapters.push(entry);
+}
+function report(now = Date.now()) {
+  const chapters = state.chapters;
+  const wordCount = chapters.reduce((a, c) => a + c.wordCount, 0);
+  const errors = chapters.reduce((a, c) => a + c.errors, 0);
+  const practiceMs = chapters.reduce((a, c) => a + c.durationMs, 0);
+  const minutes = practiceMs / 6e4;
+  const wpm = minutes > 0 ? Math.round(wordCount / minutes * 10) / 10 : 0;
+  const errorWordSet = /* @__PURE__ */ new Set();
+  for (const c of chapters) {
+    for (const w of Object.keys(c.perWordErrors)) errorWordSet.add(w);
+  }
+  const accuracy2 = wordCount === 0 ? 1 : Math.max(0, (wordCount - errorWordSet.size) / wordCount);
+  return {
+    startedAt: state.startedAt,
+    totalDurationMs: state.startedAt === null ? 0 : now - state.startedAt,
+    chaptersCompleted: chapters.length,
+    wordCount,
+    errors,
+    wpm,
+    accuracy: accuracy2,
+    newMistakeWords: errorWordSet.size,
+    practiceMs
+  };
+}
+
 // src/ui/hooks/useSessionPersistence.ts
 function useSessionPersistence(meta) {
   return useCallback3(
@@ -1299,6 +1954,15 @@ function useSessionPersistence(meta) {
         perWordErrors: summary.perWordErrors
       };
       await appendSession(rec);
+      addChapter({
+        dictId: meta.dictId,
+        chapterIndex: meta.chapterIndex,
+        mode: meta.mode,
+        wordCount: summary.wordCount,
+        errors: summary.errors,
+        durationMs: summary.durationMs,
+        perWordErrors: summary.perWordErrors
+      });
       const dirty = Object.entries(summary.perWordErrors).filter(([, n]) => n > 0);
       if (dirty.length === 0) return;
       let book = await loadMistakes();
@@ -1309,16 +1973,80 @@ function useSessionPersistence(meta) {
   );
 }
 
+// src/ui/screens/StealthPracticeLayout.tsx
+import { Box as Box4, Text as Text3 } from "ink";
+import { jsx as jsx9, jsxs as jsxs3 } from "react/jsx-runtime";
+var TYPED = "#d4d4d4";
+var UNTYPED = "#808080";
+var DIM = "#6b6b6b";
+function fmtTime(ms) {
+  const total = Math.floor(ms / 1e3);
+  const m = Math.floor(total / 60);
+  const s = total % 60;
+  return `${m}:${String(s).padStart(2, "0")}`;
+}
+function StealthTyping(props) {
+  const t = useStrings();
+  const target = [...props.target];
+  const typed = [...props.typed];
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", width: "100%", height: "100%", paddingX: 4, paddingY: 3, children: [
+    /* @__PURE__ */ jsx9(Box4, { flexGrow: 1 }),
+    /* @__PURE__ */ jsxs3(Box4, { children: [
+      /* @__PURE__ */ jsx9(Text3, { color: UNTYPED, children: "[" }),
+      target.map((ch, i) => {
+        const isTyped = i < typed.length;
+        const display = props.hideTarget && !isTyped ? "_" : isTyped ? typed[i] : ch;
+        const color = isTyped ? TYPED : UNTYPED;
+        return /* @__PURE__ */ jsx9(Text3, { color, inverse: props.error && isTyped && i === typed.length - 1, children: display }, i);
+      }),
+      /* @__PURE__ */ jsx9(Text3, { color: UNTYPED, children: "]" })
+    ] }),
+    /* @__PURE__ */ jsxs3(Box4, { children: [
+      props.phonetic && /* @__PURE__ */ jsx9(Text3, { color: DIM, children: props.phonetic }),
+      props.phonetic && props.translation.length > 0 && /* @__PURE__ */ jsx9(Text3, { color: DIM, children: "  \xB7  " }),
+      props.translation.length > 0 && /* @__PURE__ */ jsx9(Text3, { color: DIM, children: props.translation.slice(0, 1).join("") })
+    ] }),
+    /* @__PURE__ */ jsx9(Box4, { children: props.info.visible ? /* @__PURE__ */ jsx9(Text3, { color: DIM, children: t.stealth.infoFmt(
+      props.info.dictName,
+      props.info.chapterLabel,
+      props.info.completed,
+      props.info.total,
+      props.info.wpm,
+      props.info.accPct
+    ) }) : /* @__PURE__ */ jsx9(Text3, { children: " " }) }),
+    /* @__PURE__ */ jsx9(Box4, { flexGrow: 3 })
+  ] });
+}
+function StealthPaused() {
+  const t = useStrings();
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", width: "100%", height: "100%", paddingX: 4, paddingY: 3, children: [
+    /* @__PURE__ */ jsx9(Box4, { flexGrow: 1 }),
+    /* @__PURE__ */ jsx9(Box4, { children: /* @__PURE__ */ jsx9(Text3, { color: UNTYPED, children: t.stealth.paused }) }),
+    /* @__PURE__ */ jsx9(Box4, { children: /* @__PURE__ */ jsx9(Text3, { color: DIM, children: t.stealth.resumeHint }) }),
+    /* @__PURE__ */ jsx9(Box4, { flexGrow: 3 })
+  ] });
+}
+function StealthSummary(props) {
+  const t = useStrings();
+  const line = `${t.stealth.chapterDone} \xB7 ${props.wordCount}w \xB7 ${props.wpm}wpm \xB7 ${props.accPct}% \xB7 ${fmtTime(props.durationMs)}`;
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", width: "100%", height: "100%", paddingX: 4, paddingY: 3, children: [
+    /* @__PURE__ */ jsx9(Box4, { flexGrow: 1 }),
+    /* @__PURE__ */ jsx9(Box4, { children: /* @__PURE__ */ jsx9(Text3, { color: UNTYPED, children: line }) }),
+    /* @__PURE__ */ jsx9(Box4, { children: /* @__PURE__ */ jsx9(Text3, { color: DIM, children: t.stealth.nextHint }) }),
+    /* @__PURE__ */ jsx9(Box4, { flexGrow: 3 })
+  ] });
+}
+
 // src/ui/screens/PracticeScreen.tsx
-import { jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs4 } from "react/jsx-runtime";
 function PracticeScreen({ params }) {
   const { dictId, chapterIndex, mode } = params;
   const { cfg } = useAppState();
-  const nav = useNav();
-  const [phase, setPhase] = useState6("loading");
-  const [loaded, setLoaded] = useState6(null);
-  const [errorMsg, setErrorMsg] = useState6(null);
-  useEffect5(() => {
+  const t = useStrings();
+  const [phase, setPhase] = useState8("loading");
+  const [loaded, setLoaded] = useState8(null);
+  const [errorMsg, setErrorMsg] = useState8(null);
+  useEffect6(() => {
     let cancelled = false;
     setPhase("loading");
     setLoaded(null);
@@ -1332,7 +2060,7 @@ function PracticeScreen({ params }) {
           if (cancelled) return;
           const reviewWords = words.filter((w) => book[w.name]?.count).slice(0, cfg.chapterSize);
           if (reviewWords.length === 0) {
-            setErrorMsg("No mistakes to review yet. Practice some chapters first.");
+            setErrorMsg(t.practice.errors.noMistakes);
             setPhase("error");
             return;
           }
@@ -1342,7 +2070,7 @@ function PracticeScreen({ params }) {
         }
         const chapters = chunkChapters(words, cfg.chapterSize);
         if (chapters.length === 0) {
-          setErrorMsg(`Dictionary ${dictId} is empty.`);
+          setErrorMsg(t.practice.errors.dictEmpty(dictId));
           setPhase("error");
           return;
         }
@@ -1359,15 +2087,15 @@ function PracticeScreen({ params }) {
     return () => {
       cancelled = true;
     };
-  }, [dictId, chapterIndex, mode, cfg.chapterSize]);
+  }, [dictId, chapterIndex, mode, cfg.chapterSize, t]);
   if (phase === "loading") {
-    return /* @__PURE__ */ jsx7(Centered, { text: "loading\u2026", color: PALETTE.muted });
+    return /* @__PURE__ */ jsx10(Centered, { text: t.practice.loading, color: PALETTE.muted });
   }
   if (phase === "error") {
-    return /* @__PURE__ */ jsx7(ErrorView, { msg: errorMsg ?? "Unknown error" });
+    return /* @__PURE__ */ jsx10(ErrorView, { msg: errorMsg ?? t.practice.errors.unknown });
   }
   if (!loaded) return null;
-  return /* @__PURE__ */ jsx7(
+  return /* @__PURE__ */ jsx10(
     PracticeRunner,
     {
       params,
@@ -1375,7 +2103,7 @@ function PracticeScreen({ params }) {
       phase,
       setPhase
     },
-    `${dictId}-${chapterIndex}-${mode}`
+    `${dictId}-${chapterIndex}-${mode}-${params.stealth ? "s" : "n"}`
   );
 }
 function PracticeRunner({
@@ -1385,19 +2113,22 @@ function PracticeRunner({
   setPhase
 }) {
   const { dictId, chapterIndex, mode } = params;
+  const stealth = params.stealth === true;
   const { cfg } = useAppState();
   const nav = useNav();
   const { exit } = useApp3();
   const goBack = () => nav.stack.length > 1 ? nav.back() : exit();
   const persist = useSessionPersistence({ dictId, chapterIndex, mode });
+  const dictName = useDictName(dictId);
   const audio = useAudio({
-    enabled: cfg.sounds.master,
+    enabled: !stealth && cfg.sounds.master,
     accent: cfg.accent,
-    autoplayPronunciation: cfg.autoplayPronunciation
+    autoplayPronunciation: !stealth && cfg.autoplayPronunciation
   });
   const finishedRef = useRef3(false);
   const lastEffectRef = useRef3(null);
   const lastIndexRef = useRef3(-1);
+  const [infoVisible, setInfoVisible] = useState8(false);
   const { session, lastEffect, tick } = useWordLoop({
     playlist: loaded.playlist,
     enabled: phase === "typing",
@@ -1410,12 +2141,13 @@ function PracticeRunner({
       });
     },
     onEscape: () => setPhase(phase === "paused" ? "typing" : "paused"),
-    onTab: () => {
+    onTab: stealth ? void 0 : () => {
       const cur = session.current ? loaded.playlist[session.current.wordIndex] : void 0;
       if (cur) void audio.pronounce(cur.name);
     }
   });
-  useEffect5(() => {
+  useEffect6(() => {
+    if (stealth) return;
     if (lastEffect === null) return;
     if (lastEffect === lastEffectRef.current) return;
     lastEffectRef.current = lastEffect;
@@ -1425,8 +2157,9 @@ function PracticeRunner({
       if (cfg.sounds.feedback) audio.correct();
       if (cfg.sounds.keystroke) audio.keystroke();
     }
-  }, [lastEffect, audio, cfg.sounds.feedback, cfg.sounds.keystroke]);
-  useEffect5(() => {
+  }, [stealth, lastEffect, audio, cfg.sounds.feedback, cfg.sounds.keystroke]);
+  useEffect6(() => {
+    if (stealth) return;
     const idx = session.current?.wordIndex ?? -1;
     if (idx === -1) return;
     if (idx === lastIndexRef.current) return;
@@ -1435,63 +2168,148 @@ function PracticeRunner({
     const next = loaded.playlist[idx + 1];
     if (cur && cfg.autoplayPronunciation) audio.pronounce(cur.name);
     if (next) audio.prefetch(next.name);
-  }, [session.current?.wordIndex, audio, cfg.autoplayPronunciation, loaded.playlist]);
+  }, [stealth, session.current?.wordIndex, audio, cfg.autoplayPronunciation, loaded.playlist]);
   void tick;
   useInput3(
-    (input) => {
-      if (input === "r") setPhase("typing");
-      if (input === "q") goBack();
+    (input, key) => {
+      if (key.ctrl && input === "i") {
+        setInfoVisible((v) => !v);
+        return;
+      }
+    },
+    { isActive: stealth && phase === "typing" }
+  );
+  useInput3(
+    (_input, key) => {
+      if (key.return) {
+        setPhase("typing");
+        return;
+      }
+      if (key.escape) {
+        goBack();
+        return;
+      }
     },
     { isActive: phase === "paused" }
   );
   useInput3(
-    (input) => {
-      if (input === "q") {
+    (input, key) => {
+      if (key.escape) {
         goBack();
         return;
       }
-      if (input === "n") {
+      if (key.return) {
         const nextIdx = chapterIndex + 1;
         if (mode === "loop") {
-          nav.replace({ name: "practice", params: { dictId, chapterIndex, mode } });
+          nav.replace({
+            name: "practice",
+            params: { dictId, chapterIndex, mode, stealth: params.stealth }
+          });
         } else if (mode === "review" || nextIdx >= loaded.totalChapters) {
           goBack();
         } else {
-          nav.replace({ name: "practice", params: { dictId, chapterIndex: nextIdx, mode } });
+          nav.replace({
+            name: "practice",
+            params: { dictId, chapterIndex: nextIdx, mode, stealth: params.stealth }
+          });
         }
         return;
       }
       if (input === "m") {
-        nav.replace({ name: "practice", params: { dictId, chapterIndex: 0, mode: "review" } });
+        nav.replace({
+          name: "practice",
+          params: { dictId, chapterIndex: 0, mode: "review", stealth: params.stealth }
+        });
         return;
       }
     },
     { isActive: phase === "summary" }
   );
-  if (phase === "paused") return /* @__PURE__ */ jsx7(PausedView, {});
-  if (phase === "summary") {
-    return /* @__PURE__ */ jsx7(
+  const completed = session.results.length;
+  const errors = session.results.reduce((a, r) => a + r.errors, 0);
+  const elapsedMs = Date.now() - session.startedAt;
+  const minutes = elapsedMs / 6e4;
+  const wpm = minutes > 0 ? Math.round(completed / minutes * 10) / 10 : 0;
+  const summary = phase === "summary" ? sessionSummary(session) : null;
+  if (stealth) {
+    if (phase === "paused") return /* @__PURE__ */ jsx10(StealthPaused, {});
+    if (phase === "summary" && summary) {
+      const sMinutes = summary.durationMs / 6e4;
+      const sWpm = sMinutes > 0 ? Math.round(summary.wordCount / sMinutes * 10) / 10 : 0;
+      const sErrWords = Object.keys(summary.perWordErrors).length;
+      const sAcc = summary.wordCount === 0 ? 1 : Math.max(0, (summary.wordCount - sErrWords) / summary.wordCount);
+      const sAccPct = Math.round(sAcc * 1e3) / 10;
+      return /* @__PURE__ */ jsx10(
+        StealthSummary,
+        {
+          wordCount: summary.wordCount,
+          errors: summary.errors,
+          durationMs: summary.durationMs,
+          wpm: sWpm,
+          accPct: sAccPct
+        }
+      );
+    }
+    const currentWord2 = session.current ? loaded.playlist[session.current.wordIndex] : loaded.playlist[loaded.playlist.length - 1];
+    const inputState2 = session.current?.input ?? { target: "", typed: "", errorsThisWord: 0 };
+    const errWords = new Set(
+      session.results.filter((r) => r.errors > 0).map((r) => r.word)
+    ).size;
+    const accFrac = completed === 0 ? 1 : Math.max(0, (completed - errWords) / completed);
+    const accPct = Math.round(accFrac * 1e3) / 10;
+    const chapterLabel = mode === "review" ? "review" : `ch ${chapterIndex + 1}/${loaded.totalChapters}`;
+    return /* @__PURE__ */ jsx10(
+      StealthTyping,
+      {
+        target: currentWord2?.name ?? "",
+        typed: inputState2.typed,
+        hideTarget: mode === "dictation",
+        phonetic: pickPhonetic(currentWord2, cfg.accent),
+        translation: currentWord2?.trans ?? [],
+        error: lastEffect === "wrong",
+        info: {
+          visible: infoVisible,
+          dictName: truncateName(dictName, 24),
+          chapterLabel,
+          completed,
+          total: loaded.playlist.length,
+          wpm,
+          accPct
+        }
+      }
+    );
+  }
+  if (phase === "paused") {
+    return /* @__PURE__ */ jsx10(
+      PausedView,
+      {
+        dictName,
+        chapterIndex,
+        totalChapters: loaded.totalChapters,
+        mode,
+        completed,
+        total: loaded.playlist.length
+      }
+    );
+  }
+  if (phase === "summary" && summary) {
+    return /* @__PURE__ */ jsx10(
       SummaryView,
       {
-        dictId,
+        dictName,
         chapterIndex,
         totalChapters: loaded.totalChapters,
         mode,
-        summary: sessionSummary(session)
+        summary
       }
     );
   }
   const currentWord = session.current ? loaded.playlist[session.current.wordIndex] : loaded.playlist[loaded.playlist.length - 1];
   const inputState = session.current?.input ?? { target: "", typed: "", errorsThisWord: 0 };
-  const elapsedMs = Date.now() - session.startedAt;
-  const completed = session.results.length;
-  const errors = session.results.reduce((a, r) => a + r.errors, 0);
-  const minutes = elapsedMs / 6e4;
-  const wpm = minutes > 0 ? Math.round(completed / minutes * 10) / 10 : 0;
-  return /* @__PURE__ */ jsx7(
+  return /* @__PURE__ */ jsx10(
     TypingLayout,
     {
-      dictId,
+      dictName,
       chapterIndex,
       totalChapters: loaded.totalChapters,
       mode,
@@ -1515,19 +2333,20 @@ function pickPhonetic(word, accent) {
   const p = accent === "us" ? word.usphone : word.ukphone;
   return p ? `/${p}/` : null;
 }
-function fmtTime(ms) {
+function fmtTime2(ms) {
   const total = Math.floor(ms / 1e3);
   const m = Math.floor(total / 60);
   const s = total % 60;
   return `${m}:${String(s).padStart(2, "0")}`;
 }
 function TypingLayout(props) {
+  const t = useStrings();
   const progressFrac = props.total === 0 ? 0 : props.completed / props.total;
-  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
-    /* @__PURE__ */ jsx7(
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx10(
       StatusBar,
       {
-        dictId: props.dictId,
+        dictName: props.dictName,
         chapterIndex: props.chapterIndex,
         totalChapters: props.totalChapters,
         mode: props.mode,
@@ -1537,8 +2356,8 @@ function TypingLayout(props) {
         elapsedMs: props.elapsedMs
       }
     ),
-    /* @__PURE__ */ jsxs3(Box3, { flexGrow: 1, flexDirection: "column", alignItems: "center", justifyContent: "center", children: [
-      /* @__PURE__ */ jsx7(
+    /* @__PURE__ */ jsxs4(Box5, { flexGrow: 1, flexDirection: "column", alignItems: "center", justifyContent: "center", children: [
+      /* @__PURE__ */ jsx10(
         BigWord,
         {
           target: props.target,
@@ -1547,34 +2366,41 @@ function TypingLayout(props) {
           hideTarget: props.hideTarget
         }
       ),
-      props.phonetic && /* @__PURE__ */ jsx7(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text3, { italic: true, color: PALETTE.muted, children: props.phonetic }) }),
-      props.translation.length > 0 && /* @__PURE__ */ jsx7(Box3, { marginTop: 1, flexDirection: "column", alignItems: "center", children: props.translation.slice(0, 2).map((t, i) => /* @__PURE__ */ jsx7(Text3, { color: PALETTE.primary, children: t }, i)) })
+      props.phonetic && /* @__PURE__ */ jsx10(Box5, { marginTop: 3, children: /* @__PURE__ */ jsx10(Text4, { italic: true, color: PALETTE.muted, children: props.phonetic }) }),
+      props.translation.length > 0 && /* @__PURE__ */ jsx10(Box5, { marginTop: 2, flexDirection: "column", alignItems: "center", children: props.translation.slice(0, 2).map((tr, i) => /* @__PURE__ */ jsx10(Text4, { color: PALETTE.primary, children: tr }, i)) })
     ] }),
-    /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx7(ProgressBar, { frac: progressFrac }),
-      /* @__PURE__ */ jsx7(Box3, { justifyContent: "center", marginTop: 1, children: /* @__PURE__ */ jsxs3(Text3, { color: PALETTE.muted, children: [
+    /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx10(ProgressBar, { frac: progressFrac }),
+      /* @__PURE__ */ jsx10(Box5, { justifyContent: "center", marginTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { color: PALETTE.muted, children: [
         props.completed,
         "/",
         props.total,
         "  \xB7  ",
-        fmtTime(props.elapsedMs),
+        fmtTime2(props.elapsedMs),
         "  \xB7  ",
         props.wpm,
-        " wpm  \xB7  ",
+        " ",
+        t.practice.statCards.wpm,
+        "  \xB7  ",
         props.errors,
-        " errors"
+        " ",
+        t.practice.statCards.errors
       ] }) }),
-      /* @__PURE__ */ jsx7(Box3, { justifyContent: "center", marginTop: 1, children: /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: "Ctrl+N skip  \xB7  Esc pause  \xB7  Tab replay  \xB7  Ctrl+C quit" }) })
+      /* @__PURE__ */ jsx10(Box5, { justifyContent: "center", marginTop: 1, children: /* @__PURE__ */ jsx10(Text4, { color: PALETTE.muted, children: t.practice.footers.typing }) })
     ] })
   ] });
 }
 function StatusBar(props) {
-  const left = props.mode === "review" ? `${props.dictId}  \xB7  review  \xB7  ${props.accent}` : `${props.dictId}  \xB7  ch ${props.chapterIndex + 1}/${props.totalChapters}  \xB7  ${props.mode}  \xB7  ${props.accent}`;
-  const right = `${props.completed}/${props.total}  \xB7  ${fmtTime(props.elapsedMs)}`;
-  return /* @__PURE__ */ jsxs3(Box3, { children: [
-    /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: left }),
-    /* @__PURE__ */ jsx7(Box3, { flexGrow: 1 }),
-    /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: right })
+  const t = useStrings();
+  const modeName = t.practice.modes[props.mode];
+  const accentName = t.practice.accents[props.accent];
+  const name = truncateName(props.dictName, 20);
+  const left = props.mode === "review" ? `${name}  \xB7  ${t.practice.reviewLabel}  \xB7  ${accentName}` : `${name}  \xB7  ${t.practice.chapterLabel(props.chapterIndex + 1, props.totalChapters)}  \xB7  ${modeName}  \xB7  ${accentName}`;
+  const right = `${props.completed}/${props.total}  \xB7  ${fmtTime2(props.elapsedMs)}`;
+  return /* @__PURE__ */ jsxs4(Box5, { children: [
+    /* @__PURE__ */ jsx10(Text4, { color: PALETTE.muted, children: left }),
+    /* @__PURE__ */ jsx10(Box5, { flexGrow: 1 }),
+    /* @__PURE__ */ jsx10(Text4, { color: PALETTE.muted, children: right })
   ] });
 }
 function ProgressBar({ frac }) {
@@ -1582,33 +2408,43 @@ function ProgressBar({ frac }) {
   const width = Math.max(20, Math.min(72, cols - 16));
   const filled = Math.round(width * Math.max(0, Math.min(1, frac)));
   const empty = width - filled;
-  return /* @__PURE__ */ jsxs3(Box3, { justifyContent: "center", children: [
-    /* @__PURE__ */ jsx7(Text3, { color: PALETTE.accent, children: "\u2501".repeat(filled) }),
-    /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: "\u2500".repeat(empty) })
+  return /* @__PURE__ */ jsxs4(Box5, { justifyContent: "center", children: [
+    /* @__PURE__ */ jsx10(Text4, { color: PALETTE.accent, children: "\u2501".repeat(filled) }),
+    /* @__PURE__ */ jsx10(Text4, { color: PALETTE.muted, children: "\u2500".repeat(empty) })
   ] });
 }
-function PausedView() {
-  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: [
-    /* @__PURE__ */ jsx7(BigText2, { text: "paused", font: "tiny", colors: [PALETTE.warning] }),
-    /* @__PURE__ */ jsx7(Box3, { marginTop: 2, children: /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: "[r] resume   \xB7   [q] quit to menu" }) })
+function PausedView(props) {
+  const t = useStrings();
+  const frac = props.total === 0 ? 0 : props.completed / props.total;
+  const subtitle = props.mode === "review" ? `${truncateName(props.dictName, 20)}  \xB7  ${t.practice.reviewLabel}` : `${truncateName(props.dictName, 20)}  \xB7  ${t.practice.pause.chapter(props.chapterIndex + 1, props.totalChapters)}`;
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx10(Text4, { bold: true, color: PALETTE.warning, children: t.practice.pause.title }),
+    /* @__PURE__ */ jsx10(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text4, { color: PALETTE.muted, children: subtitle }) }),
+    /* @__PURE__ */ jsx10(Box5, { marginTop: 2, children: /* @__PURE__ */ jsx10(ProgressBar, { frac }) }),
+    /* @__PURE__ */ jsx10(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text4, { color: PALETTE.muted, children: t.practice.pause.progress(props.completed, props.total) }) }),
+    /* @__PURE__ */ jsx10(Box5, { marginTop: 2, children: /* @__PURE__ */ jsx10(Text4, { color: PALETTE.muted, children: t.practice.pause.hint }) })
   ] });
 }
 function ErrorView({ msg }) {
-  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: [
-    /* @__PURE__ */ jsx7(Text3, { color: PALETTE.error, children: msg }),
-    /* @__PURE__ */ jsx7(Box3, { marginTop: 2, children: /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: "[q] back to menu" }) }),
-    /* @__PURE__ */ jsx7(BackKey, {})
+  const t = useStrings();
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx10(Text4, { color: PALETTE.error, children: msg }),
+    /* @__PURE__ */ jsx10(Box5, { marginTop: 2, children: /* @__PURE__ */ jsxs4(Text4, { color: PALETTE.muted, children: [
+      "Esc ",
+      t.common.back
+    ] }) }),
+    /* @__PURE__ */ jsx10(BackKey, {})
   ] });
 }
 function BackKey() {
   const nav = useNav();
-  useInput3((input, key) => {
-    if (input === "q" || key.escape) nav.back();
+  useInput3((_input, key) => {
+    if (key.escape) nav.back();
   });
   return null;
 }
 function Centered({ text, color }) {
-  return /* @__PURE__ */ jsx7(Box3, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx7(Text3, { color, children: text }) });
+  return /* @__PURE__ */ jsx10(Box5, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx10(Text4, { color, children: text }) });
 }
 function SummaryView(props) {
   const { summary } = props;
@@ -1617,52 +2453,126 @@ function SummaryView(props) {
   const errorWords = Object.keys(summary.perWordErrors).length;
   const acc = summary.wordCount === 0 ? 1 : Math.max(0, (summary.wordCount - errorWords) / summary.wordCount);
   const accPct = Math.round(acc * 1e3) / 10;
-  const subtitle = props.mode === "review" ? `${props.dictId}  \xB7  review` : `${props.dictId}  \xB7  chapter ${props.chapterIndex + 1}/${props.totalChapters}  \xB7  ${props.mode}`;
-  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", alignItems: "center", justifyContent: "center", paddingY: 1, width: "100%", height: "100%", children: [
-    /* @__PURE__ */ jsx7(BigText2, { text: "complete", font: "tiny", colors: [PALETTE.success] }),
-    /* @__PURE__ */ jsx7(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: subtitle }) }),
-    /* @__PURE__ */ jsxs3(Box3, { marginTop: 3, flexDirection: "row", justifyContent: "center", children: [
-      /* @__PURE__ */ jsx7(StatCard, { label: "words", value: String(summary.wordCount), color: PALETTE.text }),
-      /* @__PURE__ */ jsx7(
+  const t = useStrings();
+  const modeName = t.practice.modes[props.mode];
+  const name = truncateName(props.dictName, 20);
+  const subtitle = props.mode === "review" ? `${name}  \xB7  ${t.practice.reviewLabel}` : `${name}  \xB7  ${t.practice.chapterLabel(props.chapterIndex + 1, props.totalChapters)}  \xB7  ${modeName}`;
+  const nextLabel = props.mode === "loop" ? t.practice.summary.loopAgain : props.mode === "review" || props.chapterIndex + 1 >= props.totalChapters ? t.practice.summary.backMenu : t.practice.summary.nextChapter;
+  const footer = `Enter ${nextLabel}  \xB7  m ${t.practice.summary.reviewMistakes}  \xB7  Esc ${t.practice.summary.backMenu}`;
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", alignItems: "center", justifyContent: "center", paddingY: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx10(Text4, { bold: true, color: PALETTE.success, children: t.practice.chapterComplete }),
+    /* @__PURE__ */ jsx10(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text4, { color: PALETTE.muted, children: subtitle }) }),
+    /* @__PURE__ */ jsxs4(Box5, { marginTop: 3, flexDirection: "row", justifyContent: "center", children: [
+      /* @__PURE__ */ jsx10(StatCard, { label: t.practice.statCards.words, value: String(summary.wordCount), color: PALETTE.text }),
+      /* @__PURE__ */ jsx10(
         StatCard,
         {
-          label: "errors",
+          label: t.practice.statCards.errors,
           value: String(summary.errors),
           color: summary.errors > 0 ? PALETTE.error : PALETTE.muted
         }
       ),
-      /* @__PURE__ */ jsx7(StatCard, { label: "wpm", value: String(wpm), color: PALETTE.accent }),
-      /* @__PURE__ */ jsx7(StatCard, { label: "accuracy", value: `${accPct}%`, color: PALETTE.accent })
+      /* @__PURE__ */ jsx10(StatCard, { label: t.practice.statCards.wpm, value: String(wpm), color: PALETTE.accent }),
+      /* @__PURE__ */ jsx10(StatCard, { label: t.practice.statCards.accuracy, value: `${accPct}%`, color: PALETTE.accent })
     ] }),
-    /* @__PURE__ */ jsx7(Box3, { marginTop: 2, children: /* @__PURE__ */ jsxs3(Text3, { color: PALETTE.muted, children: [
-      "elapsed ",
-      fmtTime(summary.durationMs)
-    ] }) }),
-    /* @__PURE__ */ jsx7(Box3, { flexGrow: 1 }),
-    /* @__PURE__ */ jsx7(Box3, { marginTop: 2, children: /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: "[n] next chapter  \xB7  [m] review mistakes  \xB7  [q] back to menu" }) })
+    /* @__PURE__ */ jsx10(Box5, { marginTop: 2, children: /* @__PURE__ */ jsx10(Text4, { color: PALETTE.muted, children: t.practice.statCards.elapsed(fmtTime2(summary.durationMs)) }) }),
+    /* @__PURE__ */ jsx10(Box5, { flexGrow: 1 }),
+    /* @__PURE__ */ jsx10(Box5, { marginTop: 2, children: /* @__PURE__ */ jsx10(Text4, { color: PALETTE.muted, children: footer }) })
   ] });
 }
 function StatCard({ label, value, color }) {
-  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", alignItems: "center", marginX: 2, children: [
-    /* @__PURE__ */ jsx7(BigText2, { text: value, font: "tiny", colors: [color] }),
-    /* @__PURE__ */ jsx7(Text3, { color: PALETTE.muted, children: label })
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", alignItems: "center", marginX: 3, children: [
+    /* @__PURE__ */ jsx10(Text4, { bold: true, color, children: value }),
+    /* @__PURE__ */ jsx10(Text4, { color: PALETTE.muted, children: label })
   ] });
 }
 
 // src/ui/screens/DictBrowser.tsx
-import { useEffect as useEffect6, useState as useState7 } from "react";
-import { Box as Box4, Text as Text4, useInput as useInput4 } from "ink";
-import { Fragment as Fragment2, jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+import { useEffect as useEffect7, useMemo as useMemo2, useState as useState10 } from "react";
+import { Box as Box7, Text as Text6, useInput as useInput5, useStdout as useStdout3 } from "ink";
+
+// src/ui/components/ActionPanel.tsx
+import { useState as useState9 } from "react";
+import { Box as Box6, Text as Text5, useInput as useInput4 } from "ink";
+import { jsx as jsx11, jsxs as jsxs5 } from "react/jsx-runtime";
+function ActionPanel({ title, items, onClose }) {
+  const enabledIndices = items.map((it, i) => it.disabled ? -1 : i).filter((i) => i >= 0);
+  const initial = enabledIndices[0] ?? 0;
+  const [selected, setSelected] = useState9(initial);
+  useInput4((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.upArrow) {
+      const cur = enabledIndices.indexOf(selected);
+      const next = enabledIndices[(cur - 1 + enabledIndices.length) % enabledIndices.length];
+      if (next !== void 0) setSelected(next);
+      return;
+    }
+    if (key.downArrow) {
+      const cur = enabledIndices.indexOf(selected);
+      const next = enabledIndices[(cur + 1) % enabledIndices.length];
+      if (next !== void 0) setSelected(next);
+      return;
+    }
+    if (key.return) {
+      const item = items[selected];
+      if (item && !item.disabled) {
+        void item.run();
+      }
+      return;
+    }
+    for (let i = 0; i < items.length; i++) {
+      const it = items[i];
+      if (it.disabled) continue;
+      if (it.key && input === it.key) {
+        void it.run();
+        return;
+      }
+    }
+  });
+  const maxLabel = Math.max(...items.map((it) => it.label.length));
+  const width = Math.max(maxLabel + 8, title.length + 4, 24);
+  return /* @__PURE__ */ jsxs5(
+    Box6,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: PALETTE.accent,
+      paddingX: 2,
+      paddingY: 1,
+      width,
+      children: [
+        /* @__PURE__ */ jsx11(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx11(Text5, { bold: true, color: PALETTE.accent, children: title }) }),
+        items.map((it, i) => {
+          const active = i === selected;
+          const color = it.disabled ? PALETTE.muted : active ? PALETTE.text : PALETTE.muted;
+          return /* @__PURE__ */ jsxs5(Box6, { children: [
+            /* @__PURE__ */ jsx11(Text5, { color: active ? PALETTE.accent : PALETTE.muted, children: active ? "\u258C " : "  " }),
+            /* @__PURE__ */ jsx11(Text5, { bold: active, color, children: it.label })
+          ] }, i);
+        }),
+        /* @__PURE__ */ jsx11(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text5, { color: PALETTE.muted, children: "\u2191/\u2193 \xB7 Enter \xB7 Esc" }) })
+      ]
+    }
+  );
+}
+
+// src/ui/screens/DictBrowser.tsx
+import { Fragment, jsx as jsx12, jsxs as jsxs6 } from "react/jsx-runtime";
 function DictBrowser({ params }) {
   const nav = useNav();
   const { cfg, setCfg } = useAppState();
-  const [rows, setRows] = useState7([]);
-  const [loading, setLoading] = useState7(true);
-  const [selected, setSelected] = useState7(0);
-  const [filter, setFilter] = useState7("");
-  const [filterFocus, setFilterFocus] = useState7(false);
-  const [pending, setPending] = useState7(null);
-  const [tick, setTick] = useState7(0);
+  const t = useStrings();
+  const { stdout } = useStdout3();
+  const [rows, setRows] = useState10([]);
+  const [loading, setLoading] = useState10(true);
+  const [selected, setSelected] = useState10(0);
+  const [filter, setFilter] = useState10("");
+  const [pending, setPending] = useState10(null);
+  const [tick, setTick] = useState10(0);
+  const [panel, setPanel] = useState10(null);
   const refresh = async () => {
     const reg = await loadRegistry();
     const flagged = await Promise.all(
@@ -1671,168 +2581,227 @@ function DictBrowser({ params }) {
     setRows(flagged);
     setLoading(false);
   };
-  useEffect6(() => {
+  useEffect7(() => {
     void refresh();
   }, [tick]);
-  const filtered = filter ? rows.filter((r) => filterRegistry([r.entry], filter).length > 0) : rows;
+  const filtered = useMemo2(
+    () => filter ? rows.filter((r) => filterRegistry([r.entry], filter).length > 0) : rows,
+    [filter, rows]
+  );
   const safeSelected = Math.max(0, Math.min(filtered.length - 1, selected));
   const current = filtered[safeSelected];
-  useInput4((input, key) => {
-    if (filterFocus) {
-      if (key.escape || key.return) {
-        setFilterFocus(false);
-        return;
+  const rowsTotal = stdout?.rows ?? 24;
+  const visibleH = Math.max(6, rowsTotal - 8);
+  const half = Math.floor(visibleH / 2);
+  const start2 = Math.max(0, Math.min(filtered.length - visibleH, safeSelected - half));
+  const end = Math.min(filtered.length, start2 + visibleH);
+  const goPractice = (id) => {
+    nav.replace({
+      name: "practice",
+      params: {
+        dictId: id,
+        chapterIndex: 0,
+        mode: cfg.defaultMode,
+        stealth: cfg.stealth === "default"
       }
-      if (key.backspace || key.delete) {
-        setFilter((f) => f.slice(0, -1));
-        return;
+    });
+  };
+  const doSetDefault = async (id, navigate = true) => {
+    await setCfg({ ...cfg, defaultDict: id });
+    setPanel(null);
+    if (navigate) {
+      if (params?.pickerMode === "choose-then-practice") {
+        goPractice(id);
+      } else {
+        nav.back();
+      }
+    }
+  };
+  const doDelete = (id) => {
+    setPanel(null);
+    setPending({ kind: "removing", id });
+    void (async () => {
+      try {
+        await removeDictionary(id);
+        setPending(null);
+        setTick((n) => n + 1);
+      } catch (err) {
+        setPending({ kind: "error", id, msg: err.message });
       }
-      if (input && !key.ctrl && !key.meta) {
-        setFilter((f) => f + input);
+    })();
+  };
+  const doPull = (id) => {
+    setPanel(null);
+    setPending({ kind: "pulling", id });
+    void (async () => {
+      try {
+        await pullDictionary(id);
+        setPending(null);
+        setTick((n) => n + 1);
+      } catch (err) {
+        setPending({ kind: "error", id, msg: err.message });
       }
+    })();
+  };
+  const doRefreshList = () => {
+    setPanel(null);
+    setPending({ kind: "refreshing" });
+    setTick((n) => n + 1);
+    setPending(null);
+  };
+  useInput5((input, key) => {
+    if (panel !== null) return;
+    if (key.escape) {
+      nav.back();
       return;
     }
-    if (key.upArrow) setSelected((i) => Math.max(0, i - 1));
-    if (key.downArrow) setSelected((i) => Math.min(filtered.length - 1, i + 1));
-    if (input === "/") {
-      setFilterFocus(true);
+    if (key.upArrow) {
+      setSelected((i) => Math.max(0, i - 1));
       return;
     }
-    if (key.escape || input === "b") {
-      nav.back();
+    if (key.downArrow) {
+      setSelected((i) => Math.min(filtered.length - 1, i + 1));
       return;
     }
-    if (!current) return;
-    if (key.return) {
-      void (async () => {
-        await setCfg({ ...cfg, defaultDict: current.entry.id });
-        if (params?.pickerMode === "choose-then-practice") {
-          nav.replace({
-            name: "practice",
-            params: { dictId: current.entry.id, chapterIndex: 0, mode: cfg.defaultMode }
-          });
-        } else {
-          nav.back();
-        }
-      })();
+    if (key.ctrl && input === "k") {
+      setPanel("more");
       return;
     }
-    if (input === "p") {
-      nav.replace({
-        name: "practice",
-        params: { dictId: current.entry.id, chapterIndex: 0, mode: cfg.defaultMode }
-      });
+    if (key.return) {
+      if (current) setPanel("item");
       return;
     }
-    if (input === "r" && current.local) {
-      setPending({ kind: "removing", id: current.entry.id });
-      void (async () => {
-        try {
-          await removeDictionary(current.entry.id);
-          setPending(null);
-          setTick((t) => t + 1);
-        } catch (err) {
-          setPending({ kind: "error", id: current.entry.id, msg: err.message });
-        }
-      })();
+    if (key.backspace || key.delete) {
+      setFilter((f) => f.slice(0, -1));
+      setSelected(0);
       return;
     }
-    if (input === "u") {
-      setPending({ kind: "pulling", id: current.entry.id });
-      void (async () => {
-        try {
-          await pullDictionary(current.entry.id);
-          setPending(null);
-          setTick((t) => t + 1);
-        } catch (err) {
-          setPending({ kind: "error", id: current.entry.id, msg: err.message });
-        }
-      })();
+    if (input && !key.ctrl && !key.meta && input.length === 1) {
+      setFilter((f) => f + input);
+      setSelected(0);
     }
   });
   if (loading) {
-    return /* @__PURE__ */ jsx8(Box4, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx8(Text4, { color: PALETTE.muted, children: "loading dictionaries\u2026" }) });
+    return /* @__PURE__ */ jsx12(Box7, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx12(Text6, { color: PALETTE.muted, children: t.dict.loading }) });
   }
-  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
-    /* @__PURE__ */ jsxs4(Box4, { children: [
-      /* @__PURE__ */ jsx8(Text4, { bold: true, color: PALETTE.accent, children: "Dictionaries" }),
-      /* @__PURE__ */ jsx8(Box4, { flexGrow: 1 }),
-      /* @__PURE__ */ jsx8(Text4, { color: PALETTE.muted, children: filterFocus ? `/ ${filter}_` : filter ? `/ ${filter}` : `${filtered.length} entries` })
+  const itemPanelItems = current ? [
+    {
+      label: t.dict.action.setDefault,
+      run: () => void doSetDefault(current.entry.id, params?.pickerMode !== void 0)
+    },
+    {
+      label: t.dict.action.practice,
+      run: () => goPractice(current.entry.id)
+    },
+    {
+      label: t.dict.action.delete,
+      disabled: !current.local,
+      run: () => doDelete(current.entry.id)
+    },
+    { label: t.common.cancel, run: () => setPanel(null) }
+  ] : [];
+  const morePanelItems = [
+    {
+      label: t.dict.command.pull,
+      disabled: !current,
+      run: () => current && doPull(current.entry.id)
+    },
+    {
+      label: t.dict.command.import,
+      disabled: true,
+      run: () => void 0
+    },
+    { label: t.dict.command.refreshList, run: () => doRefreshList() },
+    { label: t.common.cancel, run: () => setPanel(null) }
+  ];
+  if (panel === "item" && current) {
+    return /* @__PURE__ */ jsx12(Box7, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx12(
+      ActionPanel,
+      {
+        title: `${t.dict.action.title}  \xB7  ${current.entry.name}`,
+        items: itemPanelItems,
+        onClose: () => setPanel(null)
+      }
+    ) });
+  }
+  if (panel === "more") {
+    return /* @__PURE__ */ jsx12(Box7, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx12(
+      ActionPanel,
+      {
+        title: t.dict.command.title,
+        items: morePanelItems,
+        onClose: () => setPanel(null)
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsxs6(Box7, { children: [
+      /* @__PURE__ */ jsx12(Text6, { bold: true, color: PALETTE.accent, children: t.dict.title }),
+      /* @__PURE__ */ jsx12(Box7, { flexGrow: 1 }),
+      /* @__PURE__ */ jsx12(Text6, { color: PALETTE.muted, children: filter ? `${t.dict.filterPlaceholder}: ${filter}_` : `${t.dict.filterPlaceholder}_` }),
+      /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.muted, children: [
+        "    ",
+        t.dict.entries(filtered.length)
+      ] })
     ] }),
-    /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, flexGrow: 1, children: [
-      /* @__PURE__ */ jsx8(Box4, { flexDirection: "column", width: "60%", children: filtered.slice(Math.max(0, safeSelected - 8), safeSelected + 16).map((row, vi) => {
-        const i = Math.max(0, safeSelected - 8) + vi;
+    /* @__PURE__ */ jsxs6(Box7, { marginTop: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ jsx12(Box7, { flexDirection: "column", width: "75%", paddingRight: 1, children: filtered.slice(start2, end).map((row, vi) => {
+        const i = start2 + vi;
         const active = i === safeSelected;
         const isDefault = cfg.defaultDict === row.entry.id;
-        return /* @__PURE__ */ jsxs4(Box4, { children: [
-          /* @__PURE__ */ jsx8(Text4, { color: active ? PALETTE.accent : PALETTE.muted, children: active ? "\u258C " : "  " }),
-          /* @__PURE__ */ jsx8(Text4, { color: row.local ? PALETTE.accent : PALETTE.muted, children: row.local ? "\u25CF" : "\u25CB" }),
-          /* @__PURE__ */ jsx8(Text4, { children: " " }),
-          /* @__PURE__ */ jsx8(Text4, { color: isDefault ? PALETTE.success : PALETTE.muted, children: isDefault ? "\u2605" : " " }),
-          /* @__PURE__ */ jsx8(Text4, { children: " " }),
-          /* @__PURE__ */ jsx8(Text4, { bold: active, color: active ? PALETTE.text : PALETTE.muted, children: row.entry.id.slice(0, 14).padEnd(15) }),
-          /* @__PURE__ */ jsx8(Text4, { color: PALETTE.muted, children: String(row.entry.length).padStart(5) })
+        return /* @__PURE__ */ jsxs6(Box7, { children: [
+          /* @__PURE__ */ jsx12(Box7, { width: 2, children: /* @__PURE__ */ jsx12(Text6, { color: active ? PALETTE.accent : PALETTE.muted, children: active ? "\u258C " : "  " }) }),
+          /* @__PURE__ */ jsx12(Box7, { width: 2, children: /* @__PURE__ */ jsx12(Text6, { color: row.local ? PALETTE.accent : PALETTE.muted, children: row.local ? "\u25CF" : "\u25CB" }) }),
+          /* @__PURE__ */ jsx12(Box7, { width: 2, children: /* @__PURE__ */ jsx12(Text6, { color: isDefault ? PALETTE.success : PALETTE.muted, children: isDefault ? "\u2605" : " " }) }),
+          /* @__PURE__ */ jsx12(Box7, { flexGrow: 1, children: /* @__PURE__ */ jsx12(Text6, { bold: active, color: active ? PALETTE.text : PALETTE.muted, wrap: "truncate", children: row.entry.name }) }),
+          /* @__PURE__ */ jsx12(Box7, { width: 6, children: /* @__PURE__ */ jsx12(Text6, { color: PALETTE.muted, children: String(row.entry.length).padStart(5) }) })
         ] }, row.entry.id);
       }) }),
-      /* @__PURE__ */ jsx8(Box4, { flexDirection: "column", width: "40%", paddingLeft: 2, children: current && /* @__PURE__ */ jsxs4(Fragment2, { children: [
-        /* @__PURE__ */ jsx8(Text4, { bold: true, color: PALETTE.text, children: current.entry.name }),
-        /* @__PURE__ */ jsx8(Text4, { color: PALETTE.muted, children: current.entry.id }),
-        /* @__PURE__ */ jsx8(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { color: PALETTE.muted, children: [
+      /* @__PURE__ */ jsx12(Box7, { flexDirection: "column", width: "25%", paddingLeft: 1, children: current && /* @__PURE__ */ jsxs6(Fragment, { children: [
+        /* @__PURE__ */ jsx12(Text6, { bold: true, color: PALETTE.text, wrap: "wrap", children: current.entry.name }),
+        /* @__PURE__ */ jsx12(Text6, { color: PALETTE.muted, children: current.entry.id }),
+        /* @__PURE__ */ jsx12(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.muted, wrap: "wrap", children: [
           current.entry.language,
           " \xB7 ",
-          current.entry.category,
-          " \xB7 ",
-          current.entry.length,
-          " words"
-        ] }) }),
-        /* @__PURE__ */ jsx8(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text4, { color: PALETTE.primary, children: current.entry.description || "(no description)" }) }),
-        current.entry.tags.length > 0 && /* @__PURE__ */ jsx8(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { color: PALETTE.muted, children: [
-          "tags: ",
-          current.entry.tags.join(", ")
+          current.entry.category
         ] }) }),
-        /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, children: [
-          /* @__PURE__ */ jsx8(Text4, { color: current.local ? PALETTE.accent : PALETTE.muted, children: current.local ? "local \u2713" : "not local" }),
-          cfg.defaultDict === current.entry.id && /* @__PURE__ */ jsx8(Text4, { color: PALETTE.success, children: "  \xB7 default \u2605" })
-        ] })
+        /* @__PURE__ */ jsx12(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text6, { color: PALETTE.muted, children: t.dict.wordsLabel(current.entry.length) }) }),
+        current.entry.description && /* @__PURE__ */ jsx12(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text6, { color: PALETTE.primary, wrap: "wrap", children: current.entry.description }) }),
+        current.entry.tags.length > 0 && /* @__PURE__ */ jsx12(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text6, { color: PALETTE.muted, wrap: "wrap", children: t.dict.tagsLabel(current.entry.tags.join(", ")) }) }),
+        /* @__PURE__ */ jsx12(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text6, { color: current.local ? PALETTE.accent : PALETTE.muted, children: current.local ? t.dict.local : t.dict.notLocal }) }),
+        cfg.defaultDict === current.entry.id && /* @__PURE__ */ jsx12(Box7, { children: /* @__PURE__ */ jsx12(Text6, { color: PALETTE.success, children: t.dict.defaultMark }) })
       ] }) })
     ] }),
-    pending && /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, children: [
-      pending.kind === "pulling" && /* @__PURE__ */ jsxs4(Text4, { color: PALETTE.warning, children: [
-        "pulling ",
-        pending.id,
-        "\u2026"
-      ] }),
-      pending.kind === "removing" && /* @__PURE__ */ jsxs4(Text4, { color: PALETTE.warning, children: [
-        "removing ",
-        pending.id,
+    pending && /* @__PURE__ */ jsxs6(Box7, { marginTop: 1, children: [
+      pending.kind === "pulling" && /* @__PURE__ */ jsx12(Text6, { color: PALETTE.warning, children: t.dict.pulling(pending.id) }),
+      pending.kind === "removing" && /* @__PURE__ */ jsx12(Text6, { color: PALETTE.warning, children: t.dict.removing(pending.id) }),
+      pending.kind === "refreshing" && /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.warning, children: [
+        t.dict.command.refreshList,
         "\u2026"
       ] }),
-      pending.kind === "error" && /* @__PURE__ */ jsxs4(Text4, { color: PALETTE.error, children: [
-        "error on ",
-        pending.id,
-        ": ",
-        pending.msg
-      ] })
+      pending.kind === "error" && /* @__PURE__ */ jsx12(Text6, { color: PALETTE.error, children: t.dict.errorOn(pending.id, pending.msg) })
     ] }),
-    /* @__PURE__ */ jsx8(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text4, { color: PALETTE.muted, children: "\u2191/\u2193 select  \xB7  Enter set default  \xB7  p practice  \xB7  u pull  \xB7  r remove  \xB7  / filter  \xB7  Esc back" }) })
+    /* @__PURE__ */ jsx12(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text6, { color: PALETTE.muted, children: t.dict.footer }) })
   ] });
 }
 
 // src/ui/screens/ConfigEditor.tsx
-import { useState as useState8 } from "react";
-import { Box as Box5, Text as Text5, useInput as useInput5 } from "ink";
-import { jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+import { useState as useState11 } from "react";
+import { Box as Box8, Text as Text7, useInput as useInput6 } from "ink";
+import { jsx as jsx13, jsxs as jsxs7 } from "react/jsx-runtime";
 var FIELDS = [
-  { kind: "dictRef", path: "defaultDict", label: "default dict" },
-  { kind: "enum", path: "defaultMode", label: "default mode", options: ["order", "dictation", "review", "random", "loop"] },
-  { kind: "enum", path: "accent", label: "accent", options: ["us", "uk"] },
-  { kind: "enum", path: "mirror", label: "mirror", options: ["jsdelivr", "github"] },
-  { kind: "int", path: "chapterSize", label: "chapter size", min: 1, max: 200 },
-  { kind: "bool", path: "autoplayPronunciation", label: "autoplay pronunciation" },
-  { kind: "bool", path: "sounds.master", label: "sounds master" },
-  { kind: "bool", path: "sounds.keystroke", label: "sounds keystroke" },
-  { kind: "bool", path: "sounds.feedback", label: "sounds feedback" },
-  { kind: "string", path: "sounds.keySoundName", label: "sounds key sound" }
+  { kind: "dictRef", path: "defaultDict", labelKey: "defaultDict" },
+  { kind: "enum", path: "defaultMode", labelKey: "defaultMode", options: ["order", "dictation", "review", "random", "loop"] },
+  { kind: "enum", path: "accent", labelKey: "accent", options: ["us", "uk"] },
+  { kind: "enum", path: "language", labelKey: "language", options: ["auto", "zh", "en"] },
+  { kind: "enum", path: "mirror", labelKey: "mirror", options: ["jsdelivr", "github"] },
+  { kind: "enum", path: "stealth", labelKey: "stealth", options: ["off", "menu", "default"] },
+  { kind: "int", path: "chapterSize", labelKey: "chapterSize", min: 1, max: 200 },
+  { kind: "bool", path: "autoplayPronunciation", labelKey: "autoplayPronunciation" },
+  { kind: "bool", path: "sounds.master", labelKey: "soundsMaster" },
+  { kind: "bool", path: "sounds.keystroke", labelKey: "soundsKeystroke" },
+  { kind: "bool", path: "sounds.feedback", labelKey: "soundsFeedback" },
+  { kind: "string", path: "sounds.keySoundName", labelKey: "soundsKeySound" }
 ];
 function getByPath2(cfg, path) {
   return path.split(".").reduce((acc, k) => {
@@ -1843,10 +2812,12 @@ function getByPath2(cfg, path) {
 function ConfigEditor() {
   const nav = useNav();
   const { cfg, setCfg } = useAppState();
-  const [selected, setSelected] = useState8(0);
-  const [editing, setEditing] = useState8(false);
-  const [draft, setDraft] = useState8("");
-  const [error, setError] = useState8(null);
+  const t = useStrings();
+  const defaultDictName = useDictName(cfg.defaultDict);
+  const [selected, setSelected] = useState11(0);
+  const [editing, setEditing] = useState11(false);
+  const [draft, setDraft] = useState11("");
+  const [error, setError] = useState11(null);
   const field = FIELDS[selected];
   const currentValue = getByPath2(cfg, field.path);
   const commit = async (raw) => {
@@ -1859,7 +2830,7 @@ function ConfigEditor() {
       setError(err.message);
     }
   };
-  useInput5((input, key) => {
+  useInput6((input, key) => {
     if (editing && field.kind === "string") {
       if (key.escape) {
         setEditing(false);
@@ -1894,7 +2865,7 @@ function ConfigEditor() {
       if (/^[0-9]$/.test(input)) setDraft((d) => d + input);
       return;
     }
-    if (key.escape || input === "b") {
+    if (key.escape) {
       nav.back();
       return;
     }
@@ -1929,73 +2900,99 @@ function ConfigEditor() {
       setError(null);
     }
   });
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
-    /* @__PURE__ */ jsx9(Text5, { bold: true, color: PALETTE.accent, children: "Config" }),
-    /* @__PURE__ */ jsx9(Box5, { marginTop: 1, flexDirection: "column", flexGrow: 1, children: FIELDS.map((f, i) => {
+  const labelW = Math.max(...FIELDS.map((f) => visibleWidth2(t.config.fields[f.labelKey]))) + 4;
+  return /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx13(Text7, { bold: true, color: PALETTE.accent, children: t.config.title }),
+    /* @__PURE__ */ jsx13(Box8, { marginTop: 1, flexDirection: "column", flexGrow: 1, children: FIELDS.map((f, i) => {
       const active = i === selected;
       const value = getByPath2(cfg, f.path);
-      const display = renderValue(f, value, active && editing ? draft : null);
-      return /* @__PURE__ */ jsxs5(Box5, { children: [
-        /* @__PURE__ */ jsx9(Text5, { color: active ? PALETTE.accent : PALETTE.muted, children: active ? "\u258C " : "  " }),
-        /* @__PURE__ */ jsx9(Text5, { bold: active, color: active ? PALETTE.text : PALETTE.muted, children: f.label.padEnd(28) }),
-        /* @__PURE__ */ jsx9(Text5, { color: active ? PALETTE.accent : PALETTE.muted, children: display })
+      const display = renderValue(
+        f,
+        value,
+        active && editing ? draft : null,
+        t,
+        f.path === "defaultDict" ? defaultDictName : ""
+      );
+      const label = t.config.fields[f.labelKey];
+      const pad = " ".repeat(Math.max(0, labelW - visibleWidth2(label)));
+      return /* @__PURE__ */ jsxs7(Box8, { children: [
+        /* @__PURE__ */ jsx13(Text7, { color: active ? PALETTE.accent : PALETTE.muted, children: active ? "\u258C " : "  " }),
+        /* @__PURE__ */ jsxs7(Text7, { bold: active, color: active ? PALETTE.text : PALETTE.muted, children: [
+          label,
+          pad
+        ] }),
+        /* @__PURE__ */ jsx13(Text7, { color: active ? PALETTE.accent : PALETTE.muted, children: display })
       ] }, f.path);
     }) }),
-    error && /* @__PURE__ */ jsx9(Box5, { marginTop: 1, children: /* @__PURE__ */ jsxs5(Text5, { color: PALETTE.error, children: [
+    error && /* @__PURE__ */ jsx13(Box8, { marginTop: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.error, children: [
       "! ",
       error
     ] }) }),
-    /* @__PURE__ */ jsx9(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text5, { color: PALETTE.muted, children: hintFor(field, editing) }) })
+    /* @__PURE__ */ jsx13(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx13(Text7, { color: PALETTE.muted, children: hintFor(field, editing, t) }) })
   ] });
 }
-function renderValue(field, value, draft) {
+function renderValue(field, value, draft, t, dictDisplayName) {
   if (draft !== null) return `${draft}_`;
-  if (field.kind === "bool") return value ? "\u2713 on" : "\u2717 off";
-  if (field.kind === "dictRef") return String(value ?? "(none)");
-  if (field.kind === "enum") return `< ${value} >`;
+  if (field.kind === "bool") return value ? `\u2713 ${t.common.on}` : `\u2717 ${t.common.off}`;
+  if (field.kind === "dictRef") {
+    if (!value) return "\u2014";
+    return truncateName(dictDisplayName || String(value), 24);
+  }
+  if (field.kind === "enum") {
+    if (field.path === "stealth") {
+      const v = String(value);
+      const label = t.config.enumValues.stealth[v] ?? String(value);
+      return `< ${label} >`;
+    }
+    return `< ${value} >`;
+  }
   return String(value ?? "");
 }
-function hintFor(field, editing) {
-  if (editing) return "type to edit  \xB7  Enter save  \xB7  Esc cancel";
-  if (field.kind === "bool") return "space toggle  \xB7  \u2191/\u2193 move  \xB7  Esc back";
-  if (field.kind === "enum") return "\u2190/\u2192 cycle  \xB7  \u2191/\u2193 move  \xB7  Esc back";
-  if (field.kind === "dictRef") return "Enter pick dict  \xB7  \u2191/\u2193 move  \xB7  Esc back";
-  return "Enter edit  \xB7  \u2191/\u2193 move  \xB7  Esc back";
+function hintFor(field, editing, t) {
+  if (editing) return t.config.hints.editing;
+  if (field.kind === "bool") return t.config.hints.bool;
+  if (field.kind === "enum") return t.config.hints.enum;
+  if (field.kind === "dictRef") return t.config.hints.dictRef;
+  return t.config.hints.stringOrInt;
 }
 
 // src/ui/screens/StatsViewer.tsx
-import { useEffect as useEffect7, useState as useState9 } from "react";
-import { Box as Box6, Text as Text6, useInput as useInput6 } from "ink";
-import { jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+import { useEffect as useEffect8, useState as useState12 } from "react";
+import { Box as Box9, Text as Text8, useInput as useInput7 } from "ink";
+import { jsx as jsx14, jsxs as jsxs8 } from "react/jsx-runtime";
 var DAY_WINDOWS = [7, 14, 30, 90];
 function StatsViewer() {
   const nav = useNav();
-  const [sessions, setSessions] = useState9(null);
-  const [book, setBook] = useState9(null);
-  const [windowIdx, setWindowIdx] = useState9(1);
-  useEffect7(() => {
+  const t = useStrings();
+  const [sessions, setSessions] = useState12(null);
+  const [book, setBook] = useState12(null);
+  const [windowIdx, setWindowIdx] = useState12(1);
+  useEffect8(() => {
     void (async () => {
       const [s, b] = await Promise.all([loadSessions(), loadMistakes()]);
       setSessions(s);
       setBook(b);
     })();
   }, []);
-  useInput6((input, key) => {
-    if (key.escape || input === "b" || input === "q") {
+  useInput7((_input, key) => {
+    if (key.escape) {
       nav.back();
       return;
     }
-    if (input === "n") setWindowIdx((i) => (i + 1) % DAY_WINDOWS.length);
-    if (input === "N") setWindowIdx((i) => (i - 1 + DAY_WINDOWS.length) % DAY_WINDOWS.length);
+    if (key.rightArrow) setWindowIdx((i) => (i + 1) % DAY_WINDOWS.length);
+    if (key.leftArrow) setWindowIdx((i) => (i - 1 + DAY_WINDOWS.length) % DAY_WINDOWS.length);
   });
   if (!sessions || !book) {
-    return /* @__PURE__ */ jsx10(Box6, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "loading stats\u2026" }) });
+    return /* @__PURE__ */ jsx14(Box9, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx14(Text8, { color: PALETTE.muted, children: t.stats.loading }) });
   }
   if (sessions.length === 0) {
-    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: [
-      /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "No practice history yet." }),
-      /* @__PURE__ */ jsx10(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "Run a practice session first." }) }),
-      /* @__PURE__ */ jsx10(Box6, { marginTop: 2, children: /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "[q] back" }) })
+    return /* @__PURE__ */ jsxs8(Box9, { flexDirection: "column", alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: [
+      /* @__PURE__ */ jsx14(Text8, { color: PALETTE.muted, children: t.stats.none }),
+      /* @__PURE__ */ jsx14(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx14(Text8, { color: PALETTE.muted, children: t.stats.nonePractice }) }),
+      /* @__PURE__ */ jsx14(Box9, { marginTop: 2, children: /* @__PURE__ */ jsxs8(Text8, { color: PALETTE.muted, children: [
+        "Esc ",
+        t.common.back
+      ] }) })
     ] });
   }
   const days = DAY_WINDOWS[windowIdx];
@@ -2012,102 +3009,162 @@ function StatsViewer() {
   const overallAcc = totalWords === 0 ? 1 : firstTryWords / totalWords;
   const recent = sessions.slice(-5).reverse();
   const top = topN(book, 8);
-  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
-    /* @__PURE__ */ jsx10(Text6, { bold: true, color: PALETTE.accent, children: "Stats" }),
-    /* @__PURE__ */ jsxs6(Box6, { marginTop: 1, flexDirection: "column", children: [
-      /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "lifetime" }),
-      /* @__PURE__ */ jsxs6(Box6, { marginTop: 1, children: [
-        /* @__PURE__ */ jsx10(Stat, { label: "sessions", value: String(sessions.length) }),
-        /* @__PURE__ */ jsx10(Stat, { label: "words", value: String(totalWords) }),
-        /* @__PURE__ */ jsx10(Stat, { label: "errors", value: String(totalErrors) }),
-        /* @__PURE__ */ jsx10(Stat, { label: "wpm", value: String(overallWpm), accent: true }),
-        /* @__PURE__ */ jsx10(Stat, { label: "accuracy", value: `${Math.round(overallAcc * 1e3) / 10}%`, accent: true }),
-        /* @__PURE__ */ jsx10(Stat, { label: "streak", value: `${streak}d`, accent: true })
+  const wpms = buckets.map((b) => b.wpm);
+  const accs = buckets.map((b) => b.accuracy * 100);
+  const ses = buckets.map((b) => b.sessions);
+  return /* @__PURE__ */ jsxs8(Box9, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx14(Text8, { bold: true, color: PALETTE.accent, children: t.stats.title }),
+    /* @__PURE__ */ jsxs8(Box9, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx14(Text8, { color: PALETTE.muted, children: t.stats.lifetime }),
+      /* @__PURE__ */ jsxs8(Box9, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx14(Stat, { label: t.stats.sessions, value: String(sessions.length) }),
+        /* @__PURE__ */ jsx14(Stat, { label: t.stats.words, value: String(totalWords) }),
+        /* @__PURE__ */ jsx14(Stat, { label: t.stats.errors, value: String(totalErrors) }),
+        /* @__PURE__ */ jsx14(Stat, { label: t.stats.wpm, value: String(overallWpm), accent: true }),
+        /* @__PURE__ */ jsx14(Stat, { label: t.stats.accuracy, value: `${Math.round(overallAcc * 1e3) / 10}%`, accent: true }),
+        /* @__PURE__ */ jsx14(Stat, { label: t.stats.streak, value: `${streak}d`, accent: true })
       ] })
     ] }),
-    /* @__PURE__ */ jsxs6(Box6, { marginTop: 2, flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.muted, children: [
-        "last ",
-        days,
-        " days  (n / N to cycle window)"
-      ] }),
-      /* @__PURE__ */ jsxs6(Box6, { marginTop: 1, flexDirection: "column", children: [
-        /* @__PURE__ */ jsxs6(Box6, { children: [
-          /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "wpm     ".padEnd(10) }),
-          /* @__PURE__ */ jsx10(Text6, { color: PALETTE.accent, children: sparkline(buckets.map((b) => b.wpm)) }),
-          /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.muted, children: [
-            "  max ",
-            Math.round(Math.max(...buckets.map((b) => b.wpm)))
-          ] })
-        ] }),
-        /* @__PURE__ */ jsxs6(Box6, { children: [
-          /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "accuracy".padEnd(10) }),
-          /* @__PURE__ */ jsx10(Text6, { color: PALETTE.accent, children: sparkline(buckets.map((b) => b.accuracy * 100)) })
-        ] }),
-        /* @__PURE__ */ jsxs6(Box6, { children: [
-          /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "sessions".padEnd(10) }),
-          /* @__PURE__ */ jsx10(Text6, { color: PALETTE.accent, children: sparkline(buckets.map((b) => b.sessions)) })
-        ] })
+    /* @__PURE__ */ jsxs8(Box9, { marginTop: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx14(Text8, { color: PALETTE.muted, children: t.stats.last(days) }),
+      /* @__PURE__ */ jsxs8(Box9, { marginTop: 1, flexDirection: "column", borderStyle: "round", borderColor: PALETTE.muted, paddingX: 1, children: [
+        /* @__PURE__ */ jsx14(
+          SparkRow,
+          {
+            label: t.stats.wpm,
+            values: wpms,
+            maxLabel: t.stats.maxLabel
+          }
+        ),
+        /* @__PURE__ */ jsx14(
+          SparkRow,
+          {
+            label: t.stats.accuracy,
+            values: accs,
+            maxLabel: t.stats.maxLabel,
+            suffix: "%"
+          }
+        ),
+        /* @__PURE__ */ jsx14(
+          SparkRow,
+          {
+            label: t.stats.sessions,
+            values: ses,
+            maxLabel: t.stats.maxLabel
+          }
+        )
       ] })
     ] }),
-    /* @__PURE__ */ jsxs6(Box6, { marginTop: 2, flexDirection: "column", children: [
-      /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "recent sessions" }),
-      recent.map((s, i) => /* @__PURE__ */ jsxs6(Box6, { children: [
-        /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.muted, children: [
-          "  ",
-          s.ts.replace("T", " ").slice(0, 16),
-          "  "
-        ] }),
-        /* @__PURE__ */ jsx10(Text6, { color: PALETTE.text, children: s.dictId.padEnd(14) }),
-        /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.muted, children: [
-          " ",
-          "ch",
-          String(s.chapter + 1).padStart(3),
-          "  ",
-          s.mode.padEnd(9),
-          " ",
-          String(s.wordCount).padStart(3),
-          "w  ",
-          s.errors,
-          "err  ",
-          computeWPM(s),
-          "wpm  ",
-          Math.round(accuracy(s) * 1e3) / 10,
-          "%"
-        ] })
-      ] }, i))
+    /* @__PURE__ */ jsxs8(Box9, { marginTop: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx14(Text8, { color: PALETTE.muted, children: t.stats.recent }),
+      recent.map((s, i) => /* @__PURE__ */ jsx14(RecentRow, { session: s, units: t.stats.recentUnits }, i))
     ] }),
-    top.length > 0 && /* @__PURE__ */ jsxs6(Box6, { marginTop: 2, flexDirection: "column", children: [
-      /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "top mistakes" }),
-      top.map(([word, entry]) => /* @__PURE__ */ jsxs6(Box6, { children: [
-        /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.error, children: [
-          "  ",
-          String(entry.count).padStart(3),
-          "  "
-        ] }),
-        /* @__PURE__ */ jsx10(Text6, { color: PALETTE.text, children: word.padEnd(20) }),
-        /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: entry.dictIds.join(", ") })
-      ] }, word))
+    top.length > 0 && /* @__PURE__ */ jsxs8(Box9, { marginTop: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx14(Text8, { color: PALETTE.muted, children: t.stats.topMistakes }),
+      top.map(([word, entry]) => /* @__PURE__ */ jsx14(
+        MistakeRow,
+        {
+          word,
+          count: entry.count,
+          dictIds: entry.dictIds,
+          multiSuffix: t.stats.multiDictSuffix
+        },
+        word
+      ))
+    ] }),
+    /* @__PURE__ */ jsx14(Box9, { flexGrow: 1 }),
+    /* @__PURE__ */ jsx14(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx14(Text8, { color: PALETTE.muted, children: t.stats.footer }) })
+  ] });
+}
+function SparkRow({
+  label,
+  values,
+  maxLabel,
+  suffix = ""
+}) {
+  const max = values.length === 0 ? 0 : Math.max(...values);
+  const maxDisplay = `${Math.round(max)}${suffix}`;
+  return /* @__PURE__ */ jsxs8(Box9, { children: [
+    /* @__PURE__ */ jsx14(Box9, { width: 10, children: /* @__PURE__ */ jsx14(Text8, { color: PALETTE.muted, children: label }) }),
+    /* @__PURE__ */ jsx14(Box9, { flexGrow: 1, children: /* @__PURE__ */ jsx14(Text8, { color: PALETTE.accent, children: sparkline(values) }) }),
+    /* @__PURE__ */ jsx14(Box9, { marginLeft: 2, children: /* @__PURE__ */ jsxs8(Text8, { color: PALETTE.muted, children: [
+      maxLabel,
+      " ",
+      maxDisplay
+    ] }) })
+  ] });
+}
+function RecentRow({
+  session,
+  units
+}) {
+  const name = useDictName(session.dictId);
+  const display = truncateName(name, 14);
+  return /* @__PURE__ */ jsxs8(Box9, { children: [
+    /* @__PURE__ */ jsxs8(Text8, { color: PALETTE.muted, children: [
+      "  ",
+      session.ts.replace("T", " ").slice(0, 16),
+      "  "
     ] }),
-    /* @__PURE__ */ jsx10(Box6, { flexGrow: 1 }),
-    /* @__PURE__ */ jsx10(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text6, { color: PALETTE.muted, children: "n / N cycle window  \xB7  q back" }) })
+    /* @__PURE__ */ jsx14(Text8, { color: PALETTE.text, children: display.padEnd(14) }),
+    /* @__PURE__ */ jsxs8(Text8, { color: PALETTE.muted, children: [
+      " ",
+      "ch",
+      String(session.chapter + 1).padStart(3),
+      "  ",
+      session.mode.padEnd(9),
+      " ",
+      String(session.wordCount).padStart(3),
+      units.words,
+      "  ",
+      session.errors,
+      units.errors,
+      "  ",
+      computeWPM(session),
+      units.wpm,
+      "  ",
+      Math.round(accuracy(session) * 1e3) / 10,
+      "%"
+    ] })
+  ] });
+}
+function MistakeRow({
+  word,
+  count,
+  dictIds,
+  multiSuffix
+}) {
+  const firstId = dictIds[0] ?? "";
+  const firstName = useDictName(firstId);
+  const suffix = dictIds.length > 1 ? multiSuffix(dictIds.length - 1) : "";
+  return /* @__PURE__ */ jsxs8(Box9, { children: [
+    /* @__PURE__ */ jsxs8(Text8, { color: PALETTE.error, children: [
+      "  ",
+      String(count).padStart(3),
+      "  "
+    ] }),
+    /* @__PURE__ */ jsx14(Text8, { color: PALETTE.text, children: word.padEnd(20) }),
+    /* @__PURE__ */ jsxs8(Text8, { color: PALETTE.muted, children: [
+      truncateName(firstName, 20),
+      suffix
+    ] })
   ] });
 }
 function Stat({ label, value, accent = false }) {
-  return /* @__PURE__ */ jsxs6(Box6, { marginRight: 3, children: [
-    /* @__PURE__ */ jsxs6(Text6, { color: PALETTE.muted, children: [
+  return /* @__PURE__ */ jsxs8(Box9, { marginRight: 3, children: [
+    /* @__PURE__ */ jsxs8(Text8, { color: PALETTE.muted, children: [
       label,
       " "
     ] }),
-    /* @__PURE__ */ jsx10(Text6, { bold: true, color: accent ? PALETTE.accent : PALETTE.text, children: value })
+    /* @__PURE__ */ jsx14(Text8, { bold: true, color: accent ? PALETTE.accent : PALETTE.text, children: value })
   ] });
 }
 
 // src/ui/screens/WordLookup.tsx
-import { useEffect as useEffect8, useState as useState10 } from "react";
-import { Box as Box7, Text as Text7, useInput as useInput7 } from "ink";
+import { useEffect as useEffect9, useState as useState13 } from "react";
+import { Box as Box10, Text as Text9, useInput as useInput8 } from "ink";
 import { readdir } from "fs/promises";
-import { Fragment as Fragment3, jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx15, jsxs as jsxs9 } from "react/jsx-runtime";
 async function listLocalDictIds() {
   try {
     const files = await readdir(paths.dictsDir);
@@ -2118,12 +3175,13 @@ async function listLocalDictIds() {
 }
 function WordLookup() {
   const nav = useNav();
-  const [query, setQuery] = useState10("");
-  const [allWords, setAllWords] = useState10([]);
-  const [book, setBook] = useState10({});
-  const [loading, setLoading] = useState10(true);
-  const [selected, setSelected] = useState10(0);
-  useEffect8(() => {
+  const t = useStrings();
+  const [query, setQuery] = useState13("");
+  const [allWords, setAllWords] = useState13([]);
+  const [book, setBook] = useState13({});
+  const [loading, setLoading] = useState13(true);
+  const [selected, setSelected] = useState13(0);
+  useEffect9(() => {
     void (async () => {
       const ids = await listLocalDictIds();
       const collected = [];
@@ -2139,7 +3197,7 @@ function WordLookup() {
   }, []);
   const q = query.toLowerCase().trim();
   const filtered = q ? allWords.filter((h) => h.word.name.toLowerCase().includes(q)).slice(0, 50) : [];
-  useInput7((input, key) => {
+  useInput8((input, key) => {
     if (key.escape) {
       nav.back();
       return;
@@ -2163,115 +3221,223 @@ function WordLookup() {
     }
   });
   if (loading) {
-    return /* @__PURE__ */ jsx11(Box7, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: "indexing local dictionaries\u2026" }) });
+    return /* @__PURE__ */ jsx15(Box10, { alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: /* @__PURE__ */ jsx15(Text9, { color: PALETTE.muted, children: t.word.indexing }) });
   }
   if (allWords.length === 0) {
-    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: [
-      /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: "No local dictionaries." }),
-      /* @__PURE__ */ jsx11(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: "Pull one in Dictionaries first." }) }),
-      /* @__PURE__ */ jsx11(Box7, { marginTop: 2, children: /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: "[Esc] back" }) })
+    return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: [
+      /* @__PURE__ */ jsx15(Text9, { color: PALETTE.muted, children: t.word.none }),
+      /* @__PURE__ */ jsx15(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx15(Text9, { color: PALETTE.muted, children: t.word.pullFirst }) }),
+      /* @__PURE__ */ jsx15(Box10, { marginTop: 2, children: /* @__PURE__ */ jsxs9(Text9, { color: PALETTE.muted, children: [
+        "[Esc] ",
+        t.common.back
+      ] }) })
     ] });
   }
   const current = filtered[selected];
-  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
-    /* @__PURE__ */ jsxs7(Box7, { children: [
-      /* @__PURE__ */ jsx11(Text7, { bold: true, color: PALETTE.accent, children: "Word lookup" }),
-      /* @__PURE__ */ jsx11(Box7, { flexGrow: 1 }),
-      /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.muted, children: [
-        allWords.length,
-        " words across local dicts"
-      ] })
+  return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsxs9(Box10, { children: [
+      /* @__PURE__ */ jsx15(Text9, { bold: true, color: PALETTE.accent, children: t.word.title }),
+      /* @__PURE__ */ jsx15(Box10, { flexGrow: 1 }),
+      /* @__PURE__ */ jsx15(Text9, { color: PALETTE.muted, children: t.word.countAcross(allWords.length) })
     ] }),
-    /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, children: [
-      /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: "> " }),
-      /* @__PURE__ */ jsx11(Text7, { color: PALETTE.text, children: query }),
-      /* @__PURE__ */ jsx11(Text7, { color: PALETTE.accent, children: "_" })
+    /* @__PURE__ */ jsxs9(Box10, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx15(Text9, { color: PALETTE.muted, children: "> " }),
+      /* @__PURE__ */ jsx15(Text9, { color: PALETTE.text, children: query }),
+      /* @__PURE__ */ jsx15(Text9, { color: PALETTE.accent, children: "_" })
     ] }),
-    /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, flexGrow: 1, children: [
-      /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", width: "40%", children: [
-        filtered.map((h, i) => {
-          const active = i === selected;
-          return /* @__PURE__ */ jsxs7(Box7, { children: [
-            /* @__PURE__ */ jsx11(Text7, { color: active ? PALETTE.accent : PALETTE.muted, children: active ? "\u258C " : "  " }),
-            /* @__PURE__ */ jsx11(Text7, { bold: active, color: active ? PALETTE.text : PALETTE.muted, children: h.word.name.padEnd(20) }),
-            /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: h.dictId })
-          ] }, `${h.dictId}-${h.word.name}-${i}`);
-        }),
-        filtered.length === 0 && q && /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.muted, children: [
-          'no matches for "',
-          query,
-          '"'
-        ] })
+    /* @__PURE__ */ jsxs9(Box10, { marginTop: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", width: "40%", children: [
+        filtered.map((h, i) => /* @__PURE__ */ jsx15(HitRow, { hit: h, active: i === selected }, `${h.dictId}-${h.word.name}-${i}`)),
+        filtered.length === 0 && q && /* @__PURE__ */ jsx15(Text9, { color: PALETTE.muted, children: t.word.noMatches(query) })
       ] }),
-      /* @__PURE__ */ jsx11(Box7, { flexDirection: "column", width: "60%", paddingLeft: 2, children: current && /* @__PURE__ */ jsxs7(Fragment3, { children: [
-        /* @__PURE__ */ jsx11(Text7, { bold: true, color: PALETTE.text, children: current.word.name }),
-        /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, children: [
-          current.word.usphone && /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.muted, children: [
-            "US /",
-            current.word.usphone,
-            "/   "
-          ] }),
-          current.word.ukphone && /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.muted, children: [
-            "UK /",
-            current.word.ukphone,
-            "/"
-          ] })
-        ] }),
-        /* @__PURE__ */ jsx11(Box7, { marginTop: 1, flexDirection: "column", children: (current.word.trans ?? []).map((t, i) => /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.primary, children: [
-          "\xB7 ",
-          t
-        ] }, i)) }),
-        /* @__PURE__ */ jsx11(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.muted, children: [
-          "in: ",
-          current.dictId
-        ] }) }),
-        book[current.word.name] && /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, children: [
-          /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.error, children: [
-            "mistakes: ",
-            book[current.word.name].count
-          ] }),
-          /* @__PURE__ */ jsxs7(Text7, { color: PALETTE.muted, children: [
-            " ",
-            "(last ",
-            book[current.word.name].lastSeen.slice(0, 10),
-            ")"
-          ] })
-        ] })
-      ] }) })
+      /* @__PURE__ */ jsx15(Box10, { flexDirection: "column", width: "60%", paddingLeft: 2, children: current && /* @__PURE__ */ jsx15(Detail, { hit: current, book }) })
+    ] }),
+    /* @__PURE__ */ jsx15(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx15(Text9, { color: PALETTE.muted, children: t.word.footer }) })
+  ] });
+}
+function HitRow({ hit, active }) {
+  const name = useDictName(hit.dictId);
+  return /* @__PURE__ */ jsxs9(Box10, { children: [
+    /* @__PURE__ */ jsx15(Text9, { color: active ? PALETTE.accent : PALETTE.muted, children: active ? "\u258C " : "  " }),
+    /* @__PURE__ */ jsx15(Text9, { bold: active, color: active ? PALETTE.text : PALETTE.muted, children: hit.word.name.padEnd(20) }),
+    /* @__PURE__ */ jsx15(Text9, { color: PALETTE.muted, children: truncateName(name, 18) })
+  ] });
+}
+function Detail({ hit, book }) {
+  const t = useStrings();
+  const name = useDictName(hit.dictId);
+  return /* @__PURE__ */ jsxs9(Fragment2, { children: [
+    /* @__PURE__ */ jsx15(Text9, { bold: true, color: PALETTE.text, children: hit.word.name }),
+    /* @__PURE__ */ jsxs9(Box10, { marginTop: 1, children: [
+      hit.word.usphone && /* @__PURE__ */ jsxs9(Text9, { color: PALETTE.muted, children: [
+        "US /",
+        hit.word.usphone,
+        "/   "
+      ] }),
+      hit.word.ukphone && /* @__PURE__ */ jsxs9(Text9, { color: PALETTE.muted, children: [
+        "UK /",
+        hit.word.ukphone,
+        "/"
+      ] })
     ] }),
-    /* @__PURE__ */ jsx11(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text7, { color: PALETTE.muted, children: "type to filter  \xB7  \u2191/\u2193 select  \xB7  Esc back" }) })
+    /* @__PURE__ */ jsx15(Box10, { marginTop: 1, flexDirection: "column", children: (hit.word.trans ?? []).map((tr, i) => /* @__PURE__ */ jsxs9(Text9, { color: PALETTE.primary, children: [
+      "\xB7 ",
+      tr
+    ] }, i)) }),
+    /* @__PURE__ */ jsx15(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx15(Text9, { color: PALETTE.muted, children: t.word.inDict(truncateName(name, 22)) }) }),
+    book[hit.word.name] && /* @__PURE__ */ jsx15(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx15(Text9, { color: PALETTE.error, children: t.word.mistakes(book[hit.word.name].count, book[hit.word.name].lastSeen.slice(0, 10)) }) })
+  ] });
+}
+
+// src/ui/screens/HelpScreen.tsx
+import { Box as Box11, Text as Text10, useInput as useInput9 } from "ink";
+import { jsx as jsx16, jsxs as jsxs10 } from "react/jsx-runtime";
+function HelpScreen() {
+  const nav = useNav();
+  const t = useStrings();
+  useInput9((_input, key) => {
+    if (key.escape) nav.back();
+  });
+  const k = t.help.keys;
+  const sections = [
+    { title: t.help.sections.global, keys: [k.helpScreen, k.quit] },
+    { title: t.help.sections.main, keys: [k.navigate, k.select, k.letterJump, k.helpScreen] },
+    {
+      title: t.help.sections.practice,
+      keys: [k.pause, k.skip, k.replay, k.resume, k.nextChapter, k.reviewMistakes, k.stealthToggle, k.backMenu]
+    },
+    {
+      title: t.help.sections.dict,
+      keys: [k.navigate, k.filter, k.itemActions, k.moreActions, k.backScreen]
+    },
+    { title: t.help.sections.config, keys: [k.navigate, k.select, k.backMenu] },
+    { title: t.help.sections.stats, keys: [k.cycleWindow, k.backMenu] },
+    { title: t.help.sections.word, keys: [k.filter, k.navigate, k.backMenu] }
+  ];
+  return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsxs10(Box11, { children: [
+      /* @__PURE__ */ jsx16(Text10, { bold: true, color: PALETTE.accent, children: t.help.title }),
+      /* @__PURE__ */ jsx16(Text10, { color: PALETTE.muted, children: "  \xB7  " }),
+      /* @__PURE__ */ jsx16(Text10, { color: PALETTE.muted, children: t.help.subtitle })
+    ] }),
+    /* @__PURE__ */ jsx16(Box11, { marginTop: 1, flexDirection: "column", flexGrow: 1, children: sections.map((sec) => /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx16(Text10, { bold: true, color: PALETTE.text, children: sec.title }),
+      sec.keys.map((line, i) => /* @__PURE__ */ jsx16(Box11, { children: /* @__PURE__ */ jsxs10(Text10, { color: PALETTE.muted, children: [
+        "  \xB7 ",
+        line
+      ] }) }, i))
+    ] }, sec.title)) }),
+    /* @__PURE__ */ jsx16(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text10, { color: PALETTE.muted, children: t.help.footer }) })
   ] });
 }
 
 // src/ui/App.tsx
-import { jsx as jsx12 } from "react/jsx-runtime";
+import { jsx as jsx17 } from "react/jsx-runtime";
 function App({ initial, initialCfg }) {
-  return /* @__PURE__ */ jsx12(AppStateProvider, { initialCfg, children: /* @__PURE__ */ jsx12(AudioStatusProvider, { disabled: !initialCfg.sounds.master, children: /* @__PURE__ */ jsx12(NavProvider, { initial, children: /* @__PURE__ */ jsx12(Fullscreen, { children: /* @__PURE__ */ jsx12(Router, {}) }) }) }) });
+  return /* @__PURE__ */ jsx17(AppStateProvider, { initialCfg, children: /* @__PURE__ */ jsx17(LangBridge, { children: /* @__PURE__ */ jsx17(RegistryProvider, { children: /* @__PURE__ */ jsx17(AudioStatusProvider, { disabled: !initialCfg.sounds.master, children: /* @__PURE__ */ jsx17(NavProvider, { initial, children: /* @__PURE__ */ jsx17(Fullscreen, { children: /* @__PURE__ */ jsx17(Router, {}) }) }) }) }) }) });
+}
+function LangBridge({ children }) {
+  const { cfg } = useAppState();
+  return /* @__PURE__ */ jsx17(StringsProvider, { pref: cfg.language, children });
+}
+function screenKey(frame) {
+  if (frame.name === "practice") {
+    const p = frame.params;
+    return `practice:${p.dictId}:${p.chapterIndex}:${p.mode}:${p.stealth ? "s" : "n"}`;
+  }
+  return frame.name;
 }
 function Router() {
   const nav = useNav();
   const { cfg } = useAppState();
   const { exit } = useApp4();
-  useInput8((input, key) => {
-    if (key.ctrl && input === "c") exit();
+  const lastKeyRef = useRef4(null);
+  useInput10((input, key2) => {
+    if (key2.ctrl && input === "c") exit();
   });
   const frame = nav.current;
+  const key = screenKey(frame);
+  if (lastKeyRef.current !== key) {
+    if (process.stdout.isTTY) process.stdout.write("\x1B[2J\x1B[H");
+    lastKeyRef.current = key;
+  }
   switch (frame.name) {
     case "main":
-      return /* @__PURE__ */ jsx12(MainMenu, { cfg });
+      return /* @__PURE__ */ jsx17(MainMenu, { cfg });
     case "practice":
-      return /* @__PURE__ */ jsx12(PracticeScreen, { params: frame.params });
+      return /* @__PURE__ */ jsx17(PracticeScreen, { params: frame.params });
     case "dict":
-      return /* @__PURE__ */ jsx12(DictBrowser, { params: frame.params });
+      return /* @__PURE__ */ jsx17(DictBrowser, { params: frame.params });
     case "config":
-      return /* @__PURE__ */ jsx12(ConfigEditor, {});
+      return /* @__PURE__ */ jsx17(ConfigEditor, {});
     case "stats":
-      return /* @__PURE__ */ jsx12(StatsViewer, {});
+      return /* @__PURE__ */ jsx17(StatsViewer, {});
     case "word":
-      return /* @__PURE__ */ jsx12(WordLookup, {});
+      return /* @__PURE__ */ jsx17(WordLookup, {});
+    case "help":
+      return /* @__PURE__ */ jsx17(HelpScreen, {});
   }
 }
 
+// src/util/report.ts
+import chalk3 from "chalk";
+var LEAVE_ALTSCREEN = "\x1B[?25h\x1B[?1049l";
+function ensureMainScreen() {
+  if (process.stdout.isTTY) process.stdout.write(LEAVE_ALTSCREEN);
+}
+function fmtDuration(ms, lang) {
+  const total = Math.floor(ms / 1e3);
+  const m = Math.floor(total / 60);
+  const s = total % 60;
+  if (lang === "zh") {
+    if (m === 0) return `${s} \u79D2`;
+    return `${m} \u5206 ${s} \u79D2`;
+  }
+  if (m === 0) return `${s}s`;
+  return `${m}m ${s}s`;
+}
+function printSessionReport(r, t, lang) {
+  if (r.startedAt === null && r.chaptersCompleted === 0) return;
+  if (r.chaptersCompleted === 0) {
+    console.log();
+    console.log(chalk3.bold.cyan(t.report.title));
+    const labelW2 = Math.max(visibleWidth2(t.report.duration), visibleWidth2(t.report.notPracticed)) + 2;
+    const pad2 = (label) => label + " ".repeat(Math.max(0, labelW2 - visibleWidth2(label)));
+    console.log(`  ${chalk3.dim(pad2(t.report.duration))} ${fmtDuration(r.totalDurationMs, lang)}`);
+    console.log(`  ${chalk3.dim(t.report.notPracticed)}`);
+    console.log();
+    console.log(chalk3.dim(`  ${t.report.farewell}`));
+    console.log();
+    return;
+  }
+  const accPct = Math.round(r.accuracy * 1e3) / 10;
+  const labels = [
+    t.report.duration,
+    t.report.practiced,
+    t.report.chapters,
+    t.report.words,
+    t.report.accuracy,
+    t.report.wpm
+  ];
+  if (r.newMistakeWords > 0) labels.push(t.report.newMistakes);
+  const labelW = Math.max(...labels.map(visibleWidth2)) + 2;
+  const pad = (label) => label + " ".repeat(Math.max(0, labelW - visibleWidth2(label)));
+  console.log();
+  console.log(chalk3.bold.cyan(t.report.title));
+  console.log(`  ${chalk3.dim(pad(t.report.duration))} ${fmtDuration(r.totalDurationMs, lang)}`);
+  console.log(`  ${chalk3.dim(pad(t.report.practiced))} ${fmtDuration(r.practiceMs, lang)}`);
+  console.log(`  ${chalk3.dim(pad(t.report.chapters))} ${r.chaptersCompleted}`);
+  console.log(`  ${chalk3.dim(pad(t.report.words))} ${r.wordCount}`);
+  console.log(`  ${chalk3.dim(pad(t.report.accuracy))} ${accPct}%`);
+  console.log(`  ${chalk3.dim(pad(t.report.wpm))} ${r.wpm}`);
+  if (r.newMistakeWords > 0) {
+    console.log(`  ${chalk3.dim(pad(t.report.newMistakes))} ${r.newMistakeWords}`);
+  }
+  console.log();
+  console.log(chalk3.dim(`  ${t.report.farewell}`));
+  console.log();
+}
+
 // src/commands/practice.ts
 var MODES = ["order", "dictation", "review", "random", "loop"];
 function isMode(v) {
@@ -2279,42 +3445,49 @@ function isMode(v) {
 }
 async function runPractice(dictIdArg, options) {
   if (!process.stdout.isTTY) {
-    console.error(chalk3.red("Practice requires an interactive TTY."));
+    console.error(chalk4.red("Practice requires an interactive TTY."));
     process.exitCode = 1;
     return;
   }
   const cfg = await loadConfig();
   const dictId = dictIdArg ?? cfg.defaultDict;
   if (!dictId) {
-    console.error(chalk3.red("No dictionary specified. Pass an id or set config.defaultDict."));
+    console.error(chalk4.red("No dictionary specified. Pass an id or set config.defaultDict."));
     process.exitCode = 1;
     return;
   }
   const mode = options.mode ?? cfg.defaultMode;
   if (!isMode(mode)) {
-    console.error(chalk3.red(`Invalid mode "${mode}". Valid: ${MODES.join(", ")}`));
+    console.error(chalk4.red(`Invalid mode "${mode}". Valid: ${MODES.join(", ")}`));
     process.exitCode = 1;
     return;
   }
   const chapterIndex = Math.max(0, Number(options.chapter ?? 1) - 1);
+  const stealth = options.stealth === true || cfg.stealth === "default";
+  start();
   const { waitUntilExit } = render(
     createElement(App, {
-      initial: { name: "practice", params: { dictId, chapterIndex, mode } },
+      initial: { name: "practice", params: { dictId, chapterIndex, mode, stealth } },
       initialCfg: cfg
     }),
     { patchConsole: false, exitOnCtrlC: false }
   );
   await waitUntilExit();
+  ensureMainScreen();
+  const { lang, t } = pickStrings(cfg.language);
+  printSessionReport(report(), t, lang);
 }
 function buildPracticeCommand() {
-  return new Command3("practice").argument("[dictId]", "dictionary id; falls back to config.defaultDict").description("Start a typing practice session").option("-c, --chapter <n>", "chapter number (1-based)", "1").option("-m, --mode <mode>", "order | dictation | review | random | loop").action(async (dictIdArg, options) => {
-    await runPractice(dictIdArg, options);
-  });
+  return new Command3("practice").argument("[dictId]", "dictionary id; falls back to config.defaultDict").description("Start a typing practice session").option("-c, --chapter <n>", "chapter number (1-based)", "1").option("-m, --mode <mode>", "order | dictation | review | random | loop").option("--stealth", "enter stealth mode (minimal UI, no sound)").action(
+    async (dictIdArg, options) => {
+      await runPractice(dictIdArg, options);
+    }
+  );
 }
 
 // src/commands/stats.ts
 import { Command as Command4 } from "commander";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 function buildStatsCommand() {
   return new Command4("stats").description("Show practice history and trends").option("-d, --days <n>", "window size for trend (default 14)", "14").option("--top <n>", "how many top mistakes to show (default 10)", "10").action(async (opts) => {
     const days = Math.max(1, Number(opts.days) || 14);
@@ -2322,7 +3495,7 @@ function buildStatsCommand() {
     const sessions = await loadSessions();
     const book = await loadMistakes();
     if (sessions.length === 0) {
-      console.log(chalk4.yellow("No practice history yet. Run `qwerty practice <dict>` to get started."));
+      console.log(chalk5.yellow("No practice history yet. Run `qwerty practice <dict>` to get started."));
       return;
     }
     const buckets = dailyBuckets(sessions, days);
@@ -2336,33 +3509,33 @@ function buildStatsCommand() {
     );
     const overallWpm = totalMs > 0 ? Math.round(totalWords / (totalMs / 6e4) * 10) / 10 : 0;
     const overallAcc = totalWords === 0 ? 1 : firstTryWords / totalWords;
-    console.log(chalk4.bold("\nLifetime"));
-    console.log(`  ${chalk4.dim("sessions")} ${sessions.length}   ${chalk4.dim("words")} ${totalWords}   ${chalk4.dim("errors")} ${totalErrors}`);
-    console.log(`  ${chalk4.dim("avg wpm")} ${overallWpm}   ${chalk4.dim("avg accuracy")} ${Math.round(overallAcc * 1e3) / 10}%   ${chalk4.dim("streak")} ${chalk4.bold(streak)}d`);
-    console.log(chalk4.bold(`
+    console.log(chalk5.bold("\nLifetime"));
+    console.log(`  ${chalk5.dim("sessions")} ${sessions.length}   ${chalk5.dim("words")} ${totalWords}   ${chalk5.dim("errors")} ${totalErrors}`);
+    console.log(`  ${chalk5.dim("avg wpm")} ${overallWpm}   ${chalk5.dim("avg accuracy")} ${Math.round(overallAcc * 1e3) / 10}%   ${chalk5.dim("streak")} ${chalk5.bold(streak)}d`);
+    console.log(chalk5.bold(`
 Last ${days} days`));
-    console.log(`  ${chalk4.dim("wpm     ")} ${sparkline(buckets.map((b) => b.wpm))}   ${chalk4.dim("max")} ${Math.round(Math.max(...buckets.map((b) => b.wpm)))}`);
-    console.log(`  ${chalk4.dim("accuracy")} ${sparkline(buckets.map((b) => b.accuracy * 100))}   ${chalk4.dim("range")} ${Math.round(Math.min(...buckets.map((b) => b.accuracy * 100)))}-${Math.round(Math.max(...buckets.map((b) => b.accuracy * 100)))}%`);
-    console.log(`  ${chalk4.dim("sessions")} ${sparkline(buckets.map((b) => b.sessions))}`);
+    console.log(`  ${chalk5.dim("wpm     ")} ${sparkline(buckets.map((b) => b.wpm))}   ${chalk5.dim("max")} ${Math.round(Math.max(...buckets.map((b) => b.wpm)))}`);
+    console.log(`  ${chalk5.dim("accuracy")} ${sparkline(buckets.map((b) => b.accuracy * 100))}   ${chalk5.dim("range")} ${Math.round(Math.min(...buckets.map((b) => b.accuracy * 100)))}-${Math.round(Math.max(...buckets.map((b) => b.accuracy * 100)))}%`);
+    console.log(`  ${chalk5.dim("sessions")} ${sparkline(buckets.map((b) => b.sessions))}`);
     const recent = sessions.slice(-5).reverse();
-    console.log(chalk4.bold("\nLast 5 sessions"));
+    console.log(chalk5.bold("\nLast 5 sessions"));
     for (const s of recent) {
       const wpm = computeWPM(s);
       const acc = Math.round(accuracy(s) * 1e3) / 10;
       console.log(
-        `  ${chalk4.dim(s.ts.replace("T", " ").slice(0, 16))}  ${chalk4.cyan(s.dictId.padEnd(14))} ch${String(s.chapter + 1).padStart(3)}  ${s.mode.padEnd(9)} ${String(s.wordCount).padStart(3)}w  ${s.errors}err  ${wpm}wpm  ${acc}%`
+        `  ${chalk5.dim(s.ts.replace("T", " ").slice(0, 16))}  ${chalk5.cyan(s.dictId.padEnd(14))} ch${String(s.chapter + 1).padStart(3)}  ${s.mode.padEnd(9)} ${String(s.wordCount).padStart(3)}w  ${s.errors}err  ${wpm}wpm  ${acc}%`
       );
     }
     const top = topN(book, topCount);
     if (top.length > 0) {
-      console.log(chalk4.bold(`
+      console.log(chalk5.bold(`
 Top ${top.length} mistakes`));
       for (const [word, entry] of top) {
-        console.log(`  ${chalk4.red(String(entry.count).padStart(3))}  ${chalk4.bold(word.padEnd(20))} ${chalk4.dim(entry.dictIds.join(", "))}`);
+        console.log(`  ${chalk5.red(String(entry.count).padStart(3))}  ${chalk5.bold(word.padEnd(20))} ${chalk5.dim(entry.dictIds.join(", "))}`);
       }
     } else {
-      console.log(chalk4.bold("\nTop mistakes"));
-      console.log(chalk4.dim("  none \u2014 keep going"));
+      console.log(chalk5.bold("\nTop mistakes"));
+      console.log(chalk5.dim("  none \u2014 keep going"));
     }
     console.log();
   });
@@ -2370,7 +3543,7 @@ Top ${top.length} mistakes`));
 
 // src/commands/word.ts
 import { Command as Command5 } from "commander";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import { readdir as readdir2 } from "fs/promises";
 async function listLocalDictIds2() {
   try {
@@ -2385,7 +3558,7 @@ function buildWordCommand() {
     const q = keyword.toLowerCase();
     const ids = await listLocalDictIds2();
     if (ids.length === 0) {
-      console.log(chalk5.yellow("No local dictionaries. Run `qwerty dict pull <id>` first."));
+      console.log(chalk6.yellow("No local dictionaries. Run `qwerty dict pull <id>` first."));
       return;
     }
     const hits = [];
@@ -2399,7 +3572,7 @@ function buildWordCommand() {
       }
     }
     if (hits.length === 0) {
-      console.log(chalk5.yellow(`No matches for "${keyword}" in ${ids.length} local dictionaries`));
+      console.log(chalk6.yellow(`No matches for "${keyword}" in ${ids.length} local dictionaries`));
       return;
     }
     const byName = /* @__PURE__ */ new Map();
@@ -2412,27 +3585,37 @@ function buildWordCommand() {
     for (const [name, group] of byName) {
       const first = group[0].word;
       console.log();
-      console.log(chalk5.bold.white(name));
+      console.log(chalk6.bold.white(name));
       const us = first.usphone ? `US /${first.usphone}/` : "";
       const uk = first.ukphone ? `UK /${first.ukphone}/` : "";
-      if (us || uk) console.log(chalk5.dim(`  ${[us, uk].filter(Boolean).join("   ")}`));
-      for (const t of first.trans ?? []) console.log(chalk5.cyan(`  \xB7 ${t}`));
+      if (us || uk) console.log(chalk6.dim(`  ${[us, uk].filter(Boolean).join("   ")}`));
+      for (const t of first.trans ?? []) console.log(chalk6.cyan(`  \xB7 ${t}`));
       const sources = await Promise.all(
         group.map(async (h) => {
           const reg = await findEntry(h.dictId);
           return reg?.name ?? h.dictId;
         })
       );
-      console.log(chalk5.dim(`  in: ${sources.join(", ")}`));
+      console.log(chalk6.dim(`  in: ${sources.join(", ")}`));
       const mistake = book[name];
       if (mistake) {
-        console.log(chalk5.dim(`  mistakes: ${mistake.count} (last ${mistake.lastSeen.slice(0, 10)})`));
+        console.log(chalk6.dim(`  mistakes: ${mistake.count} (last ${mistake.lastSeen.slice(0, 10)})`));
       }
     }
     console.log();
   });
 }
 
+// src/commands/stealth.ts
+import { Command as Command6 } from "commander";
+function buildStealthCommand() {
+  return new Command6("boss").alias("stealth").description("Start practice in stealth mode (minimal UI, looks like plain terminal output)").argument("[dictId]", "dictionary id; falls back to config.defaultDict").option("-c, --chapter <n>", "chapter number (1-based)", "1").option("-m, --mode <mode>", "order | dictation | review | random | loop").action(
+    async (dictIdArg, options) => {
+      await runPractice(dictIdArg, { ...options, stealth: true });
+    }
+  );
+}
+
 // src/commands/menu.ts
 import { render as render2 } from "ink";
 import { createElement as createElement2 } from "react";
@@ -2442,17 +3625,22 @@ async function runMainMenu() {
     return;
   }
   const cfg = await loadConfig();
+  start();
   const { waitUntilExit } = render2(
     createElement2(App, { initial: { name: "main" }, initialCfg: cfg }),
     { patchConsole: false, exitOnCtrlC: false }
   );
   await waitUntilExit();
+  ensureMainScreen();
+  const { lang, t } = pickStrings(cfg.language);
+  printSessionReport(report(), t, lang);
 }
 
 // src/cli.ts
-var program = new Command6();
+var program = new Command7();
 program.name("qwerty").description("Terminal clone of qwerty-learner \u2014 typing practice for English vocabulary").version(package_default.version);
 program.addCommand(buildPracticeCommand());
+program.addCommand(buildStealthCommand());
 program.addCommand(buildDictCommand());
 program.addCommand(buildWordCommand());
 program.addCommand(buildStatsCommand());