pi-naming 0.5.2 → 0.6.0

package/README.md

@@ -10,11 +10,11 @@ Automatic and manual naming for Pi sessions and terminals.
 pi install npm:pi-naming
 ```
 
-Available through npm after publication. Run `/reload` after installation or configuration changes.
+Available through npm after publication. Run `/reload` after installation.
 
 - **Automatic naming**: the first real user input in a new, unnamed session generates a title in the background and applies it to the allowed session, workspace and tab targets.
 - **`/rename [name]`**: supply an explicit name, or omit it to generate one from user messages on the current branch. Uses the same targets and execution path as automatic naming.
-- **`/config:naming`**: open the normal TUI settings menu; use `reset` to restore defaults.
+- **`/config:naming`**: open the TUI settings panel (Pi's `SettingsList`); toggles switch in place, enums and numbers open a submenu, free text opens a prefilled input. Every change is saved and applied immediately, no `/reload`. Use `reset` to restore defaults.
 - Manual generation considers all user input on the current branch and names the main task. Explicit later corrections or goal changes take precedence; procedural follow-ups such as “continue”, “verify”, or “commit” should not overshadow the topic. Other branches, assistant replies and tool output are excluded. Automatic naming still attempts only once on the first input, not after every turn.
 - Automatic results do not overwrite an existing name. Manual commands supersede pending requests; session switches and reloads discard old results and errors.
 - Each target is independent. Unsupported, disabled, unidentified or failed terminal targets are reported without preventing session naming or other target updates. Non-UI modes receive Pi messages instead of silent failures.

package/README.zh-CN.md

@@ -10,11 +10,11 @@
 pi install npm:pi-naming
 ```
 
-本包发布后可通过 npm 安装。安装或修改配置后执行 `/reload`。
+本包发布后可通过 npm 安装。安装后执行 `/reload`。
 
 - **首条消息自动命名**：新建且未命名的 session 收到首条真实用户输入后，后台生成标题，同步允许修改的 session、workspace 和 tab。
 - **`/rename [名称]`**：显式指定名称，或省略名称、根据当前分支用户消息生成标题。与自动命名使用相同的目标配置和执行逻辑。
-- **`/config:naming`**：打开常规 TUI 配置菜单；输入 `reset` 恢复默认值。
+- **`/config:naming`**：打开 TUI 配置面板（Pi 自带 `SettingsList`）；开关原地切换，枚举与数值回车开二级列表，自由文本回车开预填输入框。改一项立即保存并生效，不需要 `/reload`。输入 `reset` 恢复默认值。
 - 手动生成时综合当前分支的全部用户输入，围绕主要任务命名；后续明确纠正或目标变更优先，“继续”“验证一下”“提交”等流程性跟进不应盖过主题。不会读取其他分支、assistant 回复或工具输出。自动命名仍仅在首条输入时尝试一次，不随每轮对话更新。
 - 不覆盖已有名称的自动命名结果。手动命令优先于尚未完成的旧请求；会话切换或 reload 后丢弃旧结果和错误。
 - 各目标独立执行。终端不支持、被禁用、缺少归属信息或改名失败均明确报告，不阻止 session 和其他可用目标改名。无交互 UI 时通过 Pi 消息报告。

package/SKILL.md

@@ -5,9 +5,9 @@ description: 配置 Pi 统一 /rename、首条消息命名和终端目标归属
 
 # 配置 pi-naming / Configure pi-naming
 
-读取 `<pi-agent-dir>/extensions/pi-naming/config.json`，遵守 `PI_CODING_AGENT_DIR`。使用 `/config:naming` 打开 TUI 配置菜单，输入 `reset` 恢复默认值，保存后 reload。字段和默认值见关联文档和配置示例。
+读取 `<pi-agent-dir>/extensions/pi-naming/config.json`，遵守 `PI_CODING_AGENT_DIR`。使用 `/config:naming` 打开 TUI 配置面板（Pi 自带 SettingsList），输入 `reset` 恢复默认值；面板里改一项立即生效，不需要 reload。字段和默认值见关联文档和配置示例。
 
-Use `/config:naming` to open the normal TUI settings menu; use `reset` for defaults and reload after saving.
+Use `/config:naming` to open the TUI settings panel (Pi's SettingsList); use `reset` for defaults. Changes apply immediately, no reload needed after saving.
 
 - `automaticNaming` / `manualNaming` 控制自动输入和 `/rename [名称]`，`targets` 直接分别控制 session/workspace/tab。Control automatic input and `/rename [name]`; `targets` directly selects session/workspace/tab.
 - `title` 控制长度、语言、补充提示、超时、输出预算和思考档位（`maxTokens` 默认 2048、`effort` 默认 low，二者与 `maxLength` 相互独立）；模型鉴权复用 Pi。Controls length, language, instructions, timeout, output budget and thinking effort (`maxTokens` default 2048, `effort` default low, both independent from `maxLength`); model authentication comes from Pi.

package/locales/index.json

@@ -75,6 +75,14 @@
     "zh-CN": "统一命名 session 与允许修改的终端目标；省略名称时综合当前分支全部用户消息生成",
     "en-US": "Name the session and allowed terminal targets; omit the name to summarize all user messages on the current branch"
   },
+  "namingManualDisabled": {
+    "zh-CN": "手动命名已关闭：用 /config:naming 打开「手动命名」后再试",
+    "en-US": "Manual naming is off: enable it in /config:naming and retry"
+  },
+  "namingNoTargets": {
+    "zh-CN": "没有启用任何命名目标：用 /config:naming 至少打开 session、workspace 或 tab 之一",
+    "en-US": "No naming target is enabled: turn on session, workspace, or tab in /config:naming"
+  },
   "namingFailed": {
     "zh-CN": "命名失败：{error}",
     "en-US": "Naming failed: {error}"
@@ -123,10 +131,6 @@
     "zh-CN": "用法：/config:naming（打开配置菜单）或 /config:naming reset（恢复默认值）",
     "en-US": "Usage: /config:naming (open the settings menu) or /config:naming reset (restore defaults)"
   },
-  "configCommandInput": {
-    "zh-CN": "输入配置值",
-    "en-US": "Enter a configuration value"
-  },
   "configCommandInteractiveOnly": {
     "zh-CN": "命名配置需要在 TUI 中修改；请在交互式 Pi 会话中执行命令。",
     "en-US": "Naming configuration requires the TUI; run this command in an interactive Pi session."
@@ -135,120 +139,124 @@
     "zh-CN": "命名配置",
     "en-US": "Naming settings"
   },
