cline-kit 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -4,6 +4,55 @@ 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
+
+- `ckit locales` — lists the interface languages that ship with the kit (code, native name, string
+  count, dictionary version, `*` on the active one) and `ckit locales <code>` switches to one. Language
+  choice used to be reachable only through `ckit config --dictionary=<code>`, which no one finds without
+  reading the middle of the README; the old flag still works and writes the same field.
+- `ckit install` prints the current language and the switch command every time, and the first successful
+  `ckit start` says it once (`hintLanguageShown` in `%APPDATA%\cline-kit\config.json`).
+- `scripts/cli-locale-switch-check.js` — drives the CLI as a subprocess and probes the live DOM, so the
+  check covers the command a user types rather than the internal config write.
+
+### Changed
+
+- `npm test` is 25 checks: the new one asserts every bundled locale appears in `ckit locales`, that
+  `--help` documents each command, and that an unknown code fails instead of storing a broken language.
+
 ## [0.1.1] - 2026-09-20
 
 ### Changed
@@ -60,8 +109,8 @@ First public release. Windows only.
 - `ckit audit` — walks the screens over CDP, filters hidden-but-mounted panels by hit-testing each node,
   and reports only strings the dictionary does not cover.
 - `ckit.cmd` so a release-zip download has an entry point without a global install.
-- CI: `npm test` plus a CLI smoke pass on tag, a portable Windows zip artifact, and npm publish gated on
-  an `NPM_TOKEN` secret.
+- CI: `npm test` plus a CLI smoke pass on tag, a portable Windows zip artifact, and `npm publish` through
+  npm's OIDC trusted publishing - the repository holds no npm credential.
 
 ### Changed
 

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 (简体中文 today; 繁體中文 / 日本語 / 한국어 / Tiếng Việt use the
-same format). 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,13 +82,14 @@ 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                    # 22 checks, no dependencies
+npm test                    # 28 checks, no dependencies
 ```
 
 Then in every case:
 
 ```bash
 ckit doctor                 # confirms the overlay is live inside the running window
+ckit locales                # optional: list / switch the interface language
 ```
 
 `ckit install` locates the Cline shortcut in the Start Menu / Desktop, saves its original target in
@@ -106,11 +108,34 @@ then gives you the enhanced sidebar. If you would rather keep your own launcher,
 | `ckit attach` | Inject once into a Cline you started yourself (`--port=N`), without owning the shortcut |
 | `ckit features` | List feature plugins and whether each is on |
 | `ckit feature enable\|disable <id>` | Toggle a feature (applies within ~4 s, no restart) |
+| `ckit locales` | List the bundled interface languages |
+| `ckit locales <code>` | Switch language — e.g. `ckit locales ja` (applies within ~4 s, no restart) |
 | `ckit install` / `uninstall` | Repoint / restore your Cline shortcut |
 | `ckit update` | Pull the latest locale dictionary from GitHub (`--force` to check now) |
 | `ckit audit` | Walk the UI and list strings still in English |
 | `ckit dict` | Dictionary statistics and the local override path |
-| `ckit config` | Inspect or set `--cline-path`, `--port`, `--auto-update=on\|off` |
+| `ckit config` | Inspect or set `--cline-path`, `--port`, `--auto-update=on\|off`, `--dictionary=<code>` |
+
+### Choosing a language
+
+**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 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 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
 
@@ -123,14 +148,16 @@ then gives you the enhanced sidebar. If you would rather keep your own launcher,
   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. Switch with `ckit config --dictionary=ja`; the change
-  applies to the open window without a reload, and `ckit update` follows the locale you picked.
-  Authoring guide: [`docs/dictionary-pipeline.zh-CN.md`](docs/dictionary-pipeline.zh-CN.md).
+  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
 
@@ -143,6 +170,10 @@ then gives you the enhanced sidebar. If you would rather keep your own launcher,
   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 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,7 +10,8 @@
 在界面上根本不存在。cline-kit 把所有已登记项目常驻列出，样式与原生分组一致，并且可以直接从侧边栏
 切进一个还没有会话的项目。
 
-**附属功能：** 界面语言包（目前简体中文；繁體中文 / 日本語 / 한국어 / Tiếng Việt 用同一套格式）。
+**附属功能：** 界面语言包，随包 5 份：**zh-CN**（基准，逐条对着界面校过）、繁體中文 / 日本語 / 한국어 /
+Tiếng Việt，另加一项 `English` 表示不替换。选择入口在 Cline 里面：设置页会多出一行**界面语言**。
 语言包之所以在这里，是因为同一条注入通道顺带能承载它——它不是这个项目存在的理由。
 
 ## 要解决的问题
@@ -73,13 +74,14 @@ ckit.cmd start
 git clone https://github.com/chentaoxing/Cline-kit.git
 cd cline-kit
 npm install -g .        # 或直接用：node src/cli.js <命令>
-npm test                # 22 项无依赖自检
+npm test                # 28 项无依赖自检
 ```
 
 装完统一确认一次：
 
 ```bash
 ckit doctor             # 直接问运行中的窗口：增强层到底进没进去
+ckit locales            # 可选：看有哪些语言、换语言
 ```
 
 `ckit install` 会在开始菜单 / 桌面找到 Cline 快捷方式，把原始目标备份进 `%APPDATA%\cline-kit\config.json`，
