token-stats-timer 1.0.18 → 1.1.2

package/README.en.md

@@ -0,0 +1,149 @@
+# token-stats-timer
+
+> [简体中文](README.md) | English (current)
+
+A modified version of `@liziy/token-stats`.
+
+One extension, one footer — run timing plus token usage/quota monitoring in a single plugin.
+
+## Features
+
+Footer, top line (left-aligned):
+
+```
+↑12k ↓3.4k CH87% ⚡77.7 t/s 5.3%/1.0M | 5h: 87% W: 92% ⏱ 2h 15m
+```
+
+- `prev` / `max` —— duration of the previous run / longest run in this session branch (with a 15-char prompt preview)
+- `↑ ↓ Σ CH` —— cumulative input / output / total / cache hit rate
+- `⚡` —— live speed (2s rolling window; falls back to the average speed while idle)
+- Context usage (style configurable)
+- `5h: W: ⏱` —— quota remaining (built-in plans for MiniMax / GLM / Kimi / DeepSeek / OpenCode Go; enable per provider in `/stats`)
+
+Footer, bottom line: cwd + git branch + statuses from other extensions.
+
+## Per-model thinking level memory (thinking-memory)
+
+No manual setup command: when you **manually switch the thinking level, it is recorded automatically** as the default for the current model, and restored on `session_start` / model switch. Inspired by the per-model preference mechanism of `@tifan/pi-preferred-thinking`, but with your actual switching behavior as the memory source (enabled by default):
+
+- Manually change the thinking level (keybinding / `/thinking` / settings UI) → recorded for the current model
+- `session_start` / `model_select` → the remembered level for that model is applied automatically
+- Level changes caused by the extension's own `setThinkingLevel` or by model-switch clamping (e.g. a model that doesn't support `max`) are never misrecorded
+
+- `/auto-remember-thinking-level` — no arg shows status; `on` / `off` enable or disable (enabled by default)
+
+Config: `~/.pi/agent/extensions/token-stats/auto-remember-thinking-level.json`
+
+```json
+{
+  "enabled": true,
+  "levels": {
+    "opencode-go/deepseek-v4-flash": "max"
+  }
+}
+```
+
+> If the original `@tifan/pi-preferred-thinking` is also installed, its session_start auto-apply overrides this feature and vice versa — install only one of them.
+
+## macOS completion notifications
+
+A system notification is posted when each run (agent task) finishes, distinguishing two outcomes:
+
+- ✅ pi task finished — normal completion (with duration)
+- ⏹ pi aborted — aborted via Esc
+
+A separate 👋 notification on session close (optional).
+
+### Delivery channels (automatic fallback, best available wins)
+
+1. **OSC terminal protocol** — writes an escape sequence to the terminal; the **terminal app itself** shows the notification, so the sender is the terminal (no osascript needed):
+   - **iTerm2 → OSC 9** (`ESC]9;content`, the notification sequence from iTerm2's official docs, **verified working**)
+   - Ghostty / WezTerm / Hyper / rxvt-unicode → OSC 777 (`ESC]777;notify;title;content`)
+   > ⚠️ Note: OSC 777 is silently ignored on iTerm2 3.5.x (supported since 3.6.9). The official pi example (notify.ts) only sends OSC 777, which does nothing on iTerm2 — this plugin selects the sequence per terminal.
+2. **terminal-notifier** — used automatically once `brew install terminal-notifier` is done; most reliable at the system level (`-sender` sets ownership, `-group` dedupes).
+3. **osascript** — last-resort fallback (when no terminal protocol is available).
+
+> Why not pure osascript: since macOS Sequoia, notifications are attributed to the *calling process*. pi is a node process that cannot be authorized in System Settings, so the notification is silently dropped (the script exits 0 but no banner appears). OSC sequences re-attribute the notification to the terminal app, which can be authorized and shows banners normally.
+
+### Configuration
+
+Config file: `~/.pi/agent/extensions/token-stats/notify-config.json` (defaults apply if missing)
+
+```json
+{
+  "enabled": true,
+  "minDurationSec": 0,
+  "sound": "Glass",
+  "onSuccess": true,
+  "onFailure": true,
+  "onAbort": true,
+  "onSessionEnd": true
+}
+```
+
+- `enabled` — master switch (also togglable via `/notify on|off`)
+- `minDurationSec` — skip notifications for runs shorter than this many seconds (e.g. 30 avoids noise from instant replies)
+- `sound` — notification sound (built-in macOS sounds: Glass/Ping/Sosumi/Hero/Funk…; `""` for silent; note only the osascript/terminal-notifier channels support sound — OSC 777 has no sound parameter)
+- `onSuccess/onFailure/onAbort/onSessionEnd` — per-category switches
+
+`/notify` — no arg shows current status; `on`/`off` toggle; `test` immediately sends a test notification to verify the channel.
+
+## Run timing (step-timer)
+
+- While working: the spinner text shows `Working... 01:02` (elapsed time, refreshed every second)
+- On completion: an entry is appended at the end of the session showing the total duration:
+
+  `Total time 01:23`
+
+  Persisted via `appendEntry`, kept out of the LLM context, and still visible after `/resume`.
+
+No separate switch — always on with the package; timing semantics match the run timer (one run = first `agent_start` → `agent_settled`, including retries, compaction recovery and queued prompts).
+
+## Commands
+
+- `/stats` — no arg shows **today's token stats** (same as `/stats day`)
+- `/stats day [YYYY-MM-DD]` / `hour` / `week` / `month [YYYY-MM]` — stats queries
+- `/stats limit` — quota plan config (pick/disable the plan shown for the current provider; picking GLM asks whether to configure team credentials)
+- `/stats config` — display style / display items / quota refresh interval / GLM team credentials
+- `/notify [on|off|test]` — notifications toggle / test (no arg shows status)
+- `/auto-remember-thinking-level [on|off]` — thinking-level memory toggle (no arg shows status)
+
+## GLM Team Plan
+
+Personal and team plans share `GET /api/monitor/usage/quota/limit`; the only difference is the request headers — the team plan requires the `Bigmodel-Organization` / `Bigmodel-Project` headers plus `?type=2` (api_key + organization ID + project ID, all three required; the team tier only exists on the China endpoint `open.bigmodel.cn`).
+
+This plugin uses the team query **only when both the organization ID and the project ID are configured**, otherwise it falls back to the personal query:
+
+- After enabling the GLM plan (`/stats limit` → GLM), a team-credential prompt appears automatically — "✏️ Configure / Edit" or "Skip"
+- Change or clear it any time via `/stats config` → "GLM team credentials"
+- Credentials are stored in the `teamCredential` field of `~/.pi/agent/extensions/token-stats/config.json`:
+
+```json
+{
+  "providerPlans": { "zai-coding-cn": "glm" },
+  "teamCredential": { "organization": "your-org-id", "project": "your-project-id" },
+  "ttl": 60
+}
+```
+
+> Organization ID / Project ID can be found on the "Team Coding Plan" page of the GLM Coding Plan team console; if you already configure them as environment variables for Claude Code / Cursor or similar tools, you can also put the same values into config.json directly.
+
+## OpenCode Go balance
+
+The OpenCode Go subscription (`opencode-go` provider, baseUrl `https://opencode.ai/zen/go/v1`) uses the official quota endpoint `GET /zen/go/v1/usage` (`Authorization: Bearer <key>` — the `key` of `opencode-go` in auth.json or the `OPENCODE_API_KEY` env var), returning the used percentage of three rolling windows: 5 hours / week / month.
+
+The footer shows `5h: X% W: Y% M: Z% ⏱ ...` (remaining = 100 − used); each of the last three items can be toggled via `/stats config` → Display items → "5h quota / Week quota / Month quota / Refresh time".
+
+## Compatibility with the original packages
+
+- Display/quota config reuses `~/.pi/agent/extensions/token-stats/` (existing token-stats config takes effect as-is)
+- Stats logs reuse `~/.pi/agent/extensions/token-stats-logs/` (historical data queryable via `/stats`)
+
+## Installation (replaces the original packages)
+
+```bash
+pi remove npm:@liziy/token-stats
+pi install npm:token-stats-timer
+```
+
+Run `/reload` or restart pi to activate.

package/README.md

@@ -1,5 +1,7 @@
 # token-stats-timer
 
+> [English](README.en.md) | 简体中文（当前）
+
 `@liziy/token-stats` 的修改版本。
 
 一个扩展、一个 footer，同时提供 run 计时与 token 用量/配额监控。
@@ -20,6 +22,31 @@ Footer 上行（左对齐）：
 
 Footer 下行：cwd + git 分支 + 其他扩展状态。
 
+## 按模型自动记忆思考强度（thinking-memory）
+
+不用命令手动设置，**手动切换思考强度时自动记录**为当前模型的默认级别，
+会话启动 / 切换模型时自动恢复。参考 `@tifan/pi-preferred-thinking` 的按模型偏好机制，
+改为以实际切换行为作为记忆来源（默认开启）：
+
+- 手动切换 thinking level（快捷键 / /thinking / 设置界面）→ 自动记录到当前模型
+- `session_start` / `model_select` → 自动应用该模型记忆的级别
+- 自身 `setThinkingLevel` 与模型切换引发的级别变化（如不支持 max 被 clamp）不会误记录
+
+- `/auto-remember-thinking-level` —— 无参查看状态；`on` / `off` 启用或禁用（默认开启）
+
+配置：`~/.pi/agent/extensions/token-stats/auto-remember-thinking-level.json`
+
+```json
+{
+  "enabled": true,
+  "levels": {
+    "opencode-go/deepseek-v4-flash": "max"
+  }
+}
+```
+
+> 若同时安装原 `@tifan/pi-preferred-thinking`，其 session_start 自动应用会与本功能互相覆盖，建议二选一。
+
 ## macOS 完成通知
 
 每次 run（agent 任务）结束后弹系统通知，区分两种结果：
@@ -81,6 +108,7 @@ Footer 下行：cwd + git 分支 + 其他扩展状态。
 - `/stats limit` —— 套餐配置（为当前 provider 选择/关闭配额套餐；选 GLM 后会继续询问是否配置团队套餐凭证）
 - `/stats config` —— 显示样式 / 显示内容 / 配额刷新时间 / GLM 团队凭证
 - `/notify [on|off|test]` —— 通知开关 / 测试（无参查看状态）
+- `/auto-remember-thinking-level [on|off]` —— 自动记忆思考强度开关（无参查看状态）
 
 ## GLM 团队套餐（Team Plan）
 
@@ -88,7 +116,7 @@ Footer 下行：cwd + git 分支 + 其他扩展状态。
 
 本插件在**组织 ID 与项目 ID 都配置**时才走团队查询，否则回退个人版查询：
 
-- 启用 GLM 套餐后（`/stats` 选 GLM）会自动弹出团队凭证配置询问，可「✏️ 配置/修改」或「跳过」
+- 启用 GLM 套餐后（`/stats limit` 选 GLM）会自动弹出团队凭证配置询问，可「✏️ 配置/修改」或「跳过」
 - 随时可通过 `/stats config` → 「GLM 团队凭证」修改或清除
 - 凭证保存在 `~/.pi/agent/extensions/token-stats/config.json` 的 `teamCredential` 字段：
 

package/index.ts

@@ -10,6 +10,9 @@
 // 模块划分：
 //   run-timer.ts   —— run 计时状态机 + session 持久化（原 pi-run-timer）
 //   token-stats.ts —— token 统计 + 套餐配额 + JSONL 日志 + /stats（原 token-stats）
+//   notify.ts      —— macOS 完成通知（成功/失败/中止）
+//   step-timer.ts  —— 任务计时（Working 实时耗时 + 总耗时汇总）
+//   thinking-memory.ts —— 按模型自动记忆思考强度（手动切换时记录，默认开启）
 //
 // 与两个原包的兼容性：
 //   - 配置沿用 ~/.pi/agent/extensions/token-stats/{config.json,display-config.json}
@@ -21,6 +24,8 @@ import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { createTokenStats, formatUserPath, type SharedState } from "./token-stats.ts";
 import { createNotifier } from "./notify.ts";
 import { createStepTimer } from "./step-timer.ts";
+import { createThinkingMemory } from "./thinking-memory.ts";
+import { createUserLanguage } from "./user-language.ts";
 
 const shared: SharedState = {
   sessionActive: false,
@@ -29,10 +34,16 @@ const shared: SharedState = {
 
 export default function runTokenStatsExtension(pi: ExtensionAPI) {
   const stats = createTokenStats(pi, shared);
+
+  // 语言判断最先初始化：其他模块的文案随用户语言切换
+  createUserLanguage(pi);
+
   // macOS 完成通知（成功/失败/中止），配置见 notify-config.json
   createNotifier(pi);
   // 每步耗时：Thinking.../Working... 实时耗时 + 每 turn/总耗时会话摘要
   createStepTimer(pi);
+  // 按模型自动记忆思考强度（/auto-remember-thinking-level），默认开启
+  createThinkingMemory(pi);
 
   pi.on("session_start", (_event, ctx) => {
     shared.sessionActive = true;

package/notify.ts

@@ -28,8 +28,7 @@
 // 便于排查"没弹通知"是触发问题还是投递问题。
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { spawn, spawnSync } from "node:child_process";
-import {
+import { spawn, spawnSync } from "node:child_process";import {
   appendFileSync,
   existsSync,
   mkdirSync,
@@ -38,6 +37,7 @@ import {
 } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { t } from "./user-language.ts";
 
 const CONFIG_DIR = join(homedir(), ".pi/agent/extensions/token-stats");
 const CONFIG_FILE = join(CONFIG_DIR, "notify-config.json");
@@ -238,15 +238,16 @@ export function createNotifier(pi: ExtensionAPI): void {
     if (runAborted) {
       if (config.onAbort) {
         notify(
-          "⏹ pi 已中止",
-          `耗时：${dur}\n${truncate("执行被中止")}`,
+          t("⏹ pi 已中止", "⏹ pi aborted"),
+          t(`耗时：${dur}`, `Duration: ${dur}`) +
+            `\n${truncate(t("执行被中止", "Execution aborted"))}`,
           config.sound,
         );
       }
     } else if (config.onSuccess) {
       notify(
-        "✅ pi 执行完成",
-        `耗时：${dur}`,
+        t("✅ pi 执行完成", "✅ pi task finished"),
+        t(`耗时：${dur}`, `Duration: ${dur}`),
         config.sound,
       );
     }
@@ -258,42 +259,57 @@ export function createNotifier(pi: ExtensionAPI): void {
   // 会话关闭时提示（可选）
   pi.on("session_shutdown", () => {
     if (config.enabled && config.onSessionEnd) {
-      notify("👋 pi 会话结束", "session 已关闭", config.sound);
+      notify(t("👋 pi 会话结束", "👋 pi session ended"), t("session 已关闭", "Session closed"), config.sound);
     }
   });
 
   // ── /notify 命令 ─────────────────────────────────────
   pi.registerCommand("notify", {
-    description: "macOS 完成通知: on | off | status | test（详细配置见 notify-config.json）",
+    description: t(
+      "macOS 完成通知: on | off | status | test（详细配置见 notify-config.json）",
+      "macOS completion notifications: on | off | status | test (see notify-config.json)",
+    ),
     handler: async (args, ctx) => {
       const arg = args.trim();
       if (arg === "on") {
         config = { ...config, enabled: true };
         saveConfig(config);
-        ctx.ui.notify("完成通知已开启", "info");
+        ctx.ui.notify(t("完成通知已开启", "Completion notifications enabled"), "info");
       } else if (arg === "off") {
         config = { ...config, enabled: false };
         saveConfig(config);
-        ctx.ui.notify("完成通知已关闭", "info");
+        ctx.ui.notify(t("完成通知已关闭", "Completion notifications disabled"), "info");
       } else if (arg === "test") {
         // 立即发一条测试通知，验证当前投递通道是否可达
-        const title = "🔔 pi 通知测试";
+        const title = t("🔔 pi 通知测试", "🔔 pi notification test");
         const channel = isITerm2()
-          ? "osc9 终端协议"
+          ? t("osc9 终端协议", "osc9 terminal protocol")
           : supportsOSC777()
-            ? "osc777 终端协议"
+            ? t("osc777 终端协议", "osc777 terminal protocol")
             : existsSync("/opt/homebrew/bin/terminal-notifier") ||
               existsSync("/usr/local/bin/terminal-notifier")
               ? "terminal-notifier"
               : "osascript";
-        notify(title, `投递通道：${channel}\n时间：${new Date().toLocaleTimeString()}`, config.sound);
-        ctx.ui.notify("测试通知已发送，请查看系统通知栏", "info");
+        notify(
+          title,
+          t(`投递通道：${channel}\n时间：${new Date().toLocaleTimeString()}`, 
+            `Channel: ${channel}\nTime: ${new Date().toLocaleTimeString()}`),
+          config.sound,
+        );
+        ctx.ui.notify(t("测试通知已发送，请查看系统通知栏", "Test notification sent, check Notification Center"), "info");
       } else {
-        const sound = config.sound ? `, 声音=${config.sound}` : ", 静音";
+        const sound = config.sound
+          ? t(`, 声音=${config.sound}`, `, sound=${config.sound}`)
+          : t(", 静音", ", silent");
         ctx.ui.notify(
-          `完成通知: ${config.enabled ? "开" : "关"}, 最短时长=${config.minDurationSec}s, ` +
-            `成功=${config.onSuccess ? "开" : "关"}, ` +
-            `中止=${config.onAbort ? "开" : "关"}, 会话结束=${config.onSessionEnd ? "开" : "关"}${sound}`,
+          t(
+            `完成通知: ${config.enabled ? "开" : "关"}, 最短时长=${config.minDurationSec}s, ` +
+              `成功=${config.onSuccess ? "开" : "关"}, ` +
+              `中止=${config.onAbort ? "开" : "关"}, 会话结束=${config.onSessionEnd ? "开" : "关"}${sound}`,
+            `Notifications: ${config.enabled ? "on" : "off"}, min duration=${config.minDurationSec}s, ` +
+              `success=${config.onSuccess ? "on" : "off"}, ` +
+              `abort=${config.onAbort ? "on" : "off"}, session end=${config.onSessionEnd ? "on" : "off"}${sound}`,
+          ),
           "info",
         );
       }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "token-stats-timer",
-  "version": "1.0.18",
-  "description": "pi extension to display token usage and time spend.",
+  "version": "1.1.2",
+  "description": "pi extension to display token usage and time spend. Persist preferred thinking level per model in pi",
   "keywords": [
     "pi-package",
     "pi-extension"
@@ -16,7 +16,10 @@
     "token-stats.ts",
     "notify.ts",
     "step-timer.ts",
-    "README.md"
+    "thinking-memory.ts",
+    "user-language.ts",
+    "README.md",
+    "README.en.md"
   ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -26,6 +29,11 @@
       "./index.ts"
     ]
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/i7guokui/token-stats-timer.git"
+  },
+  "homepage": "https://github.com/i7guokui/token-stats-timer/tree/main#readme",
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",

package/step-timer.ts

@@ -10,6 +10,7 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
+import { t } from "./user-language.ts";
 
 /** 一次 run 的总耗时汇总(appendEntry "timing-final") */
 export interface FinalTimingData {
@@ -95,7 +96,7 @@ export function createStepTimer(pi: ExtensionAPI): void {
   pi.registerEntryRenderer<FinalTimingData>(FINAL_TYPE, (entry, _opts, theme) => {
     const d = entry.data;
     if (!d) return undefined;
-    const title = theme.fg("accent", "总耗时");
+    const title = theme.fg("accent", t("总耗时", "Total time"));
     const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
     box.addChild(new Text(`${title} ${formatDuration(d.totalMs)}`, 0, 0));
     return box;

package/thinking-memory.ts

@@ -0,0 +1,157 @@
+// thinking-memory 模块 —— 按模型自动记忆思考强度
+// =============================================================================
+// 行为（默认开启，/auto-remember-thinking-level on|off 切换）：
+//   - 用户手动切换 thinking level 时，自动记录为当前模型的默认级别
+//   - session_start / model_select 时自动应用该模型记忆的级别
+//   - 扩展自身 setThinkingLevel 与模型切换引起的级别变化不会被误记录
+//
+// 配置：~/.pi/agent/extensions/token-stats/auto-remember-thinking-level.json
+//   {
+//     "enabled": true,
+//     "levels": { "opencode-go/deepseek-v4-flash": "max" }
+//   }
+//
+// 参考 @tifan/pi-preferred-thinking（手动设置命令）改为自动记忆模式：不提供
+// 单独设置命令，以用户的实际切换行为作为记忆来源。
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { t } from "./user-language.ts";
+
+type ThinkingLevel = Parameters<ExtensionAPI["setThinkingLevel"]>[0];
+
+const CONFIG_DIR = join(homedir(), ".pi/agent/extensions/token-stats");
+const CONFIG_FILE = join(CONFIG_DIR, "auto-remember-thinking-level.json");
+
+const VALID_LEVELS = new Set<ThinkingLevel>([
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+]);
+
+interface ThinkingMemoryConfig {
+  enabled: boolean;
+  levels: Record<string, ThinkingLevel>;
+}
+
+const DEFAULT_CONFIG: ThinkingMemoryConfig = { enabled: true, levels: {} };
+
+/** 判定「手动切换」的窗口：距模型切换多少毫秒内的级别变化视为切换引起 */
+const MODEL_SWITCH_WINDOW_MS = 200;
+/** 自身 apply 引起的级别变化要在多少毫秒内匹配上才算（防止残留标志误吞手动切换） */
+const APPLY_WINDOW_MS = 100;
+
+function loadConfig(): ThinkingMemoryConfig {
+  try {
+    if (!existsSync(CONFIG_FILE)) return { ...DEFAULT_CONFIG, levels: {} };
+    const raw = JSON.parse(readFileSync(CONFIG_FILE, "utf-8")) as unknown;
+    const cfg = raw && typeof raw === "object" && !Array.isArray(raw) ? raw as Record<string, unknown> : {};
+    const levels: Record<string, ThinkingLevel> = {};
+    const configured = cfg.levels;
+    if (configured && typeof configured === "object" && !Array.isArray(configured)) {
+      for (const [modelKey, level] of Object.entries(configured)) {
+        if (typeof level === "string" && VALID_LEVELS.has(level as ThinkingLevel)) {
+          levels[modelKey] = level as ThinkingLevel;
+        }
+      }
+    }
+    return { enabled: cfg.enabled !== false, levels };
+  } catch {
+    return { ...DEFAULT_CONFIG, levels: {} };
+  }
+}
+
+function saveConfig(cfg: ThinkingMemoryConfig): void {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+}
+
+export function createThinkingMemory(pi: ExtensionAPI): void {
+  let cfg = loadConfig();
+
+  // 自身 apply 的记录：apply 时间 + 目标级别，事件匹配且窗口内则视为自身引起
+  let lastApply: { at: number; level: ThinkingLevel } | null = null;
+  // 最近一次模型切换时间戳（判断级别变化是否由切模型/clamp 引起）
+  let lastModelSwitchAt = 0;
+
+  /** 应用当前模型的记忆级别（自身 setThinkingLevel 不会触发误记录） */
+  function applyForModel(ctx: ExtensionContext): void {
+    if (!cfg.enabled) return;
+    if (!ctx.model) return;
+    const modelKey = `${ctx.model.provider}/${ctx.model.id}`;
+    const level = cfg.levels[modelKey];
+    if (!level) return;
+    if (pi.getThinkingLevel() === level) return;
+
+    lastApply = { at: Date.now(), level };
+    pi.setThinkingLevel(level);
+  }
+
+  pi.registerCommand("auto-remember-thinking-level", {
+    description: t(
+      "自动记忆思考强度: on | off（无参查看状态）",
+      "Auto-remember thinking level: on | off (no arg shows status)",
+    ),
+    handler: (args, ctx) => {
+      const arg = args.trim();
+      if (arg === "on" || arg === "off") {
+        cfg = { ...cfg, enabled: arg === "on" };
+        saveConfig(cfg);
+        ctx.ui.notify(
+          t(
+            `自动记忆思考强度已${arg === "on" ? "开启" : "关闭"}`,
+            `Auto-remember thinking level ${arg === "on" ? "enabled" : "disabled"}`,
+          ),
+          "info",
+        );
+      } else {
+        ctx.ui.notify(
+          t(
+            `自动记忆思考强度: ${cfg.enabled ? "开" : "关"}`,
+            `Auto-remember thinking level: ${cfg.enabled ? "on" : "off"}`,
+          ),
+          "info",
+        );
+      }
+    },
+  });
+
+  pi.on("session_start", (_event, ctx) => {
+    applyForModel(ctx);
+  });
+
+  pi.on("model_select", (_event, ctx) => {
+    lastModelSwitchAt = Date.now();
+    applyForModel(ctx);
+  });
+
+  pi.on("thinking_level_select", (event, ctx) => {
+    if (!cfg.enabled) return;
+    if (!ctx.model) return;
+    const level = event.level as ThinkingLevel;
+    if (!VALID_LEVELS.has(level)) return;
+
+    // 自身 apply（session_start / model_select 恢复记忆）引起的变化：忽略
+    if (lastApply && Date.now() - lastApply.at < APPLY_WINDOW_MS && level === lastApply.level) {
+      lastApply = null;
+      return;
+    }
+
+    const modelKey = `${ctx.model.provider}/${ctx.model.id}`;
+    // 模型切换时 level 变化先于 model_select 发出，故延迟确认：
+    // 窗口内 lastModelSwitchAt 发生变化（发生了模型切换）则丢弃，防止误记录
+    const switchedAtSnapshot = lastModelSwitchAt;
+    setTimeout(() => {
+      if (lastModelSwitchAt !== switchedAtSnapshot) return;
+      if (cfg.levels[modelKey] === level) return;
+      cfg = { ...cfg, levels: { ...cfg.levels, [modelKey]: level } };
+      saveConfig(cfg);
+    }, MODEL_SWITCH_WINDOW_MS);
+  });
+}

package/token-stats.ts

@@ -26,6 +26,7 @@ import {
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { existsSync, readFileSync } from "node:fs";
+import { t } from "./user-language.ts";
 
 // ── 共享状态（由 index.ts 注入，footer 渲染与模块解耦）──
 
@@ -301,7 +302,7 @@ interface ModelAgg {
 
 /** 按模型生成 markdown 用量表（模型行按总token降序，末尾合计） */
 function renderModelBreakdown(records: RawRecord[]): string[] {
-  if (records.length === 0) return ["", "> 按模型：该范围暂无明细数据"];
+  if (records.length === 0) return ["", t("> 按模型：该范围暂无明细数据", "> By model: no detail data in this range")];
 
   const byModel = new Map<string, ModelAgg>();
   for (const r of records) {
@@ -357,14 +358,14 @@ function renderModelBreakdown(records: RawRecord[]): string[] {
 
   return [
     "",
-    "**按模型**",
+    "**" + t("按模型", "By model") + "**",
     ...renderTable(
-      ["模型", "次数", "新增输入", "缓存输入", "输出", "总token", "命中率", "速率"],
+      [t("模型", "Model"), t("次数", "Count"), t("新增输入", "New input"), t("缓存输入", "Cached input"), t("输出", "Output"), t("总token", "Total tokens"), t("命中率", "Hit rate"), t("速率", "Speed")],
       body,
       {
         aligns: ["left", "right", "right", "right", "right", "right", "right", "right"],
         totalRow: [
-          "合计",
+          t("合计", "Total"),
           String(total.count),
           formatTokens(total.input),
           formatTokens(total.cacheRead),
@@ -486,7 +487,7 @@ const BUILTIN_PLANS: TokenPlan[] = [
       });
       const data = await r.json();
       if (data.base_resp?.status_code === 0) return data;
-      throw new Error(data.base_resp?.status_msg || "MiniMax 返回错误");
+      throw new Error(data.base_resp?.status_msg || t("MiniMax 返回错误", "MiniMax returned an error"));
     },
     format: (data: any) => {
       const models = data.model_remains || [];
@@ -536,7 +537,7 @@ const BUILTIN_PLANS: TokenPlan[] = [
         headers,
         signal: AbortSignal.timeout(5000),
       });
-      if (!r.ok) throw new Error("GLM 配额查询 HTTP " + r.status);
+      if (!r.ok) throw new Error(t("GLM 配额查询 HTTP " + r.status, "GLM quota query HTTP " + r.status));
       return await r.json();
     },
     format: (data: any) => {
@@ -607,7 +608,7 @@ const BUILTIN_PLANS: TokenPlan[] = [
         headers: { Authorization: "Bearer " + key, "Content-Type": "application/json" },
         signal: AbortSignal.timeout(5000),
       });
-      if (!r.ok) throw new Error("Kimi 配额查询 HTTP " + r.status);
+      if (!r.ok) throw new Error(t("Kimi 配额查询 HTTP " + r.status, "Kimi quota query HTTP " + r.status));
       return await r.json();
     },
     format: (data: any) => {
@@ -658,7 +659,7 @@ const BUILTIN_PLANS: TokenPlan[] = [
         headers: { Authorization: "Bearer " + key, "Content-Type": "application/json" },
         signal: AbortSignal.timeout(5000),
       });
-      if (!r.ok) throw new Error("DeepSeek 配额查询 HTTP " + r.status);
+      if (!r.ok) throw new Error(t("DeepSeek 配额查询 HTTP " + r.status, "DeepSeek quota query HTTP " + r.status));
       return await r.json();
     },
     format: (data: any) => {
@@ -690,7 +691,7 @@ const BUILTIN_PLANS: TokenPlan[] = [
         },
         signal: AbortSignal.timeout(5000),
       });
-      if (!r.ok) throw new Error("OpenCode Go 配额查询 HTTP " + r.status);
+      if (!r.ok) throw new Error(t("OpenCode Go 配额查询 HTTP " + r.status, "OpenCode Go quota query HTTP " + r.status));
       return await r.json();
     },
     format: (data: any) => {
@@ -1383,19 +1384,22 @@ export function createTokenStats(
    * 把 quotaState.error 格式化为人类可读提示。
    */
   function formatQuotaError(state: QuotaDisplayState | null | undefined): string {
-    if (!state || !state.error) return "未知错误";
+    if (!state || !state.error) return t("未知错误", "Unknown error");
     const e = state.error;
     switch (e.kind) {
       case "no_plan":
-        return "该 provider 未配置套餐";
+        return t("该 provider 未配置套餐", "No quota plan configured for this provider");
       case "key_missing":
-        return `未设置环境变量 ${e.envVar} 或 ~/.pi/agent/auth.json 中 ${e.provider} 的 key 字段`;
+        return t(
+          `未设置环境变量 ${e.envVar} 或 ~/.pi/agent/auth.json 中 ${e.provider} 的 key 字段`,
+          `Missing env var ${e.envVar} or key field for ${e.provider} in ~/.pi/agent/auth.json`,
+        );
       case "api_error":
-        return `API 返回错误: ${e.message}`;
+        return `API ${t("返回错误", "error")}: ${e.message}`;
       case "network_error":
-        return `网络/超时: ${e.message}`;
+        return `${t("网络/超时", "Network timeout")}: ${e.message}`;
       case "no_data":
-        return "接口返回无数据";
+        return t("接口返回无数据", "API returned no data");
     }
   }
 
@@ -1501,16 +1505,22 @@ export function createTokenStats(
     const curLabel =
       cur?.organization && cur?.project
         ? `${cur.organization} / ${cur.project}`
-        : "未配置（按个人版查询）";
+        : t("未配置（按个人版查询）", "not configured (personal query)");
+    const prompts = [t("✏️ 配置/修改", "✏️ Configure / Edit"), t("跳过", "Skip")];
     const choice = await ctx.ui.select(
-      `GLM 团队套餐凭证？当前：${curLabel}\n填写组织 ID + 项目 ID（二者齐全才走团队查询 ?type=2），跳过则维持个人版查询`,
-      ["✏️ 配置/修改", "跳过"],
+      t(
+        `GLM 团队套餐凭证？当前：${curLabel}\n填写组织 ID + 项目 ID（二者齐全才走团队查询 ?type=2），跳过则维持个人版查询`,
+        `GLM team plan credentials? Current: ${curLabel}\nEnter organization ID + project ID (team query ?type=2 needs both), skip to keep personal query`,
+      ),
+      prompts,
     );
-    if (!choice || choice === "跳过") {
+    if (!choice || choice === prompts[1]) {
       await forceRefreshQuota(ctx);
       const errMsg = quotaState?.error ? formatQuotaError(quotaState) : "";
       ctx.ui.notify(
-        quotaState?.error ? `GLM 配额查询失败：${errMsg}` : "GLM 配额已启用（个人版查询）",
+        quotaState?.error
+          ? t(`GLM 配额查询失败：${errMsg}`, `GLM quota query failed: ${errMsg}`)
+          : t("GLM 配额已启用（个人版查询）", "GLM quota enabled (personal query)"),
         "info",
       );
       return;
@@ -1521,7 +1531,7 @@ export function createTokenStats(
     const org = organization?.trim() ?? "";
     const proj = project?.trim() ?? "";
     if (!org || !proj) {
-      ctx.ui.notify("组织/项目 ID 不能为空，团队凭证未保存", "warning");
+      ctx.ui.notify(t("组织/项目 ID 不能为空，团队凭证未保存", "Organization/Project ID cannot be empty, credentials not saved"), "warning");
       return;
     }
 
@@ -1534,7 +1544,9 @@ export function createTokenStats(
     await forceRefreshQuota(ctx);
     const errMsg = quotaState?.error ? formatQuotaError(quotaState) : "";
     ctx.ui.notify(
-      quotaState?.error ? `GLM 团队配额查询失败：${errMsg}` : "GLM 团队套餐配额已启用",
+      quotaState?.error
+        ? t(`GLM 团队配额查询失败：${errMsg}`, `GLM team quota query failed: ${errMsg}`)
+        : t("GLM 团队套餐配额已启用", "GLM team quota enabled"),
       "info",
     );
   }
@@ -1563,15 +1575,15 @@ export function createTokenStats(
     const cacheHitRate = weightedCacheHitRate(d);
 
     return renderTable(
-      ["指标", "数值"],
+      [t("指标", "Metric"), t("数值", "Value")],
       [
-        ["对话次数", String(d.count)],
-        ["新增输入", `${formatTokens(d.sumInput)}（平均 ${formatTokens(avgInput)}/次，未命中缓存）`],
-        ["缓存输入", formatTokens(d.sumCacheRead)],
-        ["总输出", `${formatTokens(d.sumOutput)}（平均 ${formatTokens(avgOutput)}/次）`],
-        ["总token", `${formatTokens(totalPrompt)}（新增 + 缓存）`],
-        ["缓存命中率", `${cacheHitRate.toFixed(1)}%`],
-        ["平均速率", `${(d.sumTokensPerSec / d.count).toFixed(1)} t/s`],
+        [t("对话次数", "Sessions"), String(d.count)],
+        [t("新增输入", "New input"), `${formatTokens(d.sumInput)}（${t("平均", "avg")} ${formatTokens(avgInput)}/次，${t("未命中缓存", "uncached")}）`],
+        [t("缓存输入", "Cached input"), formatTokens(d.sumCacheRead)],
+        [t("总输出", "Total output"), `${formatTokens(d.sumOutput)}（${t("平均", "avg")} ${formatTokens(avgOutput)}/次）`],
+        [t("总token", "Total tokens"), `${formatTokens(totalPrompt)}（${t("新增 + 缓存", "new + cached")}）`],
+        [t("缓存命中率", "Cache hit rate"), `${cacheHitRate.toFixed(1)}%`],
+        [t("平均速率", "Avg speed"), `${(d.sumTokensPerSec / d.count).toFixed(1)} t/s`],
       ],
     );
   }
@@ -1602,13 +1614,13 @@ export function createTokenStats(
     const daily = records.find((r) => r.date === date) || null;
 
     if (!daily) {
-      ctx.ui.notify(`${date} 暂无统计数据`, "info");
+      ctx.ui.notify(t(`${date} 暂无统计数据`, `No stats for ${date}`), "info");
       return;
     }
 
     await showStats(
       [...renderDaySummary(daily), ...renderModelBreakdown(await readRawRecordsForDates([date]))],
-      `Token 统计  |  ${date}`,
+      t(`Token 统计  |  ${date}`, `Token stats  |  ${date}`),
       ctx,
     );
   }
@@ -1625,14 +1637,14 @@ export function createTokenStats(
     }
 
     if (records.length === 0) {
-      ctx.ui.notify(`${date} 暂无按小时统计`, "info");
+      ctx.ui.notify(t(`${date} 暂无按小时统计`, `No hourly stats for ${date}`), "info");
       return;
     }
 
     records.sort((a, b) => a.hour - b.hour);
 
     const lines = renderTable(
-      ["时间", "次数", "新增输入", "缓存输入", "输出", "总token", "命中率", "速率"],
+      [t("时间", "Time"), t("次数", "Count"), t("新增输入", "New input"), t("缓存输入", "Cached input"), t("输出", "Output"), t("总token", "Total tokens"), t("命中率", "Hit rate"), t("速率", "Speed")],
       records.map((r) => {
         const totalPrompt = r.sumInput + r.sumCacheRead + r.sumCacheWrite;
         return [
@@ -1674,12 +1686,12 @@ export function createTokenStats(
       .sort((a, b) => a.date.localeCompare(b.date));
 
     if (weekRecords.length === 0) {
-      ctx.ui.notify("本周暂无统计数据", "info");
+      ctx.ui.notify(t("本周暂无统计数据", "No stats for this week"), "info");
       return;
     }
 
     const lines = renderTable(
-      ["日期", "次数", "新增输入", "缓存输入", "输出", "总token", "命中率", "速率"],
+      [t("日期", "Date"), t("次数", "Count"), t("新增输入", "New input"), t("缓存输入", "Cached input"), t("输出", "Output"), t("总token", "Total tokens"), t("命中率", "Hit rate"), t("速率", "Speed")],
       weekRecords.map((r) => {
         const totalPrompt = r.sumInput + r.sumCacheRead + r.sumCacheWrite;
         return [
@@ -1700,7 +1712,7 @@ export function createTokenStats(
 
     await showStats(
       [...lines, ...renderModelBreakdown(await readRawRecordsInRange(sevenDaysAgo, today))],
-      "本周每天汇总",
+      t("本周每天汇总", "Week summary by day"),
       ctx,
     );
   }
@@ -1726,7 +1738,7 @@ export function createTokenStats(
       .sort((a, b) => a.date.localeCompare(b.date));
 
     if (monthRecords.length === 0) {
-      ctx.ui.notify(`${month} 暂无统计数据`, "info");
+      ctx.ui.notify(t(`${month} 暂无统计数据`, `No stats for ${month}`), "info");
       return;
     }
 
@@ -1747,7 +1759,7 @@ export function createTokenStats(
     const cacheHitRate = weightedCacheHitRate(total);
 
     const lines = renderTable(
-      ["日期", "次数", "新增输入", "缓存输入", "输出", "总token", "命中率", "速率"],
+      [t("日期", "Date"), t("次数", "Count"), t("新增输入", "New input"), t("缓存输入", "Cached input"), t("输出", "Output"), t("总token", "Total tokens"), t("命中率", "Hit rate"), t("速率", "Speed")],
       monthRecords.map((r) => {
         const tp = r.sumInput + r.sumCacheRead + r.sumCacheWrite;
         return [
@@ -1764,7 +1776,7 @@ export function createTokenStats(
       {
         aligns: ["left", "right", "right", "right", "right", "right", "right", "right"],
         totalRow: [
-          "合计",
+          t("合计", "Total"),
           String(total.count),
           formatTokens(total.sumInput),
           formatTokens(total.sumCacheRead),
@@ -2007,7 +2019,10 @@ export function createTokenStats(
   // ── /stats 命令 ─────────────────────────────────────
 
   pi.registerCommand("stats", {
-    description: "Token 统计 (day | hour | week | month | config | limit)  无参默认显示当天统计；limit 进入套餐配置",
+    description: t(
+      "Token 统计 (day | hour | week | month | config | limit)  无参默认显示当天统计；limit 进入套餐配置",
+      "Token stats (day | hour | week | month | config | limit)  No arg shows today; limit enters quota plan config",
+    ),
     handler: async (args, ctx) => {
       const arg = args.trim();
 
@@ -2021,19 +2036,19 @@ export function createTokenStats(
       if (arg === "limit") {
         const provider = ctx.model?.provider;
         if (!provider) {
-          ctx.ui.notify("无法获取当前供应商，请先切换对话", "warning");
+          ctx.ui.notify(t("无法获取当前供应商，请先切换对话", "Cannot get current provider, switch conversation first"), "warning");
           return;
         }
         // 套餐用量选择菜单
-        const options = ["关闭", ...BUILTIN_PLANS.map(p => p.name)];
+        const options = [t("关闭", "Off"), ...BUILTIN_PLANS.map(p => p.name)];
         const choice = await ctx.ui.select(
-          "选择 " + provider + " 要显示配额的套餐（选中后退出）",
+          t("选择 " + provider + " 要显示配额的套餐（选中后退出）", "Select quota plan to show for " + provider + " (select to exit)"),
           options,
         );
 
         const defaults: TokenConfig = { providerPlans: {}, ttl: 60 };
 
-        if (!choice || choice === "关闭") {
+        if (!choice || choice === options[0]) {
           tokenConfig = tokenConfig
             ? { ...tokenConfig, providerPlans: { ...tokenConfig.providerPlans, [provider]: null } }
             : { ...defaults, providerPlans: { [provider]: null } };
@@ -2049,7 +2064,7 @@ export function createTokenStats(
             shared.requestRender?.();
           }, (tokenConfig?.ttl || 60) * 1000);
           shared.requestRender?.();
-          ctx.ui.notify(provider + " 的套餐用量已关闭", "info");
+          ctx.ui.notify(t(provider + " 的套餐用量已关闭", "Quota display for " + provider + " is off"), "info");
           return;
         }
         const plan = BUILTIN_PLANS.find(p => p.name === choice);
@@ -2077,50 +2092,52 @@ export function createTokenStats(
           if (quotaState?.error) {
             // 仅当 quotaState 带有 error 字段时（key 缺失 / API 错误 / 网络错误 / 无数据）才提示"查询失败"
             const errMsg = formatQuotaError(quotaState);
-            ctx.ui.notify(`${plan.name} 配额查询失败：${errMsg}`, "info");
+            ctx.ui.notify(t(`${plan.name} 配额查询失败：${errMsg}`, `${plan.name} quota query failed: ${errMsg}`), "info");
           } else {
-            ctx.ui.notify(plan.name + " 配额已启用", "info");
+            ctx.ui.notify(t(plan.name + " 配额已启用", plan.name + " quota enabled"), "info");
           }
         }
         return;
       }
 
       if (arg === "config") {
-        const subChoice = await ctx.ui.select("配置", [
-          "显示样式",
-          "显示内容",
-          "刷新时间  (当前 " + (tokenConfig?.ttl || 60) + "s)",
-          "GLM 团队凭证",
-        ]);
+        const cfgOpts = [
+          t("显示样式", "Display style"),
+          t("显示内容", "Display items"),
+          t(`刷新时间  (当前 ${tokenConfig?.ttl || 60}s)`, `Refresh interval (current ${tokenConfig?.ttl || 60}s)`),
+          t("GLM 团队凭证", "GLM team credentials"),
+        ];
+        const subChoice = await ctx.ui.select(t("配置", "Settings"), cfgOpts);
         if (!subChoice) return;
 
-        if (subChoice === "GLM 团队凭证") {
+        if (subChoice === cfgOpts[3]) {
           const cur = tokenConfig?.teamCredential;
           const label =
             cur?.organization && cur?.project
               ? `${cur.organization} / ${cur.project}`
-              : "未配置";
-          const action = await ctx.ui.select("GLM 团队凭证（当前: " + label + "）", [
-            "✏️ 配置/修改",
-            "清除",
-            "返回",
-          ]);
-          if (!action || action === "返回") return;
-          if (action === "清除") {
+              : t("未配置", "not configured");
+          const actions = [
+            t("✏️ 配置/修改", "✏️ Configure / Edit"),
+            t("清除", "Clear"),
+            t("返回", "Back"),
+          ];
+          const action = await ctx.ui.select(t("GLM 团队凭证（当前: " + label + "）", "GLM team credentials (current: " + label + ")"), actions);
+          if (!action || action === actions[2]) return;
+          if (action === actions[1]) {
             tokenConfig = {
               ...baseTokenConfig(),
               teamCredential: { organization: "", project: "" },
             };
             await saveTokenConfig(tokenConfig);
             await forceRefreshQuota(ctx);
-            ctx.ui.notify("GLM 团队凭证已清除（恢复个人版查询）", "info");
+            ctx.ui.notify(t("GLM 团队凭证已清除（恢复个人版查询）", "GLM team credentials cleared (back to personal query)"), "info");
           } else {
             const organization = await ctx.ui.input("组织 ID (Organization)", cur?.organization ?? "");
             const project = await ctx.ui.input("项目 ID (Project)", cur?.project ?? "");
             const org = organization?.trim() ?? "";
             const proj = project?.trim() ?? "";
             if (!org || !proj) {
-              ctx.ui.notify("组织/项目 ID 不能为空，未保存", "warning");
+              ctx.ui.notify(t("组织/项目 ID 不能为空，未保存", "Organization/Project ID cannot be empty, not saved"), "warning");
               return;
             }
             tokenConfig = {
@@ -2131,22 +2148,20 @@ export function createTokenStats(
             await forceRefreshQuota(ctx);
             const errMsg = quotaState?.error ? formatQuotaError(quotaState) : "";
             if (quotaState?.error) {
-              ctx.ui.notify(`GLM 团队配额查询失败：${errMsg}`, "info");
+              ctx.ui.notify(t(`GLM 团队配额查询失败：${errMsg}`, `GLM team quota query failed: ${errMsg}`), "info");
             } else {
-              ctx.ui.notify("GLM 团队凭证已保存（团队查询已生效）", "info");
+              ctx.ui.notify(t("GLM 团队凭证已保存（团队查询已生效）", "GLM team credentials saved (team query active)"), "info");
             }
           }
           return;
         }
 
-        if (subChoice === "显示样式") {
-          const catChoice = await ctx.ui.select("选择要配置的样式类别", [
-            "上下文样式",
-            "⚡ 速率样式",
-          ]);
+        if (subChoice === cfgOpts[0]) {
+          const catOpts = [t("上下文样式", "Context style"), t("⚡ 速率样式", "⚡ Speed style")];
+          const catChoice = await ctx.ui.select(t("选择要配置的样式类别", "Select style category to configure"), catOpts);
           if (!catChoice) return;
 
-          if (catChoice === "上下文样式") {
+          if (catChoice === catOpts[0]) {
             const items: { label: string; value: ContextStyle; preview: string }[] = [
               { label: "pct-window", value: "pct-window", preview: `5.3%/1.0M` },
               { label: "used-window", value: "used-window", preview: `256k/1.0M` },
@@ -2155,7 +2170,7 @@ export function createTokenStats(
               { label: "bar", value: "bar", preview: `[██░░░░░░] 25%` },
             ];
             const choice = await ctx.ui.select(
-              "上下文样式（当前: " + displayConfig.contextStyle + "）",
+              t("上下文样式（当前: " + displayConfig.contextStyle + "）", "Context style (current: " + displayConfig.contextStyle + ")"),
               items.map(i =>
                 (displayConfig.contextStyle === i.value ? "● " : "○ ") + i.label + "  " + i.preview
               ),
@@ -2175,10 +2190,10 @@ export function createTokenStats(
               { label: "t/s", value: "t/s", preview: `⚡77.7 t/s` },
               { label: "tok/s", value: "tok/s", preview: `⚡77.7 tok/s` },
               { label: "T/s", value: "T/s", preview: `⚡77.7 T/s` },
-              { label: "live@速率", value: "liveAt", preview: `⚡1.2k@77.7` },
+              { label: t("live@速率", "live@rate"), value: "liveAt", preview: `⚡1.2k@77.7` },
             ];
             const choice = await ctx.ui.select(
-              "⚡ 速率样式（当前: " + displayConfig.speedStyle + "）",
+              t("⚡ 速率样式（当前: " + displayConfig.speedStyle + "）", "⚡ Speed style (current: " + displayConfig.speedStyle + ")"),
               items.map(i =>
                 (displayConfig.speedStyle === i.value ? "● " : "○ ") + i.label + "  " + i.preview
               ),
@@ -2194,24 +2209,24 @@ export function createTokenStats(
               }
             }
           }
-          ctx.ui.notify("显示样式已保存", "info");
-        } else if (subChoice === "显示内容") {
+          ctx.ui.notify(t("显示样式已保存", "Display style saved"), "info");
+        } else if (subChoice === cfgOpts[1]) {
           const itemLabels: DisplayKey[] = [
             "input", "output", "totalTokens", "cacheHit", "speed", "context",
             "quota5h", "quotaWeek", "quotaMonth", "quotaClock",
           ];
           const itemNames: Record<DisplayKey, string> = {
-            input: "输入", output: "输出", totalTokens: "总token",
-            cacheHit: "缓存命中", speed: "速度", context: "容量",
-            quota5h: "5h额度", quotaWeek: "周额度", quotaMonth: "月额度", quotaClock: "刷新时间",
+            input: t("输入", "Input"), output: t("输出", "Output"), totalTokens: t("总token", "Total tokens"),
+            cacheHit: t("缓存命中", "Cache hit"), speed: t("速度", "Speed"), context: t("容量", "Context"),
+            quota5h: t("5h额度", "5h quota"), quotaWeek: t("周额度", "Week quota"), quotaMonth: t("月额度", "Month quota"), quotaClock: t("刷新时间", "Refresh time"),
           };
           while (true) {
             const options = itemLabels.map(k =>
               `${displayConfig.items[k] ? "✅" : "⬜"} ${itemNames[k]}`,
             );
-            options.push("🔙 完成");
-            const choice = await ctx.ui.select("选择要切换显示的项目", options);
-            if (!choice || choice === "🔙 完成") break;
+            options.push(t("🔙 完成", "🔙 Done"));
+            const choice = await ctx.ui.select(t("选择要切换显示的项目", "Select items to toggle"), options);
+            if (!choice || choice === options[options.length - 1]) break;
             const idx = options.indexOf(choice);
             if (idx >= 0 && idx < itemLabels.length) {
               const key = itemLabels[idx];
@@ -2223,13 +2238,13 @@ export function createTokenStats(
               shared.requestRender?.();
             }
           }
-          ctx.ui.notify("状态栏显示配置已保存", "info");
-        } else if (subChoice === "刷新时间  (当前 " + (tokenConfig?.ttl || 60) + "s)") {
-          const input = await ctx.ui.input("输入刷新间隔（秒）", String(tokenConfig?.ttl || 60));
+          ctx.ui.notify(t("状态栏显示配置已保存", "Status bar display config saved"), "info");
+        } else if (subChoice === cfgOpts[2]) {
+          const input = await ctx.ui.input(t("输入刷新间隔（秒）", "Refresh interval in seconds"), String(tokenConfig?.ttl || 60));
           if (input) {
             const sec = parseInt(input, 10);
             if (Number.isNaN(sec) || sec < 10) {
-              ctx.ui.notify("刷新时间必须 >= 10 秒", "warning");
+              ctx.ui.notify(t("刷新时间必须 >= 10 秒", "Refresh interval must be >= 10s"), "warning");
             } else {
               tokenConfig = tokenConfig
                 ? { ...tokenConfig, ttl: sec }
@@ -2244,7 +2259,7 @@ export function createTokenStats(
                 } catch { /* ctx 已失效（session 被替换），忽略 */ }
                 shared.requestRender?.();
               }, sec * 1000);
-              ctx.ui.notify("刷新时间已设为 " + sec + " 秒", "info");
+              ctx.ui.notify(t("刷新时间已设为 " + sec + " 秒", "Refresh interval set to " + sec + "s"), "info");
             }
           }
         }
@@ -2258,7 +2273,7 @@ export function createTokenStats(
         if (/^\d{4}-\d{2}-\d{2}$/.test(date)) {
           await showDay(date, ctx);
         } else {
-          ctx.ui.notify("用法: /stats day YYYY-MM-DD", "warning");
+          ctx.ui.notify(t("用法: /stats day YYYY-MM-DD", "Usage: /stats day YYYY-MM-DD"), "warning");
         }
       } else if (arg === "hour") {
         await showHourly(getDateStr(), ctx);
@@ -2267,7 +2282,7 @@ export function createTokenStats(
         if (/^\d{4}-\d{2}-\d{2}$/.test(date)) {
           await showHourly(date, ctx);
         } else {
-          ctx.ui.notify("用法: /stats hour YYYY-MM-DD", "warning");
+          ctx.ui.notify(t("用法: /stats hour YYYY-MM-DD", "Usage: /stats hour YYYY-MM-DD"), "warning");
         }
       } else if (arg === "week") {
         await showWeek(ctx);
@@ -2278,11 +2293,11 @@ export function createTokenStats(
         if (/^\d{4}-\d{2}$/.test(ms)) {
           await showMonth(ms, ctx);
         } else {
-          ctx.ui.notify("用法: /stats month YYYY-MM", "warning");
+          ctx.ui.notify(t("用法: /stats month YYYY-MM", "Usage: /stats month YYYY-MM"), "warning");
         }
       } else {
         ctx.ui.notify(
-          "用法: /stats [day [date] | hour [date] | week | month [YYYY-MM] | config]",
+          t("用法: /stats [day [date] | hour [date] | week | month [YYYY-MM] | config]", "Usage: /stats [day [date] | hour [date] | week | month [YYYY-MM] | config]"),
           "warning",
         );
       }

package/user-language.ts

@@ -0,0 +1,85 @@
+// user-language 模块 —— 自动判断用户中英文，输出文案随语言切换
+// =============================================================================
+// pi 没有内置的用户语言信息（无 locale/language API/settings 字段），
+// 采用启发式判断：
+//   1. LANG 环境变量初始化（zh* → 中文，其余 → 英文）
+//   2. 监听 message_start 的 user 消息，滑动窗口（最近 10 条）统计
+//      每条消息的 CJK 汉字占比：≥50% 消息判定为中文 → 总语言切到中文
+// 判错时窗口会随后续消息自动纠偏；样本为零时保持 LANG 初始猜测。
+//
+// 使用：文案处用 t("中文", "English") 取当前语言版本。
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+/** 滑动窗口大小（用户消息条数） */
+const WINDOW_SIZE = 10;
+/** 单条消息汉字占（汉字+英文字母）比例 ≥ 该值时判定为中文 */
+const CJK_RATIO_THRESHOLD = 0.2;
+/** 窗口内中文消息占比 ≥ 50% 时总语言取中文 */
+const ZH_MAJORITY = 0.5;
+
+let current: "zh" | "en" = "en";
+let samples: ("zh" | "en")[] = [];
+
+/** LANG 环境变量初始猜测：zh_* → 中文，其余 → 英文 */
+function guessFromLang(): "zh" | "en" {
+  const lang = (process.env.LANG || "").trim();
+  return /^zh/i.test(lang) ? "zh" : "en";
+}
+
+/**
+ * 单条文本的语言判定：按 CJK 汉字与英文字母的相对占比。
+ * 无有效特征（空/纯数字/纯标点/纯符号）时返回 undefined（不参与统计）。
+ */
+export function detectLanguage(text: string): "zh" | "en" | undefined {
+  const cjk = (text.match(/[\u4e00-\u9fff]/g) ?? []).length;
+  const asciiLetters = (text.match(/[A-Za-z]/g) ?? []).length;
+  const meaningful = cjk + asciiLetters;
+  if (meaningful === 0) return undefined;
+  return cjk / meaningful >= CJK_RATIO_THRESHOLD ? "zh" : "en";
+}
+
+/** 当前推断的用户语言 */
+export function getUserLanguage(): "zh" | "en" {
+  return current;
+}
+
+/** 按当前语言取文案 */
+export function t(zh: string, en: string): string {
+  return current === "zh" ? zh : en;
+}
+
+/** 从 message.content 提取纯文本（兼容 string 与 content 块数组） */
+function contentText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter(
+        (c): c is { type: string; text: string } =>
+          !!c && typeof c === "object" &&
+          (c as { type?: unknown }).type === "text" &&
+          typeof (c as { text?: unknown }).text === "string",
+      )
+      .map((c) => c.text)
+      .join(" ");
+  }
+  return "";
+}
+
+export function createUserLanguage(pi: ExtensionAPI): void {
+  current = guessFromLang();
+  samples = [];
+
+  pi.on("message_start", (event) => {
+    const msg = event.message;
+    if (!msg || msg.role !== "user") return;
+    const lang = detectLanguage(contentText(msg.content));
+    if (!lang) return;
+
+    samples.push(lang);
+    if (samples.length > WINDOW_SIZE) samples.shift();
+
+    const zhCount = samples.filter((s) => s === "zh").length;
+    current = zhCount / samples.length >= ZH_MAJORITY ? "zh" : "en";
+  });
+}