-  "configAutomaticNaming": {
-    "zh-CN": "自动命名：{value}",
-    "en-US": "Automatic naming: {value}"
+  "configOn": {
+    "zh-CN": "开",
+    "en-US": "on"
   },
-  "configManualNaming": {
-    "zh-CN": "手动 /rename：{value}",
-    "en-US": "Manual /rename: {value}"
+  "configOff": {
+    "zh-CN": "关",
+    "en-US": "off"
   },
-  "configSessionTarget": {
-    "zh-CN": "命名 session：{value}",
-    "en-US": "Name session: {value}"
+  "configCommandSaved": {
+    "zh-CN": "命名配置已保存并立即生效：{path}",
+    "en-US": "Naming configuration saved and applied immediately: {path}"
   },
-  "configWorkspaceTarget": {
-    "zh-CN": "命名 workspace：{value}",
-    "en-US": "Name workspace: {value}"
+  "configCommandInvalid": {
+    "zh-CN": "命名配置无效：{error}",
+    "en-US": "Invalid naming configuration: {error}"
   },
-  "configTabTarget": {
-    "zh-CN": "命名 tab：{value}",
-    "en-US": "Name tab: {value}"
+  "panelLabelAutomaticNaming": {
+    "zh-CN": "自动命名",
+    "en-US": "Automatic naming"
   },
-  "configMaxLength": {
-    "zh-CN": "最大标题长度：{value}",
-    "en-US": "Maximum title length: {value}"
+  "panelDescAutomaticNaming": {
+    "zh-CN": "首条用户消息后自动生成并应用会话标题",
+    "en-US": "Generate and apply a session title after the first user message"
   },
-  "configMaxTokens": {
-    "zh-CN": "输出预算：{value} tokens",
-    "en-US": "Output budget: {value} tokens"
+  "panelLabelManualNaming": {
+    "zh-CN": "手动 /rename",
+    "en-US": "Manual /rename"
   },
-  "configEffort": {
-    "zh-CN": "思考档位：{value}",
-    "en-US": "Thinking effort: {value}"
+  "panelDescManualNaming": {
+    "zh-CN": "允许用 /rename 手动命名；省略名称时综合当前分支全部用户消息生成",
+    "en-US": "Allow manual naming through /rename; omitting the name summarizes all user messages on the current branch"
   },
-  "configPreferredLength": {
-    "zh-CN": "首选标题长度：{value}",
-    "en-US": "Preferred title length: {value}"
+  "panelLabelSessionTarget": {
+    "zh-CN": "命名 session",
+    "en-US": "Name session"
   },
-  "configLanguage": {
-    "zh-CN": "标题语言：{value}",
-    "en-US": "Title language: {value}"
+  "panelDescSessionTarget": {
+    "zh-CN": "将生成的标题写入 Pi 会话名",
+    "en-US": "Write the generated title to the Pi session name"
   },
-  "configInstructions": {
-    "zh-CN": "标题提示：{value}",
-    "en-US": "Title instructions: {value}"
+  "panelLabelWorkspaceTarget": {
+    "zh-CN": "命名 workspace",
+    "en-US": "Name workspace"
   },
-  "configTimeout": {
-    "zh-CN": "请求超时：{value} ms",
-    "en-US": "Request timeout: {value} ms"
+  "panelDescWorkspaceTarget": {
+    "zh-CN": "同时修改终端工作区名称（需后端支持且目标独占）",
+    "en-US": "Also rename the terminal workspace (needs backend support and exclusive ownership)"
   },
-  "configOn": {
-    "zh-CN": "开",
-    "en-US": "on"
+  "panelLabelTabTarget": {
+    "zh-CN": "命名 tab",
+    "en-US": "Name tab"
   },
-  "configOff": {
-    "zh-CN": "关",
-    "en-US": "off"
+  "panelDescTabTarget": {
+    "zh-CN": "同时修改终端标签页名称（需后端支持且目标独占）",
+    "en-US": "Also rename the terminal tab (needs backend support and exclusive ownership)"
   },
-  "configEmpty": {
-    "zh-CN": "未设置",
-    "en-US": "not set"
+  "panelLabelMaxLength": {
+    "zh-CN": "最大标题长度",
+    "en-US": "Maximum title length"
   },
-  "configPresetValue": {
-    "zh-CN": "常用值：{value}",
-    "en-US": "Common value: {value}"
+  "panelDescMaxLength": {
+    "zh-CN": "标题允许的最多 Unicode 码点数",
+    "en-US": "Maximum number of Unicode code points allowed in a title"
   },
-  "configCustom": {
-    "zh-CN": "自定义…",
-    "en-US": "Custom…"
+  "panelLabelPreferredLength": {
+    "zh-CN": "首选标题长度",
+    "en-US": "Preferred title length"
   },
-  "configCancel": {
-    "zh-CN": "取消",
-    "en-US": "Cancel"
+  "panelDescPreferredLength": {
+    "zh-CN": "提示模型尽量控制在该长度以内，不得大于最大长度",
+    "en-US": "Ask the model to stay within this length; must not exceed the maximum length"
   },
-  "configDone": {
-    "zh-CN": "完成",
-    "en-US": "Done"
+  "panelLabelLanguage": {
+    "zh-CN": "标题语言",
+    "en-US": "Title language"
   },
-  "configMaxLengthInput": {
-    "zh-CN": "最大标题长度（正整数）",
-    "en-US": "Maximum title length (positive integer)"
+  "panelDescLanguage": {
+    "zh-CN": "auto 表示跟随消息的主要语言",
+    "en-US": "auto follows the dominant language of the messages"
   },
-  "configMaxTokensInput": {
-    "zh-CN": "输出预算（正整数，思考与标题共享）",
-    "en-US": "Output budget (positive integer, shared by thinking and title)"
+  "panelLabelInstructions": {
+    "zh-CN": "标题提示",
+    "en-US": "Title instructions"
   },
-  "configEffortInput": {
-    "zh-CN": "思考档位",
-    "en-US": "Thinking effort"
+  "panelDescInstructions": {
+    "zh-CN": "附加给命名模型的自定义要求，可留空",
+    "en-US": "Extra instructions for the naming model; can be empty"
   },
-  "configEffortInvalid": {
-    "zh-CN": "思考档位无效：{value}；可选值：{options}",
-    "en-US": "Invalid thinking effort: {value}; allowed: {options}"
+  "panelLabelTimeout": {
+    "zh-CN": "请求超时（毫秒）",
+    "en-US": "Request timeout (ms)"
   },
-  "configPreferredLengthInput": {
-    "zh-CN": "首选标题长度（正整数）",
-    "en-US": "Preferred title length (positive integer)"
+  "panelDescTimeout": {
+    "zh-CN": "单次命名模型请求的超时时间",
+    "en-US": "Timeout for one naming model request"
   },
-  "configLanguageInput": {
-    "zh-CN": "标题语言",
-    "en-US": "Title language"
+  "panelLabelMaxTokens": {
+    "zh-CN": "输出预算",
+    "en-US": "Output budget"
   },
-  "configInstructionsInput": {
-    "zh-CN": "标题提示（可留空）",
-    "en-US": "Title instructions (can be empty)"
+  "panelDescMaxTokens": {
+    "zh-CN": "思考与标题共享的输出 token 上限",
+    "en-US": "Output token budget shared by thinking and the title"
   },
-  "configTimeoutInput": {
-    "zh-CN": "请求超时（毫秒，正整数）",
-    "en-US": "Request timeout (positive milliseconds)"
+  "panelLabelEffort": {
+    "zh-CN": "思考档位",
+    "en-US": "Thinking effort"
   },
-  "configCommandSaved": {
-    "zh-CN": "命名配置已保存：{path}。请执行 /reload 使配置生效。",
-    "en-US": "Naming configuration saved to {path}. Run /reload to apply it."
+  "panelDescEffort": {
+    "zh-CN": "命名请求使用的推理强度",
+    "en-US": "Reasoning effort used for naming requests"
   },
-  "configCommandInvalid": {
-    "zh-CN": "命名配置无效：{error}",
-    "en-US": "Invalid naming configuration: {error}"
+  "panelInputPrompt": {
+    "zh-CN": "输入",
+    "en-US": "Input"
+  },
+  "panelValueUnset": {
+    "zh-CN": "未设置",
+    "en-US": "not set"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-naming",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Configurable Pi session naming and manual terminal workspace/tab renaming",
   "type": "module",
   "main": "./index.ts",
@@ -57,19 +57,23 @@
     "workspace"
   ],
   "dependencies": {
-    "pi-extensions-i18n": "^0.8.0",
-    "pi-terminal-mux": "^0.6.5"
+    "pi-extensions-i18n": "^0.9.0",
+    "pi-model-request": "^0.1.1",
+    "pi-terminal-mux": "^0.6.7"
   },
   "peerDependencies": {
+    "@earendil-works/pi-ai": ">=0.80.0",
     "@earendil-works/pi-coding-agent": ">=0.80.0",
-    "@earendil-works/pi-ai": ">=0.80.0"
+    "@earendil-works/pi-tui": ">=0.80.0"
   },
   "devDependencies": {
+    "@earendil-works/pi-ai": "0.85.1",
     "@earendil-works/pi-coding-agent": "0.85.1",
+    "@earendil-works/pi-tui": "0.85.1",
     "@types/node": "24.12.4",
-    "pi-terminal-mux": "^0.6.5",
+    "pi-model-request": "^0.1.1",
+    "pi-terminal-mux": "^0.6.7",
     "tsx": "4.23.1",
-    "typescript": "5.9.3",
-    "@earendil-works/pi-ai": "0.85.1"
+    "typescript": "5.9.3"
   }
 }

package/src/config-panel.ts

@@ -0,0 +1,378 @@
+/**
+ * pi-naming 的 TUI 配置面板。
+ *
+ * 原来用 `ctx.ui.select` 开链式菜单，一行文字里既放当前值又放「按下去会变成什么」，
+ * 屏幕上看不出哪项是状态、哪项是按钮。这里改用 Pi 自带 `SettingsList`：
+ * 左边字段名、右边当前值、选中项下方给一行说明。开关项原地切换，枚举与数值项回车
+ * 打开二级列表，自由文本项回车打开预填当前值的输入框。改一项立即写盘并同步运行期配置，
+ * Esc 关闭，全程不需要 /reload。
+ */
+
+import {
+  getSelectListTheme,
+  getSettingsListTheme,
+  type ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  Container,
+  Input,
+  SelectList,
+  SettingsList,
+  Text,
+  type Component,
+  type SelectItem,
+  type SettingItem,
+} from "@earendil-works/pi-tui";
+import { LANGUAGE_PRESETS, MAX_LENGTH_PRESETS, MAX_TOKENS_PRESETS, PREFERRED_LENGTH_PRESETS, TIMEOUT_PRESETS, TITLE_EFFORT_LEVELS, parseConfig, type NamingConfig } from "./config.ts";
+import { i18n } from "./i18n.ts";
+
+/** 面板字段名；与配置里的字段一一对应，测试用它核对没有字段漏在面板外。 */
+export const PANEL_FIELD = {
+  automaticNaming: "automaticNaming",
+  manualNaming: "manualNaming",
+  sessionTarget: "targets.session",
+  workspaceTarget: "targets.workspace",
+  tabTarget: "targets.tab",
+  maxLength: "title.maxLength",
+  preferredLength: "title.preferredLength",
+  language: "title.language",
+  instructions: "title.instructions",
+  timeoutMs: "title.timeoutMs",
+  maxTokens: "title.maxTokens",
+  effort: "title.effort",
+} as const;
+
+/** 面板字段名的联合类型。 */
+export type PanelFieldId = (typeof PANEL_FIELD)[keyof typeof PANEL_FIELD];
+
+/** 二级列表一项：label 是展示文本，value 是写回配置的值。 */
+export interface PanelOption {
+  /** 展示文本。 */
+  label: string;
+  /** 写回配置的值。 */
+  value: string;
+}
+
+/** 面板一行：字段名、取值方式和文案 key。 */
+interface PanelField {
+  /** 字段名。 */
+  id: PanelFieldId;
+  /** `toggle` 原地切换，`choice` 回车开候选列表，`text` 回车开输入框。 */
+  kind: "toggle" | "choice" | "text";
+  /** 行标题的文案 key。 */
+  labelKey: string;
+  /** 说明行的文案 key。 */
+  descriptionKey: string;
+  /** 候选列表是否需要上方过滤输入框。 */
+  search?: boolean;
+}
+
+/** 语言候选列表最多同时显示几行。 */
+const CHOICE_MENU_MAX_VISIBLE = 8;
+
+/** 开关两个状态在面板上承载的值，与本地化文案无关。 */
+const TOGGLE_ON = "on";
+const TOGGLE_OFF = "off";
+
+/** 面板字段顺序：总开关在最前，其余按「命名目标 → 标题偏好」排列。 */
+const PANEL_FIELDS: readonly PanelField[] = [
+  { id: PANEL_FIELD.automaticNaming, kind: "toggle", labelKey: "panelLabelAutomaticNaming", descriptionKey: "panelDescAutomaticNaming" },
+  { id: PANEL_FIELD.manualNaming, kind: "toggle", labelKey: "panelLabelManualNaming", descriptionKey: "panelDescManualNaming" },
+  { id: PANEL_FIELD.sessionTarget, kind: "toggle", labelKey: "panelLabelSessionTarget", descriptionKey: "panelDescSessionTarget" },
+  { id: PANEL_FIELD.workspaceTarget, kind: "toggle", labelKey: "panelLabelWorkspaceTarget", descriptionKey: "panelDescWorkspaceTarget" },
+  { id: PANEL_FIELD.tabTarget, kind: "toggle", labelKey: "panelLabelTabTarget", descriptionKey: "panelDescTabTarget" },
+  { id: PANEL_FIELD.maxLength, kind: "choice", labelKey: "panelLabelMaxLength", descriptionKey: "panelDescMaxLength" },
+  { id: PANEL_FIELD.preferredLength, kind: "choice", labelKey: "panelLabelPreferredLength", descriptionKey: "panelDescPreferredLength" },
+  { id: PANEL_FIELD.language, kind: "choice", labelKey: "panelLabelLanguage", descriptionKey: "panelDescLanguage" },
+  { id: PANEL_FIELD.instructions, kind: "text", labelKey: "panelLabelInstructions", descriptionKey: "panelDescInstructions" },
+  { id: PANEL_FIELD.timeoutMs, kind: "choice", labelKey: "panelLabelTimeout", descriptionKey: "panelDescTimeout" },
+  { id: PANEL_FIELD.maxTokens, kind: "choice", labelKey: "panelLabelMaxTokens", descriptionKey: "panelDescMaxTokens" },
+  { id: PANEL_FIELD.effort, kind: "choice", labelKey: "panelLabelEffort", descriptionKey: "panelDescEffort" },
+];
+
+/** 面板覆盖的字段名，测试用它证明配置里没有字段被漏下。 */
+export const PANEL_FIELD_IDS: readonly string[] = PANEL_FIELDS.map((field) => field.id);
+
+/** 取本地化的开关文案。 */
+export function toggleLabels(): { on: string; off: string } {
+  return { on: i18n.t("configOn"), off: i18n.t("configOff") };
+}
+
+/** 布尔字段的候选列表。 */
+function toggleOptions(): PanelOption[] {
+  const labels = toggleLabels();
+  return [
+    { label: labels.on, value: TOGGLE_ON },
+    { label: labels.off, value: TOGGLE_OFF },
+  ];
+}
+
+/** 数值字段的候选列表，labels 与值同文本。 */
+function numberOptions(values: readonly string[]): PanelOption[] {
+  return values.map((value) => ({ label: value, value }));
+}
+
+/** 思考档位的候选列表。 */
+function effortOptions(): PanelOption[] {
+  return numberOptions(TITLE_EFFORT_LEVELS);
+}
+
+/**
+ * 语言字段的候选列表。
+ *
+ * 常见语言放在前面，当前值不在列表里时补进去：语言代码是自由字符串，用户可能填
+ * 任意 BCP-47 代码，面板不能因为候选表里没有就把已存值显示成空白。
+ */
+function languageOptions(current: string): PanelOption[] {
+  const values: string[] = [...LANGUAGE_PRESETS];
+  if (!values.includes(current)) values.push(current);
+  return numberOptions(values);
+}
+
+/** 按字段名取候选列表；文本字段没有候选。 */
+function fieldOptions(id: PanelFieldId, config: NamingConfig): PanelOption[] {
+  switch (id) {
+    case PANEL_FIELD.automaticNaming:
+    case PANEL_FIELD.manualNaming:
+    case PANEL_FIELD.sessionTarget:
+    case PANEL_FIELD.workspaceTarget:
+    case PANEL_FIELD.tabTarget:
+      return toggleOptions();
+    case PANEL_FIELD.maxLength:
+      return numberOptions(MAX_LENGTH_PRESETS);
+    case PANEL_FIELD.preferredLength:
+      return numberOptions(PREFERRED_LENGTH_PRESETS);
+    case PANEL_FIELD.language:
+      return languageOptions(config.title.language);
+    case PANEL_FIELD.timeoutMs:
+      return numberOptions(TIMEOUT_PRESETS);
+    case PANEL_FIELD.maxTokens:
+      return numberOptions(MAX_TOKENS_PRESETS);
+    case PANEL_FIELD.effort:
+      return effortOptions();
+    default:
+      return [];
+  }
+}
+
+/** 按配置值取展示文本；不在候选表里就直接显示原值。 */
+export function optionLabelForValue(options: readonly PanelOption[], value: string): string {
+  return options.find((option) => option.value === value)?.label ?? value;
+}
+
+/** 按展示文本反查写回值；找不到说明候选表变了，返回 undefined 由调用方保持不变。 */
+export function optionValueFromLabel(
+  options: readonly PanelOption[],
+  label: string,
+): string | undefined {
+  return options.find((option) => option.label === label)?.value;
+}
+
+/** 读取一个字段当前存的值，统一转成面板上承载的字符串。 */
+function readField(config: NamingConfig, id: PanelFieldId): string {
+  switch (id) {
+    case PANEL_FIELD.automaticNaming:
+      return config.automaticNaming ? TOGGLE_ON : TOGGLE_OFF;
+    case PANEL_FIELD.manualNaming:
+      return config.manualNaming ? TOGGLE_ON : TOGGLE_OFF;
+    case PANEL_FIELD.sessionTarget:
+      return config.targets.session ? TOGGLE_ON : TOGGLE_OFF;
+    case PANEL_FIELD.workspaceTarget:
+      return config.targets.workspace ? TOGGLE_ON : TOGGLE_OFF;
+    case PANEL_FIELD.tabTarget:
+      return config.targets.tab ? TOGGLE_ON : TOGGLE_OFF;
+    case PANEL_FIELD.maxLength:
+      return String(config.title.maxLength);
+    case PANEL_FIELD.preferredLength:
+      return String(config.title.preferredLength);
+    case PANEL_FIELD.language:
+      return config.title.language;
+    case PANEL_FIELD.instructions:
+      return config.title.instructions;
+    case PANEL_FIELD.timeoutMs:
+      return String(config.title.timeoutMs);
+    case PANEL_FIELD.maxTokens:
+      return String(config.title.maxTokens);
+    case PANEL_FIELD.effort:
+      return config.title.effort;
+  }
+}
+
+/** 用新值重建配置；文本字段原样写入，数值字段转成数字。 */
+function writeField(config: NamingConfig, id: PanelFieldId, value: string): NamingConfig {
+  const title = { ...config.title };
+  switch (id) {
+    case PANEL_FIELD.automaticNaming:
+      return { ...config, automaticNaming: value === TOGGLE_ON };
+    case PANEL_FIELD.manualNaming:
+      return { ...config, manualNaming: value === TOGGLE_ON };
+    case PANEL_FIELD.sessionTarget:
+      return { ...config, targets: { ...config.targets, session: value === TOGGLE_ON } };
+    case PANEL_FIELD.workspaceTarget:
+      return { ...config, targets: { ...config.targets, workspace: value === TOGGLE_ON } };
+    case PANEL_FIELD.tabTarget:
+      return { ...config, targets: { ...config.targets, tab: value === TOGGLE_ON } };
+    case PANEL_FIELD.maxLength:
+      return { ...config, title: { ...title, maxLength: Number(value) } };
+    case PANEL_FIELD.preferredLength:
+      return { ...config, title: { ...title, preferredLength: Number(value) } };
+    case PANEL_FIELD.language:
+      return { ...config, title: { ...title, language: value } };
+    case PANEL_FIELD.instructions:
+      return { ...config, title: { ...title, instructions: value } };
+    case PANEL_FIELD.timeoutMs:
+      return { ...config, title: { ...title, timeoutMs: Number(value) } };
+    case PANEL_FIELD.maxTokens:
+      return { ...config, title: { ...title, maxTokens: Number(value) } };
+    case PANEL_FIELD.effort:
+      return { ...config, title: { ...title, effort: value as NamingConfig["title"]["effort"] } };
+  }
+}
+
+/** 把候选列表转成 `SelectList` 的条目；展示文本同时是回传值。 */
+function toSelectItems(options: readonly PanelOption[]): SelectItem[] {
+  return options.map((option) => ({ value: option.label, label: option.label }));
+}
+
+/** 按展示文本建二级选择列表：Enter 选定并回传，Esc 不改动直接返回。 */
+function createChoiceSubmenu(
+  options: readonly PanelOption[],
+  currentLabel: string,
+  done: (selectedLabel?: string) => void,
+): Component {
+  const items = toSelectItems(options);
+  const selectList = new SelectList(
+    items,
+    Math.max(1, Math.min(items.length, CHOICE_MENU_MAX_VISIBLE)),
+    getSelectListTheme(),
+  );
+  const index = options.findIndex((option) => option.label === currentLabel);
+  if (index >= 0) selectList.setSelectedIndex(index);
+  selectList.onSelect = (item) => done(item.value);
+  selectList.onCancel = () => done(undefined);
+  return selectList;
+}
+
+/** 自由文本二级菜单：预填当前值的 `Input`。 */
+function createTextSubmenu(
+  value: string,
+  placeholder: string,
+  done: (value?: string) => void,
+): Component {
+  const input = new Input({ prompt: `${i18n.t("panelInputPrompt")} `, placeholder });
+  input.setValue(value);
+  input.focused = true;
+  input.onSubmit = (submitted) => done(submitted);
+  input.onEscape = () => done(undefined);
+  return {
+    /** 一行可编辑文本。 */
+    render: (width) => input.render(width),
+    /** 无本地缓存。 */
+    invalidate: () => input.invalidate(),
+    /** 所有按键都归输入框。 */
+    handleInput: (data) => input.handleInput(data),
+  };
+}
+
+/** 把当前配置转成 Pi 设置列表的条目。 */
+export function buildSettingItems(config: NamingConfig): SettingItem[] {
+  return PANEL_FIELDS.map((field) => {
+    const label = i18n.t(field.labelKey);
+    const description = i18n.t(field.descriptionKey);
+    const options = fieldOptions(field.id, config);
+    const stored = readField(config, field.id);
+    if (field.kind === "toggle") {
+      return { id: field.id, label, description, currentValue: optionLabelForValue(options, stored), values: options.map((option) => option.label) };
+    }
+    if (field.kind === "choice") {
+      return {
+        id: field.id,
+        label,
+        description,
+        currentValue: optionLabelForValue(options, stored),
+        // 二级列表接管 Enter，避免在候选之间反复原地循环。
+        submenu: (currentValue, done) => createChoiceSubmenu(options, currentValue, done),
+      };
+    }
+    return {
+      id: field.id,
+      label,
+      description,
+      currentValue: stored || i18n.t("panelValueUnset"),
+      submenu: (_currentValue, done) => createTextSubmenu(stored, description, done),
+    };
+  });
+}
+
+/**
+ * 把面板返回的展示文本写回配置；无法识别时返回 undefined，由调用方保持不变。
+ *
+ * 结果统一过一遍 `parseConfig`，保证写盘的值仍在合法区间内（候选表与校验规则不会各走各的）。
+ */
+export function applyPanelChange(
+  config: NamingConfig,
+  id: string,
+  value: string,
+): NamingConfig | undefined {
+  const field = PANEL_FIELDS.find((candidate) => candidate.id === id);
+  if (!field) return undefined;
+  if (field.kind === "text") {
+    try {
+      return parseConfig(writeField(config, field.id, value));
+    } catch {
+      return undefined;
+    }
+  }
+  const stored = optionValueFromLabel(fieldOptions(field.id, config), value);
+  if (stored === undefined) return undefined;
+  try {
+    return parseConfig(writeField(config, field.id, stored));
+  } catch {
+    return undefined;
+  }
+}
+
+/** 面板与宿主之间的接口；配置读写与生效动作都由入口注入。 */
+export interface ConfigPanelHandlers {
+  /** 读取当前配置。 */
+  getConfig(): NamingConfig;
+  /** 某一项被改动后调用，由入口负责保存并同步运行期配置。 */
+  onChange(config: NamingConfig): void;
+}
+
+/** 打开配置面板；用户改动即时生效，Esc 关闭。 */
+export async function openConfigPanel(
+  ctx: ExtensionCommandContext,
+  handlers: ConfigPanelHandlers,
+): Promise<void> {
+  await ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
+    const container = new Container();
+    container.addChild(new Text(theme.fg("accent", theme.bold(i18n.t("configMenuTitle"))), 1, 1));
+
+    const settingsList = new SettingsList(
+      buildSettingItems(handlers.getConfig()),
+      PANEL_FIELDS.length,
+      getSettingsListTheme(),
+      (id, newValue) => {
+        const next = applyPanelChange(handlers.getConfig(), id, newValue);
+        if (next) handlers.onChange(next);
+      },
+      () => done(undefined),
+    );
+    container.addChild(settingsList);
+
+    // ctx.ui.custom 要求返回 Component：整体布局交给 Container，键盘转给设置列表，
+    // 列表改了数据后必须 requestRender，否则画面停在上一帧。
+    return {
+      /** 面板整体按 Container 布局渲染。 */
+      render: (width) => container.render(width),
+      /** 无本地缓存，交给 Container 清理。 */
+      invalidate: () => container.invalidate(),
+      /** 键盘输入交给设置列表，并触发一次重绘。 */
+      handleInput: (data) => {
+        settingsList.handleInput(data);
+        tui.requestRender();
+      },
+    };
+  });
+}

package/src/config.ts

@@ -12,6 +12,13 @@ const MAX_TIMER_MS = 2_147_483_647;
 /** 思考档位：与 pi-ai 的 ThinkingLevel 一致，优先级由低到高。 */
 export const TITLE_EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
 
+/** 标题长度与超时等数值字段的候选预设；配置面板与命令行共用同一份。 */
+export const MAX_LENGTH_PRESETS = ["15", "30", "60"] as const;
+export const PREFERRED_LENGTH_PRESETS = ["10", "20", "40"] as const;
+export const LANGUAGE_PRESETS = ["auto", "中文", "English", "日本語"] as const;
+export const TIMEOUT_PRESETS = ["5000", "10000", "30000"] as const;
+export const MAX_TOKENS_PRESETS = ["1024", "2048", "4096"] as const;
+
 export type TitleEffort = typeof TITLE_EFFORT_LEVELS[number];
 
 /** 标题请求的默认输出预算；推理模型的思考与标题共享该额度。 */

package/src/index.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { TerminalRenameOutcome, TerminalRenameTarget, ResolveRenameOptions } from "pi-terminal-mux";
-import { configPath, isTitleEffort, loadConfig, parseConfig, saveConfig, TITLE_EFFORT_LEVELS, type NamingConfig } from "./config.ts";
+import { configPath, loadConfig, parseConfig, saveConfig, type NamingConfig } from "./config.ts";
+import { openConfigPanel } from "./config-panel.ts";
 import { i18n } from "./i18n.ts";
 import { NOTICE_TAG_COLOR, installNoticeRenderer, notifyWithSource, type NoticeColor, type NoticeSource } from "pi-extensions-i18n";
 
@@ -15,25 +16,6 @@ import { getCurrentSessionUserMessages, requestSessionNameWithTimeout, type Sess
 const RENAME_COMMAND = "rename";
 const CONFIG_COMMAND_ALIASES = ["config:naming", "naming-config", "pi-naming-config"] as const;
 const CONFIG_RESET_COMMAND = "reset";
-const CONFIG_OPTION = {
-  automaticNaming: 0,
-  manualNaming: 1,
-  sessionTarget: 2,
-  workspaceTarget: 3,
-  tabTarget: 4,
-  maxLength: 5,
-  preferredLength: 6,
-  language: 7,
-  instructions: 8,
-  timeout: 9,
-  maxTokens: 10,
-  effort: 11,
-} as const;
-const MAX_LENGTH_PRESETS = ["15", "30", "60"] as const;
-const PREFERRED_LENGTH_PRESETS = ["10", "20", "40"] as const;
-const LANGUAGE_PRESETS = ["auto", "中文", "English", "日本語"] as const;
-const TIMEOUT_PRESETS = ["5000", "10000", "30000"] as const;
-const MAX_TOKENS_PRESETS = ["1024", "2048", "4096"] as const;
 const MESSAGE_TYPE = "pi-naming";
 
 export interface TerminalNamingAdapter {
@@ -65,10 +47,21 @@ export interface NamingConfigStore {
   path(): string;
 }
 
-/** 注册配置命令，通过 TUI 菜单和输入框修改命名配置。 */
+/** 运行期持有的命名配置；配置面板改动后直接改这里的值，不用重启会话。 */
+export interface NamingRuntime {
+  config: NamingConfig;
+}
+
+/** 把新配置写进运行期持有者；没有运行期持有者（如只读命令场景）时不动任何状态。 */
+function applyConfig(runtime: NamingRuntime | undefined, next: NamingConfig): void {
+  if (runtime) runtime.config = next;
+}
+
+/** 注册配置命令，通过 TUI 面板修改命名配置。 */
 export function registerNamingConfigCommand(
   pi: ExtensionAPI,
   store: NamingConfigStore = { load: loadConfig, save: saveConfig, path: configPath },
+  runtime?: NamingRuntime,
 ): void {
   const command = {
     description: i18n.t("configCommandDescription"),
@@ -81,7 +74,9 @@ export function registerNamingConfigCommand(
       }
       if (argument === CONFIG_RESET_COMMAND) {
         try {
-          store.save(parseConfig({}));
+          const defaults = parseConfig({});
+          store.save(defaults);
+          applyConfig(runtime, defaults);
           report(pi, ctx, {
             message: i18n.t("configCommandSaved", { path: store.path() }),
             level: "info",
@@ -104,132 +99,18 @@ export function registerNamingConfigCommand(
         return;
       }
 
-      /** Saves one validated menu change and reports its result. */
-      const save = (next: NamingConfig): boolean => {
+      /** 面板里改一项：先存盘、再同步运行期配置；失败只报错，不静默丢失界面上的改动。 */
+      const applyPanelChange = (next: NamingConfig): void => {
         try {
           store.save(next);
           config = next;
-          report(pi, ctx, { message: i18n.t("configCommandSaved", { path: store.path() }), level: "info" });
-          return true;
+          applyConfig(runtime, next);
         } catch (error) {
           report(pi, ctx, { message: i18n.t("configCommandInvalid", { error: errorMessage(error) }), level: "error" });
-          return false;
         }
       };
-      /** Formats a boolean setting for the localized menu label. */
-      const toggle = (value: boolean): string => value ? i18n.t("configOn") : i18n.t("configOff");
-      /** Opens one text input for a scalar title setting. */
-      const editText = async (title: string, current: string): Promise<string | undefined> =>
-        ctx.ui.input(title, current);
-
-      /** Opens a choice list for common values and falls back to text only for custom values. */
-      const chooseSettingValue = async (
-        title: string,
-        current: string,
-        options: readonly string[],
-      ): Promise<string | undefined> => {
-        const customChoice = i18n.t("configCustom");
-        const cancelChoice = i18n.t("configCancel");
-        const choices = [
-          ...options.map((value) => i18n.t("configPresetValue", { value })),
-          customChoice,
-          cancelChoice,
-        ];
-        const selected = await ctx.ui.select(title, choices);
-        if (selected === undefined || selected === cancelChoice) return undefined;
-        if (selected === customChoice) return ctx.ui.input(title, current);
-        const index = choices.indexOf(selected);
-        return index >= 0 && index < options.length ? options[index] : undefined;
-      };
 
-      while (true) {
-        const doneChoice = i18n.t("configDone");
-        const choices = [
-          i18n.t("configAutomaticNaming", { value: toggle(config.automaticNaming) }),
-          i18n.t("configManualNaming", { value: toggle(config.manualNaming) }),
-          i18n.t("configSessionTarget", { value: toggle(config.targets.session) }),
-          i18n.t("configWorkspaceTarget", { value: toggle(config.targets.workspace) }),
-          i18n.t("configTabTarget", { value: toggle(config.targets.tab) }),
-          i18n.t("configMaxLength", { value: config.title.maxLength }),
-          i18n.t("configPreferredLength", { value: config.title.preferredLength }),
-          i18n.t("configLanguage", { value: config.title.language }),
-          i18n.t("configInstructions", { value: config.title.instructions || i18n.t("configEmpty") }),
-          i18n.t("configTimeout", { value: config.title.timeoutMs }),
-          i18n.t("configMaxTokens", { value: config.title.maxTokens }),
-          i18n.t("configEffort", { value: config.title.effort }),
-          doneChoice,
-        ];
-        const selected = await ctx.ui.select(i18n.t("configMenuTitle"), choices);
-        if (selected === undefined || selected === doneChoice) return;
-        const selectedIndex = choices.indexOf(selected);
-        let next: NamingConfig | undefined;
-        if (selectedIndex === CONFIG_OPTION.automaticNaming) {
-          next = parseConfig({ ...config, automaticNaming: !config.automaticNaming });
-        } else if (selectedIndex === CONFIG_OPTION.manualNaming) {
-          next = parseConfig({ ...config, manualNaming: !config.manualNaming });
-        } else if (selectedIndex === CONFIG_OPTION.sessionTarget) {
-          next = parseConfig({ ...config, targets: { ...config.targets, session: !config.targets.session } });
-        } else if (selectedIndex === CONFIG_OPTION.workspaceTarget) {
-          next = parseConfig({ ...config, targets: { ...config.targets, workspace: !config.targets.workspace } });
-        } else if (selectedIndex === CONFIG_OPTION.tabTarget) {
-          next = parseConfig({ ...config, targets: { ...config.targets, tab: !config.targets.tab } });
-        } else {
-          let inputTitle = i18n.t("configTimeoutInput");
-          let inputValue = String(config.title.timeoutMs);
-          let options: readonly string[] = TIMEOUT_PRESETS;
-          if (selectedIndex === CONFIG_OPTION.maxLength) {
-            inputTitle = i18n.t("configMaxLengthInput");
-            inputValue = String(config.title.maxLength);
-            options = MAX_LENGTH_PRESETS;
-          } else if (selectedIndex === CONFIG_OPTION.preferredLength) {
-            inputTitle = i18n.t("configPreferredLengthInput");
-            inputValue = String(config.title.preferredLength);
-            options = PREFERRED_LENGTH_PRESETS;
-          } else if (selectedIndex === CONFIG_OPTION.language) {
-            inputTitle = i18n.t("configLanguageInput");
-            inputValue = config.title.language;
-            options = LANGUAGE_PRESETS;
-          } else if (selectedIndex === CONFIG_OPTION.instructions) {
-            inputTitle = i18n.t("configInstructionsInput");
-            inputValue = config.title.instructions;
-            options = [];
-          } else if (selectedIndex === CONFIG_OPTION.maxTokens) {
-            inputTitle = i18n.t("configMaxTokensInput");
-            inputValue = String(config.title.maxTokens);
-            options = MAX_TOKENS_PRESETS;
-          } else if (selectedIndex === CONFIG_OPTION.effort) {
-            inputTitle = i18n.t("configEffortInput");
-            inputValue = config.title.effort;
-            options = TITLE_EFFORT_LEVELS;
-          }
-          const input = selectedIndex === CONFIG_OPTION.instructions
-            ? await ctx.ui.input(inputTitle, inputValue)
-            : await chooseSettingValue(inputTitle, inputValue, options);
-          if (input === undefined) continue;
-          const title = { ...config.title };
-          if (selectedIndex === CONFIG_OPTION.maxLength) title.maxLength = Number(input.trim());
-          else if (selectedIndex === CONFIG_OPTION.preferredLength) title.preferredLength = Number(input.trim());
-          else if (selectedIndex === CONFIG_OPTION.language) title.language = input;
-          else if (selectedIndex === CONFIG_OPTION.instructions) title.instructions = input;
-          else if (selectedIndex === CONFIG_OPTION.maxTokens) title.maxTokens = Number(input.trim());
-          else if (selectedIndex === CONFIG_OPTION.effort) {
-            // 自定义输入可能不是受支持的档位；明确报错并重开菜单，不静默丢弃也不落到其它字段。
-            if (!isTitleEffort(input)) {
-              report(pi, ctx, {
-                message: i18n.t("configEffortInvalid", { value: input, options: TITLE_EFFORT_LEVELS.join(", ") }),
-                level: "error",
-              });
-              continue;
-            }
-            title.effort = input;
-          } else title.timeoutMs = Number(input.trim());
-          try { next = parseConfig({ ...config, title }); }
-          catch (error) {
-            report(pi, ctx, { message: i18n.t("configCommandInvalid", { error: errorMessage(error) }), level: "error" });
-          }
-        }
-        if (next) save(next);
-      }
+      await openConfigPanel(ctx, { getConfig: () => config, onChange: applyPanelChange });
     },
   };
   for (const name of CONFIG_COMMAND_ALIASES) pi.registerCommand(name, command);
@@ -239,15 +120,17 @@ export function registerNamingConfigCommand(
 export async function registerNaming(
   pi: ExtensionAPI,
   config: NamingConfig,
-  dependencies: { requestName?: SessionNameRequester; loadTerminal?: () => Promise<TerminalNamingAdapter> } = {},
+  dependencies: { requestName?: SessionNameRequester; loadTerminal?: () => Promise<TerminalNamingAdapter>; runtime?: NamingRuntime } = {},
 ): Promise<void> {
-  const { requestName, loadTerminal = loadTerminalAdapter } = dependencies;
-  if ((!config.automaticNaming && !config.manualNaming) || !Object.values(config.targets).some(Boolean)) return;
-  let terminal: TerminalNamingAdapter | undefined;
-  let terminalLoadError: unknown;
-  if (config.targets.workspace || config.targets.tab) {
-    try { terminal = await loadTerminal(); } catch (error) { terminalLoadError = error; }
-  }
+  const { requestName, loadTerminal = loadTerminalAdapter, runtime } = dependencies;
+  // 运行期配置随时可能被配置面板改写，所以每次使用都读一次，不缓存快照。
+  const current = (): NamingConfig => runtime?.config ?? config;
+  // 入口常驻注册，开关一律在调用时现取：面板里把 automaticNaming / manualNaming / targets
+  // 打开后下一次输入或 /rename 就生效。注册与否在加载时定死的话，改完必须 /reload。
+  // 终端能力按需加载：面板里把 workspace/tab 打开后，下一次命名就会去加载，不用 reload。
+  let terminalPromise: Promise<TerminalNamingAdapter> | undefined;
+  /** 取终端适配器（只加载一次）；加载失败按调用方处理。 */
+  const getTerminal = (): Promise<TerminalNamingAdapter> => (terminalPromise ??= loadTerminal());
   let generation = 0;
   let request = 0;
   let eligible = false;
@@ -257,31 +140,37 @@ export async function registerNaming(
     generation++;
     eligible = !pi.getSessionName() && getCurrentSessionUserMessages(ctx).length === 0;
     attempted = false;
-    if (terminalLoadError !== undefined) {
-      report(pi, ctx, { message: i18n.t("terminalNamingFailed", { error: errorMessage(terminalLoadError) }), level: "warning" });
-    }
   });
   pi.on("session_shutdown", () => { generation++; eligible = false; });
   pi.on("session_tree", () => { generation++; eligible = false; });
 
   /** 先捕获终端身份，再生成标题；任一新请求或会话切换都会使旧结果失效。 */
   async function rename(args: string, ctx: ExtensionContext, automatic: boolean): Promise<void> {
+    const liveTargets = current().targets;
+    // 所有目标都关着时不做任何事：既不改名，也不白花一次模型调用。
+    if (!Object.values(liveTargets).some(Boolean)) {
+      report(pi, ctx, { message: i18n.t("namingNoTargets"), level: "warning" });
+      return;
+    }
     const currentGeneration = generation;
     const currentRequest = ++request;
     // 新请求和 session 生命周期变化都会使当前请求失效。
     const isCurrent = () => generation === currentGeneration && request === currentRequest;
     let targets: TerminalRenameOutcome[] = [];
     let resolutionError: unknown;
-    if (terminal) {
-      try { targets = terminal.resolve({ tab: config.targets.tab, workspace: config.targets.workspace }); }
-      catch (error) { resolutionError = error; }
+    // 只有开了 workspace/tab 目标才需要终端；适配器不提前加载，面板打开开关后一样能用。
+    if (liveTargets.workspace || liveTargets.tab) {
+      try {
+        const terminal = await getTerminal();
+        targets = terminal.resolve({ tab: liveTargets.tab, workspace: liveTargets.workspace });
+      } catch (error) { resolutionError = error; }
     }
     let label = automatic ? "" : args.trim();
     if (!label) {
       try {
         label = await requestSessionNameWithTimeout({
           userMessages: automatic ? [args] : getCurrentSessionUserMessages(ctx),
-          ctx, requestName, title: config.title,
+          ctx, requestName, title: current().title,
         });
       } catch (error) {
         if (isCurrent()) report(pi, ctx, { message: i18n.t("namingFailed", { error: errorMessage(error) }), level: "error" });
@@ -291,7 +180,7 @@ export async function registerNaming(
     if (!isCurrent() || (automatic && pi.getSessionName())) return;
 
     const renamed: string[] = [];
-    if (config.targets.session) {
+    if (current().targets.session) {
       try { pi.setSessionName(label); renamed.push(i18n.t("piSessionTarget")); }
       catch (error) { report(pi, ctx, { message: i18n.t("namingFailed", { error: errorMessage(error) }), level: "error" }); }
     }
@@ -300,8 +189,8 @@ export async function registerNaming(
     }
     for (const target of targets) {
       let result = target;
-      if (target.status === "ready" && terminal) {
-        try { result = terminal.rename(target.reference, label); }
+      if (target.status === "ready") {
+        try { result = (await getTerminal()).rename(target.reference, label); }
         catch (error) { result = { status: "failed", operation: target.reference.operation, error: errorMessage(error) }; }
       }
       if (result.status === "renamed") {
@@ -320,39 +209,46 @@ export async function registerNaming(
     }
   }
 
-  if (config.manualNaming) {
-    pi.registerCommand(RENAME_COMMAND, {
-      description: i18n.t("renameDescription"),
-      getArgumentCompletions: () => null,
-      handler: async (args, ctx) => { await rename(args, ctx, false); },
-    });
-  }
-  if (config.automaticNaming) {
-    pi.on("input", (event, ctx) => {
-      if (!eligible || attempted || event.source === "extension" || pi.getSessionName()) return;
-      const text = event.text.trim();
-      if (!text) return;
-      attempted = true;
-      const inputGeneration = generation;
-      void rename(text, ctx, true).catch((error: unknown) => {
-        if (generation !== inputGeneration) return;
-        report(pi, ctx, { message: i18n.t("namingFailed", { error: errorMessage(error) }), level: "error" });
-      });
+  // /rename 常驻注册；manualNaming 关掉时报告原因，而不是让命令凭空消失（Pi 没有内置 /rename 可回退）。
+  pi.registerCommand(RENAME_COMMAND, {
+    description: i18n.t("renameDescription"),
+    getArgumentCompletions: () => null,
+    handler: async (args, ctx) => {
+      if (!current().manualNaming) {
+        report(pi, ctx, { message: i18n.t("namingManualDisabled"), level: "warning" });
+        return;
+      }
+      await rename(args, ctx, false);
+    },
+  });
+  pi.on("input", (event, ctx) => {
+    if (!current().automaticNaming) return;
+    if (!eligible || attempted || event.source === "extension" || pi.getSessionName()) return;
+    const text = event.text.trim();
+    if (!text) return;
+    attempted = true;
+    const inputGeneration = generation;
+    void rename(text, ctx, true).catch((error: unknown) => {
+      if (generation !== inputGeneration) return;
+      report(pi, ctx, { message: i18n.t("namingFailed", { error: errorMessage(error) }), level: "error" });
     });
-  }
+  });
 }
 
 /** 配置错误在 session_start 报告，不注册不完整的命名功能。 */
 export default async function namingExtension(pi: ExtensionAPI): Promise<void> {
   // 提示画成会话区里的带底色消息块；渲染器在本包这个模块实例里注册一次。
   installNoticeRenderer(pi);
-  registerNamingConfigCommand(pi);
   let config: NamingConfig;
   try { config = loadConfig(); }
   catch (error) {
+    registerNamingConfigCommand(pi);
     pi.on("session_start", (_event, ctx) => report(pi, ctx, { message:
       i18n.t("namingConfigFailed", { error: errorMessage(error) }), level: "warning" }));
     return;
   }
-  await registerNaming(pi, config);
+  // 面板改一项就改这里，后续命名请求读到的就是新值，不用 /reload。
+  const runtime: NamingRuntime = { config };
+  registerNamingConfigCommand(pi, undefined, runtime);
+  await registerNaming(pi, config, { runtime });
 }

package/src/session-name.ts

@@ -3,11 +3,12 @@ import type {
   ExtensionContext,
   SessionEntry,
 } from "@earendil-works/pi-coding-agent";
+import { createModelRequester } from "pi-model-request";
 import { i18n } from "./i18n.ts";
 import { DEFAULT_TITLE_CONFIG, type TitleConfig } from "./config.ts";
 
 /** 生成标题所需的最小 session 上下文；终端消费者可复用该契约。 */
-export type SessionNameContext = Pick<ExtensionContext, "model" | "modelRegistry">;
+export type SessionNameContext = Pick<ExtensionContext, "model" | "modelRegistry" | "sessionManager">;
 
 /** 可注入的标题 completion，便于终端消费者和测试复用同一套请求逻辑。 */
 export type SessionNameCompletion = (...args: Parameters<typeof completeSimple>) => ReturnType<typeof completeSimple>;
@@ -147,12 +148,13 @@ export async function requestSessionName({
     throw new Error(i18n.t("sessionNameNoModel"));
   }
 
-  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-  if (auth.ok === false) {
-    throw new Error(i18n.t("sessionNameAuthFailed", { error: auth.error }));
-  }
+  // 命名请求由扩展自己发出：鉴权与 provider 会话头交给共享请求器，与 Pi 核心行为一致。
+  const request = createModelRequester(ctx, {
+    base: completion,
+    authError: (error) => new Error(i18n.t("sessionNameAuthFailed", { error })),
+  });
 
-  const response = await completion(
+  const response = await request(
     model,
     {
       systemPrompt: [
@@ -171,9 +173,6 @@ export async function requestSessionName({
       ],
     },
     {
-      apiKey: auth.apiKey,
-      headers: auth.headers,
-      env: auth.env,
       maxTokens: resolveTitleMaxTokens(model, title.maxTokens),
       // 命名不需要高强度推理；档位可配置，降低思考占用预算的波动。
       reasoning: title.effort,