@@ -97,12 +99,32 @@ ckit doctor             # 直接问运行中的窗口：增强层到底进没进
 | `ckit attach` | 往你自己启动、已开调试端口的 Cline 注入一次（`--port=N`），不接管快捷方式 |
 | `ckit features` | 列出功能插件与开关状态 |
 | `ckit feature enable\|disable <id>` | 开关某个插件（约 4 秒生效，无需重启） |
+| `ckit locales` | 列出随包发行的界面语言、字符串数与当前语言 |
+| `ckit locales <语言>` | 切换语言，如 `ckit locales ja`（约 4 秒生效，无需重启） |
 | `ckit install` / `uninstall` | 改写 / 还原 Cline 快捷方式 |
 | `ckit update` | 从 GitHub 拉取最新语言词典（`--force` 立即检查） |
 | `ckit audit` | 走查界面，列出仍是英文的字符串 |
 | `ckit dict` | 词典统计与本地覆盖文件路径 |
 | `ckit config` | 查看或设置 `--cline-path`、`--port`、`--auto-update=on\|off`、`--dictionary=<语言>`、`--hide=<路径>` |
 
+### 选择语言
+
+**在软件里**：点开 Cline 侧边栏底部的齿轮进「设置」，用**界面语言**那一行。它排在「深色模式」下面，
+样式和邻居一致，点完约 4 秒生效——不用重启，选择会记住。列表里的 `English` 表示不替换任何文案。
+
+**在终端里**（改的是同一个设置）：
+
+```bash
+ckit locales          # 看有哪些语言、各覆盖多少条、当前用的是哪一个（* 号标记）
+ckit locales ja       # 切换；正在打开的窗口约 4 秒内跟着变，不用重启
+ckit locales none     # 不再替换 Cline 自己的文案
+```
+
+`ckit install` 每次都会打印当前语言和这条命令，第一次 `ckit start` 成功后也会提示一次。
+`ckit config --dictionary=<语言>` 是等价的底层写法。选定非默认语言后，`ckit update` 热更新的就是那一份。
+
+这一行是本工具加进去的，Cline 原生没有语言设置；不想要就 `ckit feature disable language-picker`。
+
 ## 功能
 
 `ckit features` 看实时列表。
