cline-kit 0.1.2 → 0.2.0

package/CHANGELOG.md

@@ -4,6 +4,37 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); dictionary data changes are versioned inside
 each `dictionaries/<locale>.json` rather than here.
 
+## [0.2.0] - 2026-09-21
+
+### Added
+
+- **`language-picker` feature - the interface language is now chosen inside Cline.** Settings gains an
+  "Interface language" row under Dark mode, built from the same markup as the rows around it, listing
+  each language in its own script (English / 日本語 / 한국어 / Tiếng Việt / 简体中文 / 繁體中文).
+  Clicking writes one pending intent into `localStorage`; the resident injector consumes it on its next
+  cycle, stores it as the configured dictionary, and re-injects, so the open window follows in ~4 s with
+  no reload and the choice survives a restart. `ckit feature disable language-picker` removes the row.
+- `none` / `English` as a first-class language: run the overlay for the sidebar only and leave every
+  string Cline shipped. Available in the app row, `ckit locales none` and `--dictionary=none`; with it
+  selected `ckit update` reports "translation is off" instead of fetching.
+
+### Changed
+
+- The terminal is now the secondary route, not the only one: `ckit locales`, `--help` and both READMEs
+  point at Settings first, and `ckit install` / the first `ckit start` say "pick it inside Cline".
+- Language names are listed in the language they name. `label` inside a dictionary is that language's
+  own wording (English for the machine-assisted packs), so a list built from it read as
+  "简体中文 / Japanese / Korean" - a translation of whatever is on screen instead of a choice.
+- Per-feature build hashes now cover the feature's **config** as well as its source. Keyed on source
+  alone, a locale switch left `language-picker` running with the previous `current` until a full reload.
+- `ckit doctor` summarises each feature with its own numbers instead of assuming the sidebar's, and a
+  feature that is only mounted some of the time (a Settings row) no longer reads as a failure.
+- The overlay leaves its own UI alone: nodes marked `data-ckit-ui` are skipped by the translator
+  (memoised per node), which is what keeps the language row from being re-translated by itself.
+- `npm test` is 28 checks: feature text is compared against **every** dictionary and every feature,
+  the picker's choice list and native names are pinned, `none` is verified as a real setting, and a
+  config-only change is required to bump the payload version.
+
 ## [0.1.2] - 2026-09-21
 
 ### Added

package/README.md

@@ -13,9 +13,10 @@ Every project you registered but have not opened yet is simply invisible. `cline
 them listed, with the same styling as the native groups, and lets you switch into an empty project
 straight from the sidebar.
 
-**Secondary feature:** UI locale packs — five ship: 简体中文 (reference, proofread), plus 繁體中文 /
-日本語 / 한국어 / Tiếng Việt. Locales exist because the same injection channel can carry them — they
-are not what the project is for.
+**Secondary feature:** UI locale packs — 简体中文 (reference, proofread), 繁體中文, 日本語, 한국어,
+Tiếng Việt, plus an `English` opt-out. Pick one inside Cline itself: Settings gains an **Interface
+language** row. Locales exist because the same injection channel can carry them — they are not what
+the project is for.
 
 ## The sidebar problem
 
@@ -81,7 +82,7 @@ ckit.cmd start
 git clone https://github.com/chentaoxing/Cline-kit.git
 cd cline-kit
 npm install -g .            # or call it directly: node src/cli.js <command>
-npm test                    # 25 checks, no dependencies
+npm test                    # 28 checks, no dependencies
 ```
 
 Then in every case:
@@ -117,17 +118,24 @@ then gives you the enhanced sidebar. If you would rather keep your own launcher,
 
 ### Choosing a language
 
-Language is a per-install choice, and Cline has no language setting of its own, so the kit exposes it:
+**In the app:** open Cline's Settings (the gear at the bottom of the sidebar) and use the **Interface
+language** row. It sits under Dark mode, looks like its neighbours, and takes effect in about four
+seconds — no restart, and the choice is remembered. `English` there means "change nothing".
+
+**From the terminal**, which is the same setting:
 
 ```bash
 ckit locales          # what ships, how many strings each covers, which one is active
 ckit locales ja       # switch; the open window changes within ~4 s, no restart
-ckit locales zh-CN    # back to the reference dictionary
+ckit locales none     # stop replacing Cline's own text
 ```
 
 `ckit install` prints the current language and this command, and the first `ckit start` says it once.
-`ckit config --dictionary=<code>` is the same write if you prefer the generic config command. Once a
-non-default locale is selected, `ckit update` hot-updates *that* dictionary.
+`ckit config --dictionary=<code>` is the equivalent low-level write. Once a non-default locale is
+selected, `ckit update` hot-updates *that* dictionary.
+
+The row is added by this kit — Cline has no language setting of its own. Turn it off with
+`ckit feature disable language-picker`.
 
 ## Features
 
@@ -140,13 +148,15 @@ non-default locale is selected, `ckit update` hot-updates *that* dictionary.
   session; otherwise the kit keeps project grouping on. Two projects that share a folder name are
   labelled with their parent folder - `LLM (workspace)` - and every row carries the full path as its
   tooltip. Design notes: [`docs/features.zh-CN.md`](docs/features.zh-CN.md).