@@ -112,12 +134,14 @@ ckit doctor             # 直接问运行中的窗口：增强层到底进没进
   如果你亲手点了 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 config --dictionary=ja`，正在打开的窗口**不需要重启或刷新**就会跟着变；
-  `ckit update` 也只更新你选的那一份。制作流程见
+  切换：Cline 设置页的「界面语言」，或 `ckit locales ja`，正在打开的窗口**不需要重启或刷新**就会跟着变；
+  `ckit update` 也只更新你选的那一份。详见[选择语言](#选择语言)。制作流程见
   [`docs/dictionary-pipeline.zh-CN.md`](docs/dictionary-pipeline.zh-CN.md)。
 
 ## 已知限制
@@ -129,6 +153,9 @@ ckit doctor             # 直接问运行中的窗口：增强层到底进没进
   得到的是原版界面。
 * **Cline 升级可能失效。** 文案改了，语言包会留英文；侧边栏结构改了，`sidebar-groups` 需要跟进。
   跑一次 `ckit audit` 并开 issue。
+* **语言那一行是本项目加的，不是 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.1",
-  "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

@@ -2,7 +2,7 @@
 "use strict";
 // Cline-kit - desktop enhancement kit for the Cline desktop app.
 // Flagship feature: keep every registered project visible in the sidebar.
-// Optional: UI locale packs (zh-CN today; zh-TW / ja / ko / vi follow the same data format).
+// Optional: UI locale packs (zh-CN reference; zh-TW / ja / ko / vi ship the same key set).
 const cfg = require("./config");
 
 function guard() {
@@ -26,6 +26,7 @@ Usage: ckit <command> [options]
   uninstall        Restore the original shortcuts
   features         List feature plugins and whether each is on
   feature          Toggle a plugin: ckit feature enable|disable <id>
+  locales          List the UI languages that ship with the kit, and switch between them
   update           Fetch the latest locale dictionary from GitHub (skipped when offline)
   audit            Walk the UI and list strings still without a translation
   dict             Dictionary stats and the local override file path
@@ -40,13 +41,20 @@ 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. Choose one: ckit config --dictionary=ja  (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
   ckit install
   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"
 `;
@@ -62,6 +70,33 @@ 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) {
+  if (showOnce) {
+    if (conf.hintLanguageShown) return;
+    conf.hintLanguageShown = true;
+    cfg.write(conf);
+  }
+  const dict = require("./dict");
+  let codes = [];
+  try { codes = dict.choices().map((c) => c.code); } catch (e) { codes = []; }
+  const current = conf.dictionary || "zh-CN";
+  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() {
   guard();
   const argv = process.argv.slice(2);
@@ -80,6 +115,7 @@ async function main() {
     console.log(out.debugPortAlive
       ? `Cline is up (port ${out.port}, path from ${out.source}) and the overlay is loaded.`
       : `Warning: Cline started but port ${out.port} is not answering; the overlay may not be loaded.`);
+    if (out.debugPortAlive) languageTip(conf, true);
     if (!out.debugPortAlive) process.exitCode = 1;
     return;
   }
@@ -136,6 +172,7 @@ async function main() {
     r.shortcuts.forEach((s) => console.log("  " + s));
     console.log("Launcher: " + r.launcher);
     console.log("Open Cline from those shortcuts from now on; `ckit uninstall` restores them.");
+    languageTip(cfg.read(), false);
     return;
   }
 
@@ -192,6 +229,38 @@ async function main() {
     return;
   }
 
+  if (cmd === "locales" || cmd === "locale") {
+    const dict = require("./dict");
+    const conf2 = cfg.read();
+    const choices = dict.choices();
+    const target = argv.slice(1).filter((a) => !a.startsWith("--"))[0];
+    if (target) {
+      if (!dict.isKnown(target)) {
+        console.error(`Unknown locale "${target}". Bundled: ${choices.map((c) => c.code).join(", ")}`);
+        process.exitCode = 1;
+        return;
+      }
+      conf2.dictionary = target;
+      cfg.write(conf2);
+      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 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;
+  }
+
   if (cmd === "dict") {
     console.log(JSON.stringify(require("./payload").info(conf), null, 2));
     console.log("Local override file (highest priority): " + cfg.localDictFile(conf.dictionary));
@@ -207,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/config.js

@@ -73,7 +73,9 @@ const DEFAULTS = {
   shortcutPath: null,
   autostart: false,
   lastUpdateCheck: 0,
-  remoteVersion: null
+  remoteVersion: null,
+  // one-off: `ckit start` points at `ckit locales` the first time it succeeds
+  hintLanguageShown: false
 };
 
 function read() {

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) + ";",