+* **`language-picker`** (on by default) — the Interface language row inside Cline's own Settings page.
+  See [Choosing a language](#choosing-a-language).
 * **locale packs** (`dictionaries/<locale>.json`) — whole-string text replacement only, so model
   names, provider names, tool identifiers and code cannot be mangled. The corpus is 476 strings plus
   30 pattern rules, built by combining a UI walk with extraction from the app's own source. Five
   dictionaries ship: **zh-CN** (reference, proofread against the running app), **zh-TW**, **ja**,
   **ko**, **vi** - complete but machine-assisted and *not* reviewed by native speakers, so a pull
-  request fixing a term is genuinely welcome. Pick one with `ckit locales` — see
-  [Choosing a language](#choosing-a-language). Authoring guide:
+  request fixing a term is genuinely welcome. Choose one in Cline's Settings, or with
+  `ckit locales` — see [Choosing a language](#choosing-a-language). Authoring guide:
   [`docs/dictionary-pipeline.zh-CN.md`](docs/dictionary-pipeline.zh-CN.md).
 
 ## Limitations
@@ -160,9 +170,10 @@ non-default locale is selected, `ckit update` hot-updates *that* dictionary.
   repointed) has no debug port to attach to, so you get plain Cline.
 * **Cline updates can break things.** If the app renames a label, the locale leaves it in English; if
   it restructures the sidebar, `sidebar-groups` needs updating. Run `ckit audit` and open an issue.
-* **The language switch is in the kit, not in Cline.** Cline has no language setting, so there is no
-  gear icon to find it under: `ckit locales` is the picker (and `ckit install` / the first `ckit start`
-  point at it).
+* **The language row is ours, not Cline's.** It is inserted into the Settings page next to Dark mode,
+  which is the right place to look but not a location Cline documents. If that page is restructured,
+  `language-picker` needs its anchor updated (`ckit doctor` reports whether the row is present);
+  `ckit feature disable language-picker` removes it.
 * **Per-model description blurbs stay English** — free-form text from a remote provider catalogue.
 * **Same-named projects.** Cline's own group headers expose only the folder name, never the path, so if
   the registry holds two different `LLM` folders and one already has a native group, the kit cannot tell

package/README.zh-CN.md

@@ -10,8 +10,9 @@
 在界面上根本不存在。cline-kit 把所有已登记项目常驻列出，样式与原生分组一致，并且可以直接从侧边栏
 切进一个还没有会话的项目。
 
-**附属功能：** 界面语言包，随包 5 份：**zh-CN**（基准，逐条对着界面校过）、繁體中文 / 日本語 /
-한국어 / Tiếng Việt。语言包之所以在这里，是因为同一条注入通道顺带能承载它——它不是这个项目存在的理由。
+**附属功能：** 界面语言包，随包 5 份：**zh-CN**（基准，逐条对着界面校过）、繁體中文 / 日本語 / 한국어 /
+Tiếng Việt，另加一项 `English` 表示不替换。选择入口在 Cline 里面：设置页会多出一行**界面语言**。
+语言包之所以在这里，是因为同一条注入通道顺带能承载它——它不是这个项目存在的理由。
 
 ## 要解决的问题
 
@@ -73,7 +74,7 @@ ckit.cmd start
 git clone https://github.com/chentaoxing/Cline-kit.git
 cd cline-kit
 npm install -g .        # 或直接用：node src/cli.js <命令>
-npm test                # 25 项无依赖自检
+npm test                # 28 项无依赖自检
 ```
 
 装完统一确认一次：
@@ -108,16 +109,21 @@ ckit locales            # 可选：看有哪些语言、换语言
 
 ### 选择语言
 
-Cline 自己没有语言设置，所以选择权在工具这一侧：
+**在软件里**：点开 Cline 侧边栏底部的齿轮进「设置」，用**界面语言**那一行。它排在「深色模式」下面，
+样式和邻居一致，点完约 4 秒生效——不用重启，选择会记住。列表里的 `English` 表示不替换任何文案。
+
+**在终端里**（改的是同一个设置）：
 
 ```bash
 ckit locales          # 看有哪些语言、各覆盖多少条、当前用的是哪一个（* 号标记）
 ckit locales ja       # 切换；正在打开的窗口约 4 秒内跟着变，不用重启
-ckit locales zh-CN    # 换回基准词典
+ckit locales none     # 不再替换 Cline 自己的文案
 ```
 
 `ckit install` 每次都会打印当前语言和这条命令，第一次 `ckit start` 成功后也会提示一次。
-`ckit config --dictionary=<语言>` 是等价的写法。选定非默认语言后，`ckit update` 热更新的就是那一份。
+`ckit config --dictionary=<语言>` 是等价的底层写法。选定非默认语言后，`ckit update` 热更新的就是那一份。
+
+这一行是本工具加进去的，Cline 原生没有语言设置；不想要就 `ckit feature disable language-picker`。
 
 ## 功能
 
@@ -128,11 +134,13 @@ ckit locales zh-CN    # 换回基准词典
   如果你亲手点了 Cline 的排序按钮，本会话内就以你的选择为准不再干预；否则增强层会持续保持分组模式。
   两个同名项目（比如两块盘上都有 `LLM`）会带上上级目录名显示成 `LLM (workspace)`，仍然重名就加序号，
   而鼠标悬停始终是完整路径。设计说明见 [`docs/features.zh-CN.md`](docs/features.zh-CN.md)。
+* **`language-picker`**（默认开启）——在 Cline 自己的设置页里加一行「界面语言」，见
+  [选择语言](#选择语言)。
 * **语言包**（`dictionaries/<locale>.json`）——只做**整串精确匹配**替换，因此不会误伤模型名、服务商名、
   工具标识和代码。语料为 476 条词条 + 30 条规则，来源是「界面走查 + 从应用自身源码提取」两路合并。
   现在随包附带 5 份词典：**zh-CN**（基准，逐条对着运行中的界面校对过）、**zh-TW**、**ja**、**ko**、
   **vi** —— 后四份条目齐全但属于机器辅助翻译、未经母语者审校，术语有偏差欢迎提 PR 直接改。
-  切换：`ckit locales`（列出并切换）或 `ckit locales ja`，正在打开的窗口**不需要重启或刷新**就会跟着变；
+  切换：Cline 设置页的「界面语言」，或 `ckit locales ja`，正在打开的窗口**不需要重启或刷新**就会跟着变；
   `ckit update` 也只更新你选的那一份。详见[选择语言](#选择语言)。制作流程见
   [`docs/dictionary-pipeline.zh-CN.md`](docs/dictionary-pipeline.zh-CN.md)。
 
@@ -145,8 +153,9 @@ ckit locales zh-CN    # 换回基准词典
   得到的是原版界面。
 * **Cline 升级可能失效。** 文案改了，语言包会留英文；侧边栏结构改了，`sidebar-groups` 需要跟进。
   跑一次 `ckit audit` 并开 issue。
-* **语言开关在工具这一侧，不在 Cline 里。** Cline 没有语言设置，所以界面里找不到那个齿轮：
-  `ckit locales` 就是选择器（`ckit install` 和第一次 `ckit start` 都会提示它）。
+* **语言那一行是本项目加的，不是 Cline 原生的。** 它插在设置页「深色模式」下面——位置符合直觉，
+  但那个位置并不是 Cline 公开约定的。那一页改版时需要更新 `language-picker` 的锚点
+  （`ckit doctor` 会报这一行在不在），不想要就 `ckit feature disable language-picker`。
 * **模型下方的一句英文简介不覆盖**——来自云端目录的自由文本，条数随服务商变化。
 * **同名项目。** Cline 自己的分组标题只有文件夹名、没有路径，所以登记表里出现两个不同盘符下的 `LLM`
   且其中一个已有原生分组时，无法判断哪一个才是它。此时两行都列出（带上级目录区分），并且不在这种行里

package/dictionaries/ja.json

@@ -1,9 +1,9 @@
 {
- "version": 1,
+ "version": 2,
  "language": "ja",
  "label": "Japanese",
  "clineVersion": "0.0.32",
- "updated": "2026-09-20",
+ "updated": "2026-09-21",
  "note": "Whole-string exact matches only. Rules run before prefixes; $1..$9 come from rule capture groups. Provider, model and product names are intentionally left in English.",
  "entries": {
   "Session": "セッション",
@@ -617,6 +617,13 @@
    "errNoSearch": "ワークスペース検索ボックスが見つかりません",
    "errNotListed": "このプロジェクトは一覧にありません",
    "errSwitch": "切り替えに失敗しました"
+  },
+  "language-picker": {
+   "title": "表示言語",
+   "hint": "cline-kit が追加。約4秒で反映され、再起動は不要です。選択は保存されます。",
+   "switching": "切り替え中…",
+   "offTip": "Cline 本来の表示に戻す",
+   "stringsWord": "件"
   }
  }
 }

package/dictionaries/ko.json

@@ -1,9 +1,9 @@
 {
- "version": 1,
+ "version": 2,
  "language": "ko",
  "label": "Korean",
  "clineVersion": "0.0.32",
- "updated": "2026-09-20",
+ "updated": "2026-09-21",
  "note": "Whole-string exact matches only. Rules run before prefixes; $1..$9 come from rule capture groups. Provider, model and product names are intentionally left in English.",
  "entries": {
   "Session": "세션",
@@ -617,6 +617,13 @@
    "errNoSearch": "작업 공간 검색 상자를 찾을 수 없습니다",
    "errNotListed": "목록에 해당 프로젝트가 없습니다",
    "errSwitch": "전환 실패"
+  },
+  "language-picker": {
+   "title": "인터페이스 언어",
+   "hint": "cline-kit이 추가한 항목입니다. 약 4초 후 적용되며 재시작이 필요 없고 설정은 저장됩니다.",
+   "switching": "변경 중…",
+   "offTip": "Cline 원문으로 되돌리기",
+   "stringsWord": "개"
   }
  }
 }

package/dictionaries/vi.json

@@ -1,9 +1,9 @@
 {
- "version": 1,
+ "version": 2,
  "language": "vi",
  "label": "Vietnamese",
  "clineVersion": "0.0.32",
- "updated": "2026-09-20",
+ "updated": "2026-09-21",
  "note": "Whole-string exact matches only. Rules run before prefixes; $1..$9 come from rule capture groups. Provider, model and product names are intentionally left in English.",
  "entries": {
   "Session": "Phiên",
@@ -617,6 +617,13 @@
    "errNoSearch": "Không tìm thấy ô tìm kiếm không gian làm việc",
    "errNotListed": "Dự án đó không có trong danh sách",
    "errSwitch": "Chuyển đổi thất bại"
+  },
+  "language-picker": {
+   "title": "Ngôn ngữ giao diện",
+   "hint": "Do cline-kit thêm vào. Áp dụng trong ~4 giây, không cần khởi động lại, lựa chọn được lưu.",
+   "switching": "Đang chuyển…",
+   "offTip": "Giữ nguyên văn bản gốc của Cline",
+   "stringsWord": "chuỗi"
   }
  }
 }

package/dictionaries/zh-CN.json

@@ -1,9 +1,9 @@
 {
- "version": 5,
+ "version": 6,
  "language": "zh-CN",
  "label": "简体中文",
  "clineVersion": "0.0.32",
- "updated": "2026-09-20",
+ "updated": "2026-09-21",
  "note": "Whole-string exact matches only. Rules run before prefixes; $1..$9 come from rule capture groups. Provider, model and product names are intentionally left in English.",
  "entries": {
   "Session": "会话",
@@ -618,6 +618,13 @@
    "errNoSearch": "未找到工作区搜索框",
    "errNotListed": "列表里没有该项目",
    "errSwitch": "切换失败"
+  },
+  "language-picker": {
+   "title": "界面语言",
+   "hint": "由 cline-kit 添加；约 4 秒生效，无需重启，选择会保存。",
+   "switching": "切换中…",
+   "offTip": "恢复 Cline 原始文案",
+   "stringsWord": "条"
   }
  }
 }

package/dictionaries/zh-TW.json

@@ -1,9 +1,9 @@
 {
- "version": 1,
+ "version": 2,
  "language": "zh-TW",
  "label": "繁體中文",
  "clineVersion": "0.0.32",
- "updated": "2026-09-20",
+ "updated": "2026-09-21",
  "note": "Whole-string exact matches only. Rules run before prefixes; $1..$9 come from rule capture groups. Provider, model and product names are intentionally left in English. Same 476 strings as zh-CN, localised for Taiwan software usage (外掛程式 / 市集 / 智慧代理 / 重新整理 / 匯入) with character-sense review rather than a mechanical simplified-to-traditional swap.",
  "entries": {
   "Session": "會話",
@@ -618,6 +618,13 @@
    "errNoSearch": "找不到工作區搜尋框",
    "errNotListed": "清單中沒有這個專案",
    "errSwitch": "切換失敗"
+  },
+  "language-picker": {
+   "title": "介面語言",
+   "hint": "由 cline-kit 新增；約 4 秒生效，不需重新啟動，設定會儲存。",
+   "switching": "切換中…",
+   "offTip": "還原 Cline 原始文字",
+   "stringsWord": "條"
   }
  }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cline-kit",
-  "version": "0.1.2",
-  "description": "Desktop enhancement kit for the Cline desktop app (Windows): keeps every registered project visible in the sidebar, and adds optional UI locale packs (zh-CN, zh-TW, ja, ko, vi). Runtime overlay - no binary patching.",
+  "version": "0.2.0",
+  "description": "Desktop enhancement kit for the Cline desktop app (Windows): keeps every registered project visible in the sidebar, and adds an interface-language picker inside Cline's own Settings (zh-CN, zh-TW, ja, ko, vi, or leave the text alone). Runtime overlay - no binary patching.",
   "keywords": [
     "cline",
     "desktop-app",

package/src/cli.js

@@ -4,7 +4,6 @@
 // Flagship feature: keep every registered project visible in the sidebar.
 // Optional: UI locale packs (zh-CN reference; zh-TW / ja / ko / vi ship the same key set).
 const cfg = require("./config");
-const fs = require("fs");
 
 function guard() {
   if (typeof WebSocket !== "function") {
@@ -42,9 +41,12 @@ Main feature
 Optional feature
   locale packs     dictionaries/<locale>.json - whole-string replacement only, so provider names,
                    model names and code cannot be mangled. Bundled: zh-CN (reference, 476 entries),
-                   zh-TW, ja, ko, vi. Pick one with 'ckit locales' (lists + switches); the older
-                   'ckit config --dictionary=ja' does the same. 'ckit update' then follows that
-                   locale. Only zh-CN is proofread against the running app.
+                   zh-TW, ja, ko, vi, plus 'none' to leave Cline's own text alone.
+                   Pick it INSIDE Cline: Settings -> Interface language (that row is added by this
+                   kit, and clicking it applies within ~4 s without a restart). Or from here:
+                   'ckit locales' lists the choices, 'ckit locales ja' switches, and 'ckit update'
+                   then follows whichever locale is selected.
+                   Only zh-CN is proofread against the running app.
 
 Examples:
   ckit start
@@ -52,6 +54,7 @@ Examples:
   ckit features
   ckit locales
   ckit locales ja
+  ckit locales none
   ckit feature disable sidebar-groups
   ckit config --cline-path "D:\\Programs\\Cline\\cline-app.exe"
 `;
@@ -67,6 +70,16 @@ function parseFlags(argv) {
   return { flags, rest };
 }
 
+// CJK and accented names are not one cell per code unit, and `padEnd` does not know that.
+function cellWidth(s) {
+  let n = 0;
+  for (const ch of String(s)) n += /[㐀-䶿一-鿿぀-가-힯豈-﫿]/.test(ch) ? 2 : 1;
+  return n;
+}
+function padCell(s, width) {
+  return String(s) + " ".repeat(Math.max(1, width - cellWidth(s)));
+}
+
 // Language choice is a per-install decision, so say where to change it once per
 // setup path instead of hiding it in the README. Returns nothing; prints itself.
 function languageTip(conf, showOnce) {
@@ -77,10 +90,11 @@ function languageTip(conf, showOnce) {
   }
   const dict = require("./dict");
   let codes = [];
-  try { codes = dict.available(); } catch (e) { codes = []; }
+  try { codes = dict.choices().map((c) => c.code); } catch (e) { codes = []; }
   const current = conf.dictionary || "zh-CN";
-  console.log(`Interface language: ${current}  (bundled: ${codes.join(", ") || current})`);
-  console.log("  list / switch with: ckit locales        e.g. ckit locales ja");
+  console.log(`Interface language: ${current}  (choices: ${codes.join(", ") || current})`);
+  console.log("  pick it inside Cline: Settings -> Interface language");
+  console.log("  or here: ckit locales  /  ckit locales ja");
 }
 
 async function main() {
@@ -218,11 +232,11 @@ async function main() {
   if (cmd === "locales" || cmd === "locale") {
     const dict = require("./dict");
     const conf2 = cfg.read();
-    const have = dict.available();
+    const choices = dict.choices();
     const target = argv.slice(1).filter((a) => !a.startsWith("--"))[0];
     if (target) {
-      if (!have.includes(target)) {
-        console.error(`Unknown locale "${target}". Bundled: ${have.join(", ")}`);
+      if (!dict.isKnown(target)) {
+        console.error(`Unknown locale "${target}". Bundled: ${choices.map((c) => c.code).join(", ")}`);
         process.exitCode = 1;
         return;
       }
@@ -231,17 +245,19 @@ async function main() {
       console.log(`Language -> ${target} (the injector applies it within ~4 s, no restart needed)`);
       console.log("Cline must be running through cline-kit for the open window to change; otherwise it");
       console.log("applies the next time you start it with `ckit start`.");
+      console.log("The same choice is available inside Cline: Settings -> Interface language.");
       return;
     }
     console.log("Bundled UI languages (switch with: ckit locales <code>):\n");
-    for (const code of have) {
-      const d = JSON.parse(fs.readFileSync(dict.bundledPath(code), "utf8"));
-      const n = Object.keys(d.entries || {}).length;
-      const active = (conf2.dictionary || "zh-CN") === code;
-      console.log(`  ${active ? "*  " : "   "}${code.padEnd(7)} ${(d.label || "").padEnd(12)} ${String(n).padStart(4)} strings  v${d.version}`);
+    for (const c of choices) {
+      const active = (conf2.dictionary || "zh-CN") === c.code;
+      const tail = c.off ? "  (original text, nothing replaced)"
+        : `  v${c.version}`;
+      console.log(`  ${active ? "*  " : "   "}${c.code.padEnd(7)} ${padCell(c.native, 12)} ${String(c.strings).padStart(4)} strings${tail}`);
     }
     console.log("\nOnly zh-CN is proofread against the running app; the others are complete but not");
     console.log("reviewed by native speakers - see dictionaries/ if you want to fix a term.");
+    console.log("You can also pick this inside Cline: Settings -> Interface language.");
     return;
   }
 
@@ -260,9 +276,9 @@ async function main() {
     if (flags["storage-key"] !== undefined) { conf.storageKey = String(flags["storage-key"]); changed = true; }
     if (flags.dictionary) {
       const want = flags.dictionary;
-      const have = require("./dict").available();
-      if (!have.includes(want)) {
-        console.error(`Unknown locale "${want}". Bundled dictionaries: ${have.join(", ")}`);
+      const dict = require("./dict");
+      if (!dict.isKnown(want)) {
+        console.error(`Unknown locale "${want}". Choices: ${dict.choices().map((c) => c.code).join(", ")}`);
         process.exitCode = 1;
         return;
       }

package/src/dict.js

@@ -33,6 +33,23 @@ function bundledPath(name) {
   return path.join(__dirname, "..", "dictionaries", name + ".json");
 }
 
+// "none" is a first-class choice, not an absent one: the overlay still runs (the sidebar feature
+// needs it) but replaces no text, so the app reads as Cline shipped it. Both the in-app picker and
+// `ckit locales none` land here.
+const NONE = "none";
+function noneDictionary() {
+  return {
+    version: 0,
+    language: NONE,
+    label: "English (no replacement)",
+    note: "synthetic - translation off",
+    entries: {},
+    prefixes: [],
+    rules: [],
+    sourceVersions: { bundled: 0, cached: 0, local: 0 }
+  };
+}
+
 function validate(d) {
   if (!d || typeof d !== "object") return false;
   if (typeof d.version !== "number") return false;
@@ -96,6 +113,7 @@ function merge(base, extra) {
 
 function load(cfgObj) {
   const name = cfgObj.dictionary || "zh-CN";
+  if (name === NONE) return noneDictionary();
   let dict = readJson(bundledPath(name));
   if (!dict) throw new Error("bundled dictionary missing: " + name);
   const cached = readJson(cfg.cachedDictFile(name));
@@ -120,6 +138,7 @@ async function fetchRemote(url, timeoutMs) {
 // the file name rather than asking users to configure one URL per language.
 function remoteUrlFor(cfgObj) {
   const name = cfgObj.dictionary || "zh-CN";
+  if (name === NONE) return "";
   const url = cfgObj.updateUrl || "";
   return /CHANGE_ME/.test(url) ? url : url.replace(/zh-CN\.json(\?.*)?$/i, name + ".json$1");
 }
@@ -129,6 +148,7 @@ async function update(cfgObj, opts) {
   opts = opts || {};
   const now = Date.now();
   if (!opts.force && !cfgObj.autoUpdate) return { updated: false, reason: "autoUpdate disabled" };
+  if (cfgObj.dictionary === NONE) return { updated: false, reason: "translation is off" };
   if (!opts.force && (now - (cfgObj.lastUpdateCheck || 0)) < (cfgObj.updateIntervalMs || 86400000)) {
     return { updated: false, reason: "not due yet" };
   }
@@ -168,4 +188,37 @@ function available() {
   } catch (e) { return []; }
 }
 
-module.exports = { load, update, validate, bundledPath, nestedQuantifier, remoteUrlFor, available };
+// Everything a picker (in-app or CLI) needs to render one row per choice. `none` leads because
+// "leave the app alone" has to be reachable from the same place.
+// Each language is listed in its own script - the one convention that stays readable no matter which
+// language the interface is currently in. `label` inside a dictionary is the name in *that* language
+// (and English for the machine-assisted ones), which would render a list like
+// "简体中文 / Japanese / Korean" and read like a translation of the current UI rather than a choice.
+const NATIVE_NAMES = {
+  none: "English",
+  "zh-CN": "简体中文",
+  "zh-TW": "繁體中文",
+  ja: "日本語",
+  ko: "한국어",
+  vi: "Tiếng Việt"
+};
+
+function choices() {
+  const out = [{
+    code: NONE, native: NATIVE_NAMES[NONE], label: "English", strings: 0, version: 0, off: true
+  }];
+  for (const code of available().sort()) {
+    const d = readJson(bundledPath(code)) || {};
+    out.push({
+      code, native: NATIVE_NAMES[code] || d.label || code, label: d.label || code,
+      strings: Object.keys(d.entries || {}).length, version: d.version || 0, off: false
+    });
+  }
+  return out;
+}
+
+function isKnown(name) {
+  return name === NONE || available().includes(name);
+}
+
+module.exports = { load, update, validate, bundledPath, nestedQuantifier, remoteUrlFor, available, choices, isKnown, NONE };

package/src/doctor.js

@@ -30,6 +30,23 @@ function evaluate(api, expression) {
     .then((r) => (r && r.result && r.result.value !== undefined ? r.result.value : null));
 }
 
+// Each feature publishes its own shape under `__ckitFeatureState[<id>_stats]`, so the doctor line has
+// to read the numbers instead of assuming the sidebar's. A feature that is only on screen some of the
+// time (the Settings row) must not look like a failure when it is simply not mounted.
+function summarize(stats) {
+  if (typeof stats.rows === "number") {
+    return stats.rows + " row(s) added of " + stats.registered + " registered, " + stats.nativeGroups + " native";
+  }
+  if (stats.row) {
+    const bits = [stats.row === "rendered" ? "row present" : "row not on screen (" + stats.row + ")"];
+    if (stats.current) bits.push("current " + stats.current);
+    if (stats.pending && stats.pending !== stats.current) bits.push("pending " + stats.pending);
+    if (stats.choices) bits.push(stats.choices + " choices");
+    return bits.join(", ");
+  }
+  return JSON.stringify(stats).slice(0, 120);
+}
+
 async function run() {
   const conf = cfg.read();
   const found = detect.detect(conf);
@@ -70,7 +87,7 @@ async function run() {
     if (!f.enabled) continue;
     const seen = live.map((p) => p.features[f.id]).filter(Boolean);
     add("feature " + f.id, seen.length > 0, seen.length
-      ? seen.map((s) => "build " + s.build + (s.stats ? ", " + s.stats.rows + " row(s) added of " + s.stats.registered + " registered, " + s.stats.nativeGroups + " native" : "")).join(" | ")
+      ? seen.map((s) => "build " + s.build + (s.stats ? ", " + summarize(s.stats) : "")).join(" | ")
       : "not present in any page - Cline's DOM may have changed");
   }
 

package/src/engine.js

@@ -54,6 +54,18 @@
 
   function norm(s) { return String(s || "").replace(/\s+/g, " ").trim(); }
 
+  // The kit's own controls (the in-app language row) are already rendered in the language the user
+  // picked, and translating them would let the observer chase its own output. The check is memoised
+  // on the node because this runs for every text node on every mutation.
+  function isKitUI(el) {
+    if (!el || el.nodeType !== 1) return false;
+    if (el.__ckitOwn == null) {
+      try { el.__ckitOwn = el.closest && el.closest("[data-ckit-ui]") ? 1 : 0; }
+      catch (e) { el.__ckitOwn = 0; }
+    }
+    return el.__ckitOwn === 1;
+  }
+
   // Text we replaced is remembered on the node, so switching locale (or pulling a newer dictionary)
   // can start from the original English instead of from last run's output.
   function translateText(node) {
@@ -61,6 +73,7 @@
     if (!raw || raw.length > 800) return;
     var el = node.parentElement;
     if (el && SKIP[el.tagName]) return;
+    if (isKitUI(el)) return;
     var src = raw;
     if (node.__ckitOut != null) {
       src = norm(raw) === norm(node.__ckitOut) ? node.__ckitSrc : raw;  // the app rewrote it: stale
@@ -85,6 +98,7 @@
 
   function translateEl(el) {
     if (!el || el.nodeType !== 1 || !el.getAttribute) return;
+    if (isKitUI(el)) return;
     var keep = el.__ckitAttrSrc || (el.__ckitAttrSrc = {});
     for (var i = 0; i < ATTRS.length; i++) {
       var a = ATTRS[i];

package/src/features/index.js

@@ -3,6 +3,7 @@
 // Versions are read from the scripts themselves so the registry cannot drift.
 const fs = require("fs");
 const path = require("path");
+const dict = require("../dict");
 
 const DEFS = [
   {
@@ -23,6 +24,25 @@ const DEFS = [
         text: (ctx.featureText || {})[this.id] || {}
       };
     }
+  },
+  {
+    id: "language-picker",
+    file: "language-picker.js",
+    title: "Interface language row inside Cline's own Settings / 在 Cline 设置页里选语言",
+    defaultOn: true,
+    build(ctx) {
+      const current = ctx.cfg.dictionary || "zh-CN";
+      // The row belongs under Dark mode. Anchor on the English key and on this locale's rendering of
+      // it, because the engine may already have replaced the label when we look.
+      const dark = (ctx.entries || {})["Dark mode"];
+      return {
+        current,
+        pendingKey: "cline-kit.language-pending",
+        choices: dict.choices(),
+        anchors: dark && dark !== "Dark mode" ? ["Dark mode", dark] : ["Dark mode"],
+        text: (ctx.featureText || {})[this.id] || {}
+      };
+    }
   }
 ];
 
@@ -63,7 +83,8 @@ function resolve(cfgObj, dictObj) {
   const ctx = {
     cfg: cfgObj,
     installDir: cfgObj.clinePath ? path.dirname(cfgObj.clinePath) : "",
-    featureText: (dictObj && dictObj.featureText) || {}
+    featureText: (dictObj && dictObj.featureText) || {},
+    entries: (dictObj && dictObj.entries) || {}
   };
   const picked = [];
   for (const d of DEFS) {

package/src/features/language-picker.js

@@ -0,0 +1,182 @@
+// feature: language-picker
+// Puts Cline's own Settings page in charge of the interface language. Cline has no language setting,
+// so this adds a row that looks like the neighbours it sits between (same structure as the Dark mode
+// and App icon rows) and lists the dictionaries that ship with the kit, plus "English" to opt out.
+//
+// Clicking does not translate the page from inside the page - the payload is composed in Node. The
+// click stores one pending intent in localStorage; the resident injector consumes it on its next
+// cycle (<= 4 s), writes `dictionary` into %APPDATA%\cline-kit\config.json, and re-injects. The
+// engine then re-translates from the original text, so no reload happens and the choice survives a
+// restart. Because the injector clears the key after consuming it, `ckit locales <code>` from the
+// terminal stays authoritative instead of being overwritten by a stale click.
+//
+// Runs inside the webview. Config arrives as window.__clineKitFeature["language-picker"].
+(function () {
+  var ID = "language-picker";
+  var VER = 1;                       // human-readable; hot-swap keys off CFG.__build instead
+  var CFG = (window.__clineKitFeature && window.__clineKitFeature[ID]) || {};
+  var st = window.__clineKitFeatureState = window.__clineKitFeatureState || {};
+  var BUILD = String(CFG.__build || "v" + VER);
+  if (st[ID + "_build"] === BUILD) return;
+  if (st[ID + "_observer"]) { try { st[ID + "_observer"].disconnect(); } catch (e) { } }
+  if (st[ID + "_timer"]) clearInterval(st[ID + "_timer"]);
+  st[ID + "_build"] = BUILD;
+  st[ID] = VER;
+
+  var TEXT = CFG.text || {};
+  var CHOICES = CFG.choices || [];
+  var CURRENT = CFG.current || "zh-CN";
+  var PENDING = CFG.pendingKey || "cline-kit.language-pending";
+  // The row goes under the Dark mode switch. Its label is translated like everything else, so the
+  // registry hands over both the English key and this locale's rendering of it.
+  var ANCHORS = CFG.anchors || ["Dark mode"];
+
+  // Fallbacks are English on purpose: English is the app source language, so the row stays
+  // readable when a locale has no featureText block yet.
+  function t(key, fallback) { return (TEXT && TEXT[key]) || fallback; }
+
+  // Classes copied from Cline's own rows so the addition does not look bolted on.
+  var ROW_CLS = "flex items-center justify-between gap-5 border-b py-4 max-[720px]:flex-col max-[720px]:items-stretch";
+  var LEFT_CLS = "flex flex-col gap-1";
+  var TITLE_CLS = "text-base font-semibold text-foreground";
+  var HINT_CLS = "text-sm text-muted-foreground";
+  var GROUP_CLS = "flex shrink-0 items-center gap-2 max-[720px]:flex-wrap";
+  var BTN_CLS = "inline-flex h-8 cursor-pointer items-center justify-center whitespace-nowrap rounded-md border bg-background px-3 text-sm font-medium shadow-xs outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] hover:bg-surface-hover hover:text-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50";
+  var ON_CLS = " ring-2 ring-ring ring-offset-2 ring-offset-background text-foreground";
+  var OFF_CLS = " text-muted-foreground";
+
+  function txt(el) { return (el && (el.innerText || el.textContent) || "").replace(/\s+/g, " ").trim(); }
+
+  function el(tag, cls, text) {
+    var n = document.createElement(tag);
+    if (cls) n.className = cls;
+    if (text != null) n.textContent = text;
+    return n;
+  }
+
+  // The Settings page is the container that holds several native switch rows. Anchoring on the
+  // switches instead of a class keeps this working when Tailwind reorders its utility list - but the
+  // page is not the only place with switches (a notification grid has eight of its own), so every
+  // candidate is scored and the densest one wins.
+  function settingsSection() {
+    var existing = document.querySelector("[data-ckit-lang]");
+    if (existing && existing.parentElement) return existing.parentElement;
+    var sws = document.querySelectorAll("[role=switch]");
+    var best = null, bestScore = 0;
+    for (var i = 0; i < sws.length; i++) {
+      var row = sws[i].closest("div.flex");
+      var box = row && row.parentElement;
+      if (!box || box === best) continue;
+      var switchRows = 0, bordered = 0;
+      for (var j = 0; j < box.children.length; j++) {
+        var c = box.children[j];
+        if (c.hasAttribute("data-ckit-lang")) continue;
+        if (c.querySelector("[role=switch]")) switchRows++;
+        if (/border/.test(String(c.className))) bordered++;
+      }
+      var score = switchRows * 2 + bordered;
+      if (switchRows >= 3 && score > bestScore) { best = box; bestScore = score; }
+    }
+    return best;
+  }
+
+  function anchorRow(box) {
+    for (var i = 0; i < box.children.length; i++) {
+      var c = box.children[i];
+      if (c.hasAttribute("data-ckit-lang")) continue;
+      var t2 = txt(c);
+      for (var k = 0; k < ANCHORS.length; k++) {
+        if (ANCHORS[k] && t2.indexOf(ANCHORS[k]) === 0) return c;
+      }
+    }
+    return null;
+  }
+
+  function pendingCode() {
+    try { return localStorage.getItem(PENDING); } catch (e) { return null; }
+  }
+
+  function choose(code) {
+    try { localStorage.setItem(PENDING, code); } catch (e) { return; }
+    render();                              // show "switching" immediately, the injector applies it
+  }
+
+  function buildRow() {
+    var row = el("div", ROW_CLS);
+    row.setAttribute("data-ckit-lang", String(VER));
+    row.setAttribute("data-ckit-ui", "");  // the engine must not re-translate our own labels
+    var left = el("div", LEFT_CLS);
+    left.appendChild(el("p", TITLE_CLS, t("title", "Interface language")));
+    var p = pendingCode();
+    var waiting = p && p !== CURRENT;
+    left.appendChild(el("p", HINT_CLS, waiting ? t("switching", "Switching...") : t("hint", "Added by cline-kit. Applies in a few seconds, no restart.")));
+    row.appendChild(left);
+
+    var group = el("div", GROUP_CLS);
+    group.setAttribute("role", "group");
+    group.setAttribute("aria-label", t("title", "Interface language"));
+    for (var i = 0; i < CHOICES.length; i++) {
+      (function (c) {
+        var on = c.code === CURRENT;
+        var b = el("button", BTN_CLS + (on ? ON_CLS : OFF_CLS), c.native);
+        b.type = "button";
+        b.setAttribute("data-ckit-code", c.code);   // stable handle for tests and for `ckit doctor`
+        b.setAttribute("aria-pressed", on ? "true" : "false");
+        b.setAttribute("title", c.off
+          ? t("offTip", "Show Cline's original text")
+          : c.code + " - " + c.strings + " " + t("stringsWord", "strings") + " v" + c.version);
+        if (waiting && c.code === p) b.className += ON_CLS;
+        b.addEventListener("click", function () { if (c.code !== CURRENT) choose(c.code); });
+        group.appendChild(b);
+      })(CHOICES[i]);
+    }
+    row.appendChild(group);
+    return row;
+  }
+
+  function removeRow(box) {
+    var olds = box.querySelectorAll(":scope > [data-ckit-lang]");
+    for (var i = 0; i < olds.length; i++) olds[i].remove();
+  }
+
+  function render() {
+    var box = settingsSection();
+    if (!box) { st[ID + "_stats"] = { version: VER, build: BUILD, row: "no-settings-page", choices: CHOICES.length }; return; }
+    var prev = box.querySelector(":scope > [data-ckit-lang]");
+    if (prev) {
+      // Text-only refresh keeps focus on a button the user may be tabbing through.
+      var fresh = buildRow();
+      box.replaceChild(fresh, prev);
+    } else {
+      var after = anchorRow(box);
+      if (after && after.nextSibling) box.insertBefore(buildRow(), after.nextSibling);
+      else if (after) box.appendChild(buildRow());
+      else box.appendChild(buildRow());
+    }
+    st[ID + "_stats"] = {
+      version: VER, build: BUILD, row: "rendered", current: CURRENT,
+      pending: pendingCode(), choices: CHOICES.length
+    };
+  }
+
+  var queued = false;
+  function schedule() {
+    if (queued) return;
+    queued = true;
+    (window.requestAnimationFrame || setTimeout)(function () { queued = false; render(); }, 16);
+  }
+
+  if (!document.body) return;
+  render();
+  // The settings page mounts and unmounts as the user navigates; an observer keeps the row present
+  // without polling, and the interval is the safety net for subtrees that report no mutation.
+  st[ID + "_observer"] = new MutationObserver(function (muts) {
+    for (var i = 0; i < muts.length; i++) {
+      var n = muts[i].target && muts[i].target.nodeType === 1 ? muts[i].target : muts[i].target && muts[i].target.parentElement;
+      if (n && n.closest && n.closest("[data-ckit-lang]")) return;   // our own click feedback
+    }
+    schedule();
+  });
+  st[ID + "_observer"].observe(document.body, { childList: true, subtree: true, characterData: true });
+  st[ID + "_timer"] = setInterval(render, 1500);
+})();

package/src/injector.js

@@ -6,11 +6,31 @@ const path = require("path");
 const { execFileSync } = require("child_process");
 const cfg = require("./config");
 const cdp = require("./cdp");
+const dict = require("./dict");
 const payload = require("./payload");
 
 const INTERVAL_MS = 4000;
 const registered = new Map(); // targetId -> { scriptId, dictVersion }
 
+// The in-app language row cannot swap the dictionary by itself - the payload is composed here. It
+// writes one pending intent instead, and this consumes it (read + clear in one expression so a
+// second page cannot consume it twice). Clearing is what keeps `ckit locales <code>` authoritative:
+// the key is a request, not the stored setting.
+const PENDING_KEY = "cline-kit.language-pending";
+const CONSUME = "(function(){try{var k=" + JSON.stringify(PENDING_KEY) +
+  ";var v=localStorage.getItem(k);if(v)localStorage.removeItem(k);return v||\"\"}catch(e){return\"\"}})()";
+
+async function consumeLanguageIntent(port) {
+  let wanted = "";
+  const results = await cdp.eachPage(port, async (api) => {
+    const r = await api.rpc("Runtime.evaluate", { expression: CONSUME, returnByValue: true });
+    if (r && r.exceptionDetails) return "";
+    return r && r.result && typeof r.result.value === "string" ? r.result.value : "";
+  });
+  for (const item of results) if (item && !item.error && item.result) wanted = item.result;
+  return wanted;
+}
+
 // Surface injection failures instead of swallowing them; a silent no-op is the worst outcome.
 function log(msg) {
   try {
@@ -78,6 +98,16 @@ async function main() {
     try {
       // re-read every cycle so feature toggles, dictionary updates and path changes apply live
       const conf = cfg.read();
+      try {
+        const wanted = await consumeLanguageIntent(conf.port || port);
+        if (wanted && dict.isKnown(wanted) && wanted !== conf.dictionary) {
+          conf.dictionary = wanted;
+          cfg.write(conf);
+          log("language chosen inside Cline -> " + wanted);
+        } else if (wanted && !dict.isKnown(wanted)) {
+          log("ignored unknown language request: " + wanted);
+        }
+      } catch (e) { log("language intent failed: " + e.message); }
       const composed = payload.compose(conf);
       await installOnce(conf.port || port, composed.source, composed.version);
       writeActiveVersion(composed.version);
@@ -93,4 +123,4 @@ async function main() {
 }
 
 if (require.main === module) main().catch((e) => { console.error(e); process.exit(1); });
-module.exports = { installOnce, readActiveVersion, activeVersionFile };
+module.exports = { installOnce, readActiveVersion, activeVersionFile, consumeLanguageIntent, PENDING_KEY };

package/src/payload.js

@@ -26,9 +26,11 @@ function compose(cfgObj) {
   const parts = ["const DICT = " + json(d) + ";", ENGINE];
 
   for (const f of picked) {
-    // per-feature build hash: the feature's own guard compares against it, so editing the script
-    // hot-swaps it without anyone remembering to bump a VER constant
-    const cfgObjForFeature = Object.assign({}, f.config, { __build: hash12(f.source) });
+    // Per-feature build hash over source *and* config: editing the script hot-swaps it, and so does a
+    // config change (a different `current` language, a new hide path) - keying on source alone left a
+    // feature running with stale config until a full reload.
+    const plain = Object.assign({}, f.config);
+    const cfgObjForFeature = Object.assign({}, plain, { __build: hash12(f.source + "\u0000" + json(plain)) });
     parts.push(
       "window.__clineKitFeature = window.__clineKitFeature || {};",
       "window.__clineKitFeature[" + json(f.id) + "] = " + json(cfgObjForFeature) + ";",