@deepseek-harness-tui/dsh-tui 0.14.0 → 0.15.0

package/lib/types/i18n.d.ts

@@ -450,262 +450,26 @@ declare const dict: {
         readonly zh: "当前内核不支持：{{name}}";
         readonly en: "Not supported by this kernel: {{name}}";
     };
-    readonly 'capability-failed': {
-        readonly zh: "{{name}} 失败 · {{err}}";
-        readonly en: "{{name}} failed · {{err}}";
-    };
-    readonly 'claude-permission-denied': {
-        readonly zh: "{{tool}} 被权限规则拒绝";
-        readonly en: "{{tool}} was denied by a permission rule";
-    };
-    readonly 'claude-permission-denied-reason': {
-        readonly zh: "{{tool}} 被自动拒绝：{{reason}}";
-        readonly en: "{{tool}} was denied automatically: {{reason}}";
-    };
-    readonly 'claude-denied-reason': {
-        readonly zh: "拒绝原因：{{reason}}";
-        readonly en: "Denied: {{reason}}";
-    };
-    readonly 'claude-question-unreadable': {
-        readonly zh: "无法读取这次提问的内容，已拒绝";
-        readonly en: "The question could not be read and was declined";
-    };
-    readonly 'claude-always-rules-session': {
-        readonly zh: "允许，本次会话不再询问 {{rules}}";
-        readonly en: "Yes, and don't ask again for {{rules}} this session";
-    };
-    readonly 'claude-always-rules-project': {
-        readonly zh: "允许，本项目不再询问 {{rules}}";
-        readonly en: "Yes, and don't ask again for {{rules}} in this project";
-    };
-    readonly 'claude-always-rules-user': {
-        readonly zh: "允许，所有项目都不再询问 {{rules}}";
-        readonly en: "Yes, and don't ask again for {{rules}} in any project";
-    };
-    readonly 'claude-always-accept-edits': {
-        readonly zh: "允许，本次会话自动接受编辑";
-        readonly en: "Yes, and auto-accept edits this session";
-    };
-    readonly 'claude-always-mode': {
-        readonly zh: "允许，并切换到 {{mode}} 模式";
-        readonly en: "Yes, and switch to {{mode}} mode";
-    };
-    readonly 'claude-always-directories': {
-        readonly zh: "允许，并允许访问 {{dirs}}";
-        readonly en: "Yes, and allow access to {{dirs}}";
-    };
-    readonly 'claude-plan-review-header': {
-        readonly zh: "计划评审";
-        readonly en: "Plan review";
-    };
-    readonly 'claude-plan-review-question': {
-        readonly zh: "Claude 准备好了计划，要开始执行吗？";
-        readonly en: "Claude has a plan. Ready to start?";
-    };
-    readonly 'claude-plan-accept-edits': {
-        readonly zh: "批准，并自动接受编辑";
-        readonly en: "Yes, and auto-accept edits";
-    };
-    readonly 'claude-plan-accept-edits-desc': {
-        readonly zh: "退出计划模式，之后的文件编辑不再逐个询问";
-        readonly en: "Leave plan mode; file edits no longer ask one by one";
-    };
-    readonly 'claude-plan-manual': {
-        readonly zh: "批准，编辑仍逐个确认";
-        readonly en: "Yes, and approve each edit";
-    };
-    readonly 'claude-plan-manual-desc': {
-        readonly zh: "退出计划模式，回到默认权限模式";
-        readonly en: "Leave plan mode for the default permission mode";
-    };
-    readonly 'claude-plan-keep': {
-        readonly zh: "继续规划";
-        readonly en: "No, keep planning";
-    };
-    readonly 'claude-plan-keep-desc': {
-        readonly zh: "可在输入行写下要修改的地方";
-        readonly en: "Type what to change on the input row";
-    };
-    readonly 'claude-plan-approved': {
-        readonly zh: "计划已批准，开始执行";
-        readonly en: "Plan approved; starting";
-    };
-    readonly 'claude-plan-kept': {
-        readonly zh: "计划未批准，继续规划";
-        readonly en: "Plan not approved; planning continues";
-    };
-    readonly 'claude-model-unknown': {
-        readonly zh: "Claude 没有模型 {{model}}（/model 查看可用模型）";
-        readonly en: "Claude has no model {{model}} (see /model)";
-    };
-    readonly 'claude-mode-default': {
-        readonly zh: "默认";
-        readonly en: "Default";
-    };
-    readonly 'claude-mode-acceptEdits': {
-        readonly zh: "自动接受编辑";
-        readonly en: "Accept edits";
-    };
-    readonly 'claude-mode-plan': {
-        readonly zh: "计划模式";
-        readonly en: "Plan mode";
-    };
-    readonly 'claude-mode-auto': {
-        readonly zh: "自动审批";
-        readonly en: "Auto";
-    };
-    readonly 'claude-mode-dontAsk': {
-        readonly zh: "不询问";
-        readonly en: "Don't ask";
-    };
-    readonly 'claude-mode-bypassPermissions': {
-        readonly zh: "跳过权限";
-        readonly en: "Bypass permissions";
-    };
-    readonly 'claude-mode-desc-default': {
-        readonly zh: "默认：每个危险操作前都询问";
-        readonly en: "Default: asks before every risky action";
-    };
-    readonly 'claude-mode-desc-acceptEdits': {
-        readonly zh: "自动接受文件编辑，其他操作仍询问";
-        readonly en: "Auto-accepts file edits, still asks for the rest";
-    };
-    readonly 'claude-mode-desc-plan': {
-        readonly zh: "计划模式：只读，先出方案不动手";
-        readonly en: "Plan mode: read-only, proposes before acting";
-    };
-    readonly 'claude-mode-desc-auto': {
-        readonly zh: "自动审批：由模型分类器判定";
-        readonly en: "Auto: a model classifier decides";
-    };
-    readonly 'claude-mode-desc-dontAsk': {
-        readonly zh: "不询问：未预先批准的操作一律拒绝";
-        readonly en: "Don't ask: anything not pre-approved is denied";
-    };
-    readonly 'claude-mode-desc-bypassPermissions': {
-        readonly zh: "跳过全部权限检查（谨慎使用）";
-        readonly en: "Skips every permission check (use with care)";
-    };
-    readonly 'claude-effort-low': {
+    readonly 'effort-tier-low': {
         readonly zh: "低";
         readonly en: "Low";
     };
-    readonly 'claude-effort-medium': {
+    readonly 'effort-tier-medium': {
         readonly zh: "中";
         readonly en: "Medium";
     };
-    readonly 'claude-effort-high': {
+    readonly 'effort-tier-high': {
         readonly zh: "高";
         readonly en: "High";
     };
-    readonly 'claude-effort-xhigh': {
+    readonly 'effort-tier-xhigh': {
         readonly zh: "超高";
         readonly en: "Extra high";
     };
-    readonly 'claude-effort-max': {
+    readonly 'effort-tier-max': {
         readonly zh: "最高";
         readonly en: "Max";
     };
-    readonly 'claude-auth-failed-login': {
-        readonly zh: "Claude 凭证仍被拒绝：用 /login 重新登录，或设置 ANTHROPIC_API_KEY、在终端运行 claude login";
-        readonly en: "Claude still refuses the credential: sign in again with /login, set ANTHROPIC_API_KEY, or run `claude login` in a terminal";
-    };
-    readonly 'claude-auth-reconnected': {
-        readonly zh: "凭证已刷新并重新连接同一会话，请重发上一条消息";
-        readonly en: "Credential renewed and the same session reconnected; send your last message again";
-    };
-    readonly 'claude-auth-refresh-failed': {
-        readonly zh: "刷新 Claude 凭证失败{{detail}}（可用 /login 重新登录）";
-        readonly en: "Renewing the Claude credential failed{{detail}} (sign in again with /login)";
-    };
-    readonly 'claude-channel-token-missing': {
-        readonly zh: "渠道 {{name}}（{{host}}）指向自定义端点，但没有可用的 token，已拒绝启动，以免向中转端点发送不带凭据的请求。请在 /channel → 管理渠道 里补上 token，或换一个渠道后重试。";
-        readonly en: "Channel {{name}} ({{host}}) points at a custom endpoint but has no usable token, so the session was not started (no unauthenticated requests to a relay). Add a token under /channel → Manage channels, or switch to another channel, then retry.";
-    };
-    readonly 'claude-channel-helper-conflict': {
-        readonly zh: "settings.json 配置了 apiKeyHelper，与当前渠道冲突：它生成的 x-api-key 会随请求发到渠道端点。请从 settings.json 删掉 apiKeyHelper，或在 /channel 里停用该渠道后再启动。";
-        readonly en: "settings.json sets apiKeyHelper, which conflicts with the active channel: the x-api-key it produces would be sent to the channel endpoint. Remove apiKeyHelper from settings.json, or deactivate the channel in /channel, then retry.";
-    };
-    readonly 'claude-auth-refresh-status': {
-        readonly zh: " · HTTP {{status}}";
-        readonly en: " · HTTP {{status}}";
-    };
-    readonly 'claude-auth-reconnect-failed': {
-        readonly zh: "重新连接 Claude 会话失败；可用 /login 重新登录";
-        readonly en: "Reconnecting the Claude session failed; sign in again with /login";
-    };
-    readonly 'claude-auth-reconnect-deferred': {
-        readonly zh: "当前回合结束后再用新凭证重新连接";
-        readonly en: "Reconnecting with the new credential once the current turn ends";
-    };
-    readonly 'claude-auth-reconnect-forced': {
-        readonly zh: "等待当前回合结束超时，现在重新连接，正在运行的回合会被中断";
-        readonly en: "The turn did not finish in time; reconnecting now, which interrupts the running turn";
-    };
-    readonly 'claude-auth-inputs-dropped': {
-        readonly zh: "重新连接失败，{{n}} 条尚未开始的消息未能送达";
-        readonly en: "Reconnecting failed; {{n}} message(s) that had not started were not delivered";
-    };
-    readonly 'claude-auth-route': {
-        readonly zh: "未使用订阅登录：{{route}}";
-        readonly en: "Subscription sign-in not used: {{route}}";
-    };
-    readonly 'claude-route-custom-endpoint': {
-        readonly zh: "自定义端点 {{host}}（ANTHROPIC_BASE_URL）";
-        readonly en: "custom endpoint {{host}} (ANTHROPIC_BASE_URL)";
-    };
-    readonly 'claude-route-custom-oauth': {
-        readonly zh: "自定义 OAuth 部署";
-        readonly en: "custom OAuth deployment";
-    };
-    readonly 'claude-route-unix-socket': {
-        readonly zh: "Unix 套接字（ANTHROPIC_UNIX_SOCKET）";
-        readonly en: "Unix socket (ANTHROPIC_UNIX_SOCKET)";
-    };
-    readonly 'claude-route-gateway': {
-        readonly zh: "云网关";
-        readonly en: "cloud gateway";
-    };
-    readonly 'claude-route-api-key-helper': {
-        readonly zh: "设置中的 apiKeyHelper";
-        readonly en: "apiKeyHelper in settings";
-    };
-    readonly 'claude-route-settings-unreadable': {
-        readonly zh: "无法读取 Claude 设置，无法确认连接方式";
-        readonly en: "Claude settings could not be read, so the connection route is unknown";
-    };
-    readonly 'claude-auth-source': {
-        readonly zh: "凭证来源：{{source}}";
-        readonly en: "Credential: {{source}}";
-    };
-    readonly 'claude-auth-missing-hint': {
-        readonly zh: "未找到 Claude 凭证：用 /login 登录 anthropic，或设置 ANTHROPIC_API_KEY、在终端运行 claude login";
-        readonly en: "No Claude credential found: sign in to anthropic with /login, set ANTHROPIC_API_KEY, or run `claude login` in a terminal";
-    };
-    readonly 'claude-auth-cli': {
-        readonly zh: "CLI 报告 · apiKeySource：{{source}} · tokenSource：{{token}}";
-        readonly en: "CLI reports · apiKeySource: {{source}} · tokenSource: {{token}}";
-    };
-    readonly 'claude-auth-source-dsh-auth': {
-        readonly zh: "dsh-auth anthropic 登录";
-        readonly en: "dsh-auth anthropic sign-in";
-    };
-    readonly 'claude-auth-source-dsh-auth-expires': {
-        readonly zh: "dsh-auth anthropic 登录（令牌到期 {{time}}）";
-        readonly en: "dsh-auth anthropic sign-in (token expires {{time}})";
-    };
-    readonly 'claude-auth-source-cloud': {
-        readonly zh: "云厂商 {{provider}}（环境变量）";
-        readonly en: "Cloud provider {{provider}} (environment)";
-    };
-    readonly 'claude-auth-source-claude-login': {
-        readonly zh: "本机 claude login";
-        readonly en: "Local `claude login`";
-    };
-    readonly 'claude-auth-account': {
-        readonly zh: "账户：{{account}}";
-        readonly en: "Account: {{account}}";
-    };
     readonly 'login-backend-heading': {
         readonly zh: "{{backend}} 登录状态";
         readonly en: "{{backend}} sign-in";
@@ -770,14 +534,6 @@ declare const dict: {
         readonly zh: "已关闭 MCP 服务器 {{name}}";
         readonly en: "Disabled the MCP server {{name}}";
     };
-    readonly 'claude-side-query-empty': {
-        readonly zh: "会话还没有保存任何对话，暂无内容可问";
-        readonly en: "The session has no saved conversation to ask about yet";
-    };
-    readonly 'claude-side-query-no-answer': {
-        readonly zh: "没有得到回答";
-        readonly en: "No answer was received";
-    };
     readonly 'backend-mcp-needs-auth': {
         readonly zh: "需要授权的服务器请在终端运行 claude 后用 /mcp 完成";
         readonly en: "For servers that need auth, finish it with /mcp in an interactive `claude`";
@@ -790,26 +546,6 @@ declare const dict: {
         readonly zh: "订阅用量 {{usage}}";
         readonly en: "Subscription usage {{usage}}";
     };
-    readonly 'status-rate-limit-five-hour': {
-        readonly zh: "5小时";
-        readonly en: "5h";
-    };
-    readonly 'status-rate-limit-seven-day': {
-        readonly zh: "7天";
-        readonly en: "7d";
-    };
-    readonly 'claude-process-exited': {
-        readonly zh: "Claude 进程已退出：{{reason}}";
-        readonly en: "The Claude process exited: {{reason}}";
-    };
-    readonly 'claude-process-ended': {
-        readonly zh: "会话流已结束";
-        readonly en: "the session stream ended";
-    };
-    readonly 'claude-cancel-forced': {
-        readonly zh: "中断 30 秒未得到确认，已强制结束本回合";
-        readonly en: "The interrupt was not confirmed within 30s; the turn was force-closed";
-    };
     readonly 'interrupt-failed': {
         readonly zh: "打断请求失败：排队消息没有撤回，仍会在下一回合发送；已取消暂存，避免重复发送";
         readonly en: "The interrupt request failed: the queued messages were not withdrawn and will still run next turn; they are no longer held, so nothing is sent twice";
@@ -818,1080 +554,6 @@ declare const dict: {
         readonly zh: "无法确认排队消息已撤回：它们仍会在下一回合发送，不再暂存";
         readonly en: "Could not confirm the queued messages were withdrawn: they will still run next turn and are no longer held";
     };
-    readonly 'claude-version-drift': {
-        readonly zh: "Claude CLI {{version}} 未经本版 dsh-tui 验证（已验证：{{validated}}），继续运行";
-        readonly en: "Claude CLI {{version}} is not validated with this dsh-tui (validated: {{validated}}); continuing";
-    };
-    readonly 'claude-sdk-drift': {
-        readonly zh: "Claude Agent SDK {{version}} 与验证版本 {{validated}} 不一致，继续运行";
-        readonly en: "Claude Agent SDK {{version}} differs from the validated {{validated}}; continuing";
-    };
-    readonly 'claude-sdk-missing': {
-        readonly zh: "未安装 Claude Agent SDK：在 dsh-tui 安装目录运行 pnpm add @anthropic-ai/claude-agent-sdk@{{version}}";
-        readonly en: "The Claude Agent SDK is not installed: run pnpm add @anthropic-ai/claude-agent-sdk@{{version}} in the dsh-tui install directory";
-    };
-    readonly 'claude-resume-not-found': {
-        readonly zh: "本机 Claude 会话库中没有会话 {{id}}";
-        readonly en: "No Claude session {{id}} in the local session store";
-    };
-    readonly 'claude-rewind-files-unavailable': {
-        readonly zh: "该会话没有可用的文件检查点";
-        readonly en: "No file checkpoints are available for this session";
-    };
-    readonly 'claude-fork-empty': {
-        readonly zh: "会话还没有保存任何消息，无可分叉的内容";
-        readonly en: "Nothing to fork yet — the session has no saved messages";
-    };
-    readonly 'claude-task-unnamed': {
-        readonly zh: "任务 {{id}}（标题未恢复）";
-        readonly en: "Task {{id}} (subject not recovered)";
-    };
-    readonly 'claude-task-output-refused': {
-        readonly zh: "不读取任务 {{id}} 的输出：路径不在 Claude 的目录内";
-        readonly en: "Not reading the output of task {{id}}: the path is outside the Claude directories";
-    };
-    readonly 'claude-task-output-missing': {
-        readonly zh: "任务 {{id}} 的输出文件还不存在";
-        readonly en: "The output file of task {{id}} does not exist yet";
-    };
-    readonly 'claude-task-output-unknown': {
-        readonly zh: "任务 {{id}} 没有报告输出文件";
-        readonly en: "Task {{id}} reported no output file";
-    };
-    readonly 'claude-transcript-missing': {
-        readonly zh: "找不到会话 {{id}} 的转录文件";
-        readonly en: "The transcript file of session {{id}} was not found";
-    };
-    readonly 'claude-transcript-too-large': {
-        readonly zh: "会话转录超过 {{mb}} MB，不读取";
-        readonly en: "The session transcript is larger than {{mb}} MB; not reading it";
-    };
-    readonly 'claude-rewind-not-found': {
-        readonly zh: "该消息不在会话已保存的对话链中";
-        readonly en: "That message is not in the session's saved conversation";
-    };
-    readonly 'claude-images-too-many': {
-        readonly zh: "一条消息最多附 {{n}} 张图片";
-        readonly en: "A message carries at most {{n}} images";
-    };
-    readonly 'claude-images-too-large': {
-        readonly zh: "这条消息的图片合计超过 {{mb}} MB";
-        readonly en: "The images of this message exceed {{mb}} MB together";
-    };
-    readonly 'claude-image-too-large': {
-        readonly zh: "图片 {{name}} 超过 {{mb}} MB";
-        readonly en: "The image {{name}} exceeds {{mb}} MB";
-    };
-    readonly 'claude-image-type-refused': {
-        readonly zh: "Claude 不接受图片 {{name}} 的格式（{{type}}）";
-        readonly en: "Claude does not take the format of {{name}} ({{type}})";
-    };
-    readonly 'claude-image-unreadable': {
-        readonly zh: "无法读取图片 {{name}}：{{err}}";
-        readonly en: "The image {{name}} could not be read: {{err}}";
-    };
-    readonly 'claude-image-gone': {
-        readonly zh: "暂存的图片已不在内存中，请重新粘贴";
-        readonly en: "the staged image is no longer in memory; paste it again";
-    };
-    readonly 'claude-session-closed': {
-        readonly zh: "Claude 会话已关闭";
-        readonly en: "The Claude session is closed";
-    };
-    readonly 'claude-start-timeout': {
-        readonly zh: "Claude CLI 未在时限内完成启动握手";
-        readonly en: "The Claude CLI did not finish its start handshake in time";
-    };
-    readonly 'claude-start-mode-downgraded': {
-        readonly zh: "设置中的权限模式 {{mode}} 需在 /permission 里显式选择，本会话先以 default 启动";
-        readonly en: "The configured permission mode {{mode}} needs an explicit choice in /permission; this session starts in default";
-    };
-    readonly 'claude-start-mode-env': {
-        readonly zh: "权限模式由 DSH_TUI_CLAUDE_PERMISSION_MODE 指定：{{mode}}";
-        readonly en: "Permission mode set by DSH_TUI_CLAUDE_PERMISSION_MODE: {{mode}}";
-    };
-    readonly 'claude-start-mode-env-ignored': {
-        readonly zh: "已忽略 DSH_TUI_CLAUDE_PERMISSION_MODE={{mode}}（只接受 default/acceptEdits/plan/dontAsk/bypassPermissions）";
-        readonly en: "Ignored DSH_TUI_CLAUDE_PERMISSION_MODE={{mode}} (accepts default/acceptEdits/plan/dontAsk/bypassPermissions)";
-    };
-    readonly 'claude-start-mode-bypass-not-carried': {
-        readonly zh: "上次的「跳过权限」不会带到新会话，本会话照常审批；可用 /permission 重新开启";
-        readonly en: "Bypass permissions from the last session is not carried into a new one; approvals are on. Turn it back on with /permission";
-    };
-    readonly 'claude-input-refused': {
-        readonly zh: "Claude 拒绝了这条输入";
-        readonly en: "Claude refused this input";
-    };
-    readonly 'claude-assistant-error': {
-        readonly zh: "Claude 错误：{{error}}";
-        readonly en: "Claude error: {{error}}";
-    };
-    readonly 'claude-api-retry': {
-        readonly zh: "API 重试 {{attempt}}/{{max}}{{detail}}…";
-        readonly en: "API retry {{attempt}}/{{max}}{{detail}}…";
-    };
-    readonly 'claude-api-retry-status': {
-        readonly zh: " · HTTP {{status}}";
-        readonly en: " · HTTP {{status}}";
-    };
-    readonly 'claude-notification-turn': {
-        readonly zh: "后台任务完成，模型继续处理";
-        readonly en: "A background task finished; the model continues";
-    };
-    readonly 'claude-model-fallback': {
-        readonly zh: "{{original}} 拒绝了这次请求{{category}}，已改用 {{model}} 重试（本会话之后都用它）";
-        readonly en: "{{original}} declined this request{{category}}; retried on {{model}} (the session continues on it)";
-    };
-    readonly 'claude-model-fallback-local': {
-        readonly zh: "一个子任务改由 {{model}} 回答（{{original}} 拒绝了它），会话模型不变";
-        readonly en: "A side task was answered by {{model}} ({{original}} declined it); the session model is unchanged";
-    };
-    readonly 'claude-model-refused': {
-        readonly zh: "{{model}} 拒绝了这次请求{{category}}，没有可用的回退模型";
-        readonly en: "{{model}} declined this request{{category}} and no fallback model is available";
-    };
-    readonly 'claude-refusal-category-suffix': {
-        readonly zh: "（类别：{{category}}）";
-        readonly en: " (category: {{category}})";
-    };
-    readonly 'claude-rate-limit-warning': {
-        readonly zh: "订阅用量接近{{window}}上限（{{percent}}%）{{resets}}";
-        readonly en: "Approaching the {{window}} usage limit ({{percent}}%){{resets}}";
-    };
-    readonly 'claude-rate-limit-rejected': {
-        readonly zh: "已达到{{window}}用量上限{{resets}}";
-        readonly en: "The {{window}} usage limit is reached{{resets}}";
-    };
-    readonly 'claude-rate-limit-resets': {
-        readonly zh: "，{{time}}重置";
-        readonly en: " — resets {{time}}";
-    };
-    readonly 'claude-rate-limit-in': {
-        readonly zh: "{{duration}}后";
-        readonly en: "in {{duration}}";
-    };
-    readonly 'claude-auth-status-error': {
-        readonly zh: "Claude 认证出错：{{error}}";
-        readonly en: "Claude authentication error: {{error}}";
-    };
-    readonly 'claude-memory-recalled': {
-        readonly zh: "已回忆 {{count}} 条记忆";
-        readonly en: {
-            readonly one: "Recalled {{count}} memory";
-            readonly other: "Recalled {{count}} memories";
-        };
-    };
-    readonly 'claude-memory-synthesized': {
-        readonly zh: "已从记忆中归纳相关上下文";
-        readonly en: "Recalled a summary of relevant memories";
-    };
-    readonly 'claude-activity-thinking': {
-        readonly zh: "思考中";
-        readonly en: "Thinking";
-    };
-    readonly 'claude-activity-waiting': {
-        readonly zh: "等待确认";
-        readonly en: "Waiting for approval";
-    };
-    readonly 'claude-activity-done': {
-        readonly zh: "完成";
-        readonly en: "Done";
-    };
-    readonly 'claude-activity-done-tools': {
-        readonly zh: "完成 · {{count}} 个工具";
-        readonly en: {
-            readonly one: "Done · 1 tool";
-            readonly other: "Done · {{count}} tools";
-        };
-    };
-    readonly 'elicit-skip': {
-        readonly zh: "跳过";
-        readonly en: "Skip";
-    };
-    readonly 'elicit-skip-desc': {
-        readonly zh: "这一项不填";
-        readonly en: "Leave this field empty";
-    };
-    readonly 'elicit-optional': {
-        readonly zh: "{{title}}（可选）";
-        readonly en: "{{title}} (optional)";
-    };
-    readonly 'elicit-yes': {
-        readonly zh: "是";
-        readonly en: "Yes";
-    };
-    readonly 'elicit-no': {
-        readonly zh: "否";
-        readonly en: "No";
-    };
-    readonly 'elicit-send': {
-        readonly zh: "发送";
-        readonly en: "Send";
-    };
-    readonly 'elicit-send-desc': {
-        readonly zh: "把这些回答交给 MCP 服务器";
-        readonly en: "Give these answers to the MCP server";
-    };
-    readonly 'elicit-decline': {
-        readonly zh: "拒绝";
-        readonly en: "Decline";
-    };
-    readonly 'elicit-decline-desc': {
-        readonly zh: "不提供，告诉服务器你拒绝了";
-        readonly en: "Provide nothing; tell the server you declined";
-    };
-    readonly 'elicit-confirm': {
-        readonly zh: "把回答发送给 MCP 服务器 {{server}}？";
-        readonly en: "Send your answers to the MCP server {{server}}?";
-    };
-    readonly 'elicit-invalid': {
-        readonly zh: "请重新填写：{{reason}}";
-        readonly en: "Please answer again: {{reason}}";
-    };
-    readonly 'elicit-invalid-required': {
-        readonly zh: "这一项必填";
-        readonly en: "this field is required";
-    };
-    readonly 'elicit-invalid-choice': {
-        readonly zh: "请选择一项";
-        readonly en: "pick one of the options";
-    };
-    readonly 'elicit-invalid-number': {
-        readonly zh: "需要一个数字";
-        readonly en: "a number is expected";
-    };
-    readonly 'elicit-invalid-integer': {
-        readonly zh: "需要一个整数";
-        readonly en: "a whole number is expected";
-    };
-    readonly 'elicit-invalid-min': {
-        readonly zh: "不能小于 {{min}}";
-        readonly en: "must be at least {{min}}";
-    };
-    readonly 'elicit-invalid-max': {
-        readonly zh: "不能大于 {{max}}";
-        readonly en: "must be at most {{max}}";
-    };
-    readonly 'elicit-invalid-min-length': {
-        readonly zh: "至少 {{n}} 个字符";
-        readonly en: "at least {{n}} characters";
-    };
-    readonly 'elicit-invalid-max-length': {
-        readonly zh: "至多 {{n}} 个字符";
-        readonly en: "at most {{n}} characters";
-    };
-    readonly 'elicit-invalid-min-items': {
-        readonly zh: "至少选 {{n}} 项";
-        readonly en: "pick at least {{n}}";
-    };
-    readonly 'elicit-invalid-max-items': {
-        readonly zh: "至多选 {{n}} 项";
-        readonly en: "pick at most {{n}}";
-    };
-    readonly 'elicit-invalid-email': {
-        readonly zh: "需要一个邮箱地址";
-        readonly en: "an email address is expected";
-    };
-    readonly 'elicit-invalid-uri': {
-        readonly zh: "需要一个完整的网址（URI）";
-        readonly en: "a full URI is expected";
-    };
-    readonly 'elicit-invalid-date': {
-        readonly zh: "需要日期（YYYY-MM-DD）";
-        readonly en: "a date is expected (YYYY-MM-DD)";
-    };
-    readonly 'elicit-invalid-date-time': {
-        readonly zh: "需要日期时间（ISO 8601）";
-        readonly en: "a date and time is expected (ISO 8601)";
-    };
-    readonly 'elicit-invalid-pattern': {
-        readonly zh: "格式不符合要求";
-        readonly en: "the format does not match";
-    };
-    readonly 'elicit-invalid-json': {
-        readonly zh: "需要 JSON 形式的值";
-        readonly en: "a JSON value is expected";
-    };
-    readonly 'elicit-kind-number': {
-        readonly zh: "数字";
-        readonly en: "number";
-    };
-    readonly 'elicit-kind-integer': {
-        readonly zh: "整数";
-        readonly en: "whole number";
-    };
-    readonly 'elicit-hint-range': {
-        readonly zh: "{{kind}}，{{min}}–{{max}}";
-        readonly en: "{{kind}}, {{min}}–{{max}}";
-    };
-    readonly 'elicit-hint-min': {
-        readonly zh: "{{kind}}，不小于 {{min}}";
-        readonly en: "{{kind}}, at least {{min}}";
-    };
-    readonly 'elicit-hint-max': {
-        readonly zh: "{{kind}}，不大于 {{max}}";
-        readonly en: "{{kind}}, at most {{max}}";
-    };
-    readonly 'elicit-hint-json': {
-        readonly zh: "以 JSON 形式输入";
-        readonly en: "enter it as JSON";
-    };
-    readonly 'elicit-hint-format': {
-        readonly zh: "格式：{{format}}";
-        readonly en: "format: {{format}}";
-    };
-    readonly 'elicit-url-notice': {
-        readonly zh: "MCP 服务器 {{server}} 请你在浏览器中打开：{{url}}";
-        readonly en: "The MCP server {{server}} asks you to open: {{url}}";
-    };
-    readonly 'elicit-url-question': {
-        readonly zh: "MCP 服务器 {{server}} 需要你在浏览器中完成一步";
-        readonly en: "The MCP server {{server}} needs you to finish a step in the browser";
-    };
-    readonly 'elicit-url-detail': {
-        readonly zh: "打开下面的链接完成后选「继续」；完成时服务器也可能自动关闭这个面板";
-        readonly en: "Open the link below, then choose Continue; the server may also close this panel when it is done";
-    };
-    readonly 'elicit-url-accept': {
-        readonly zh: "继续（已打开链接）";
-        readonly en: "Continue (link opened)";
-    };
-    readonly 'elicit-url-accept-desc': {
-        readonly zh: "告诉服务器你同意并已打开链接";
-        readonly en: "Tell the server you agreed and opened the link";
-    };
-    readonly 'elicit-url-complete': {
-        readonly zh: "MCP 服务器 {{server}} 确认已完成";
-        readonly en: "The MCP server {{server}} confirmed it is done";
-    };
-    readonly 'elicit-url-missing': {
-        readonly zh: "MCP 服务器 {{server}} 请求打开链接却没有给出网址，已拒绝";
-        readonly en: "The MCP server {{server}} asked to open a link but gave none; declined";
-    };
-    readonly 'elicit-unsupported': {
-        readonly zh: "MCP 服务器 {{server}} 的请求（{{mode}}）无法在此显示，已拒绝";
-        readonly en: "The request of the MCP server {{server}} ({{mode}}) cannot be shown here; declined";
-    };
-    readonly 'claude-refusal-header': {
-        readonly zh: "模型拒绝";
-        readonly en: "Model declined";
-    };
-    readonly 'claude-refusal-question': {
-        readonly zh: "{{model}} 拒绝了这次请求，要换模型重试吗？";
-        readonly en: "{{model}} declined this request. Retry on another model?";
-    };
-    readonly 'claude-refusal-this-model': {
-        readonly zh: "当前模型";
-        readonly en: "The current model";
-    };
-    readonly 'claude-refusal-retry': {
-        readonly zh: "用 {{model}} 重试";
-        readonly en: "Retry on {{model}}";
-    };
-    readonly 'claude-refusal-retry-desc': {
-        readonly zh: "本次请求改由回退模型回答";
-        readonly en: "The fallback model answers this request";
-    };
-    readonly 'claude-refusal-cancel': {
-        readonly zh: "取消";
-        readonly en: "Cancel";
-    };
-    readonly 'claude-refusal-cancel-desc': {
-        readonly zh: "保留拒绝结果，结束本回合";
-        readonly en: "Keep the refusal and end the turn";
-    };
-    readonly 'claude-refusal-category': {
-        readonly zh: "拒绝类别：{{category}}";
-        readonly en: "Refusal category: {{category}}";
-    };
-    readonly 'claude-doctor-cli': {
-        readonly zh: "Claude CLI: {{path}}（{{source}}）· 版本 {{version}}";
-        readonly en: "Claude CLI: {{path}} ({{source}}) · version {{version}}";
-    };
-    readonly 'claude-doctor-bundled': {
-        readonly zh: "SDK 自带二进制";
-        readonly en: "SDK bundled binary";
-    };
-    readonly 'claude-doctor-sdk': {
-        readonly zh: "Claude Agent SDK {{version}}（已验证 {{validated}}）";
-        readonly en: "Claude Agent SDK {{version}} (validated {{validated}})";
-    };
-    readonly 'claude-doctor-mode': {
-        readonly zh: "起始权限模式: {{mode}}（来源 {{source}}）";
-        readonly en: "Start permission mode: {{mode}} (from {{source}})";
-    };
-    readonly 'codex-approve-accept': {
-        readonly zh: "是，执行";
-        readonly en: "Yes, proceed";
-    };
-    readonly 'codex-approve-decline': {
-        readonly zh: "否，跳过它继续";
-        readonly en: "No, continue without running it";
-    };
-    readonly 'codex-approve-cancel': {
-        readonly zh: "否，并告诉 Codex 怎么做";
-        readonly en: "No, and tell Codex what to do differently";
-    };
-    readonly 'codex-approve-decline-files': {
-        readonly zh: "否，不应用这些改动，继续";
-        readonly en: "No, continue without these changes";
-    };
-    readonly 'codex-approve-grant-turn': {
-        readonly zh: "是，本回合授予这些权限";
-        readonly en: "Yes, grant these permissions for this turn";
-    };
-    readonly 'codex-approve-deny-permissions': {
-        readonly zh: "否，不授予权限继续";
-        readonly en: "No, continue without permissions";
-    };
-    readonly 'codex-approve-stdin-name': {
-        readonly zh: "终端输入";
-        readonly en: "Terminal input";
-    };
-    readonly 'codex-approve-stdin': {
-        readonly zh: "向运行中的终端写入输入";
-        readonly en: "writes input to a running terminal";
-    };
-    readonly 'codex-approve-network-context': {
-        readonly zh: "访问网络主机 {{host}}（{{protocol}}）";
-        readonly en: "network access to {{host}} ({{protocol}})";
-    };
-    readonly 'codex-approve-extra-permissions': {
-        readonly zh: "额外权限：{{what}}";
-        readonly en: "extra permissions: {{what}}";
-    };
-    readonly 'codex-approve-cwd': {
-        readonly zh: "在 {{cwd}} 中运行";
-        readonly en: "runs in {{cwd}}";
-    };
-    readonly 'codex-approve-prefix': {
-        readonly zh: "是，以后以 `{{prefix}}` 开头的命令不再询问";
-        readonly en: "Yes, and don't ask again for commands that start with `{{prefix}}`";
-    };
-    readonly 'codex-approve-session-command': {
-        readonly zh: "是，本会话内此命令不再询问";
-        readonly en: "Yes, and don't ask again for this command in this session";
-    };
-    readonly 'codex-approve-session-files': {
-        readonly zh: "是，本会话内这些文件不再询问";
-        readonly en: "Yes, and don't ask again for these files";
-    };
-    readonly 'codex-approve-session-permissions': {
-        readonly zh: "是，本会话内都授予这些权限";
-        readonly en: "Yes, grant these permissions for this session";
-    };
-    readonly 'codex-approve-network': {
-        readonly zh: "是，以后允许访问 {{host}}";
-        readonly en: "Yes, and allow {{host}} in the future";
-    };
-    readonly 'codex-permissions-name': {
-        readonly zh: "额外权限";
-        readonly en: "Extra permissions";
-    };
-    readonly 'codex-perm-network': {
-        readonly zh: "联网";
-        readonly en: "network";
-    };
-    readonly 'codex-perm-read': {
-        readonly zh: "读取 {{paths}}";
-        readonly en: "read {{paths}}";
-    };
-    readonly 'codex-perm-write': {
-        readonly zh: "写入 {{paths}}";
-        readonly en: "write {{paths}}";
-    };
-    readonly 'codex-declined': {
-        readonly zh: "已拒绝";
-        readonly en: "Declined";
-    };
-    readonly 'codex-interrupted': {
-        readonly zh: "已中断";
-        readonly en: "Interrupted";
-    };
-    readonly 'codex-tool-failed': {
-        readonly zh: "执行失败";
-        readonly en: "Failed";
-    };
-    readonly 'codex-tool-unfinished': {
-        readonly zh: "回合结束时仍未完成";
-        readonly en: "Unfinished when the turn ended";
-    };
-    readonly 'codex-turn-failed': {
-        readonly zh: "回合失败";
-        readonly en: "The turn failed";
-    };
-    readonly 'codex-turn-start-failed': {
-        readonly zh: "Codex 没有接受这条消息：{{err}}";
-        readonly en: "Codex did not take this message: {{err}}";
-    };
-    readonly 'codex-steer-fallback': {
-        readonly zh: "当前回合无法插话，这条消息会在回合结束后发送";
-        readonly en: "The running turn cannot take this message now; it will be sent when the turn ends";
-    };
-    readonly 'codex-cancel-forced': {
-        readonly zh: "中断 15 秒未得到确认，已在本地结束本回合";
-        readonly en: "The interrupt was not confirmed within 15s; the turn was closed here";
-    };
-    readonly 'codex-session-closed': {
-        readonly zh: "Codex 会话已关闭";
-        readonly en: "The Codex session is closed";
-    };
-    readonly 'codex-retrying': {
-        readonly zh: "请求失败，Codex 正在重试：{{message}}";
-        readonly en: "The request failed; Codex is retrying: {{message}}";
-    };
-    readonly 'codex-rerouted': {
-        readonly zh: "模型已由 {{from}} 改为 {{to}}（{{reason}}）";
-        readonly en: "The model was rerouted from {{from}} to {{to}} ({{reason}})";
-    };
-    readonly 'codex-system-error': {
-        readonly zh: "Codex 报告该会话出现系统错误";
-        readonly en: "Codex reported a system error on this thread";
-    };
-    readonly 'codex-review-start': {
-        readonly zh: "开始代码审查：{{review}}";
-        readonly en: "Code review started: {{review}}";
-    };
-    readonly 'codex-auto-review-started': {
-        readonly zh: "自动审查中…";
-        readonly en: "Auto-review in progress…";
-    };
-    readonly 'codex-auto-review-approved': {
-        readonly zh: "自动审查：已批准";
-        readonly en: "Auto-review: approved";
-    };
-    readonly 'codex-auto-review-denied': {
-        readonly zh: "自动审查：已拒绝";
-        readonly en: "Auto-review: denied";
-    };
-    readonly 'codex-auto-review-ended': {
-        readonly zh: "自动审查已结束";
-        readonly en: "Auto-review ended";
-    };
-    readonly 'codex-strict-review': {
-        readonly zh: "本回合之后的命令需要先通过审查";
-        readonly en: "Further commands in this turn need a review first";
-    };
-    readonly 'codex-hook-started': {
-        readonly zh: "hook {{event}} 运行中…";
-        readonly en: "Hook {{event}} running…";
-    };
-    readonly 'codex-hook-done': {
-        readonly zh: "hook {{event}} 完成 {{duration}}";
-        readonly en: "Hook {{event}} finished {{duration}}";
-    };
-    readonly 'codex-hook-failed': {
-        readonly zh: "hook {{event}} 失败 {{duration}}";
-        readonly en: "Hook {{event}} failed {{duration}}";
-    };
-    readonly 'codex-mcp-failed': {
-        readonly zh: "MCP 服务器 {{name}} 启动失败：{{error}}";
-        readonly en: "The MCP server {{name}} failed to start: {{error}}";
-    };
-    readonly 'codex-thread-closed': {
-        readonly zh: "该会话已在别处关闭，仍可继续对话";
-        readonly en: "This thread was closed elsewhere; you can keep talking";
-    };
-    readonly 'codex-thread-archived': {
-        readonly zh: "该会话已在别处归档，仍可继续对话";
-        readonly en: "This thread was archived elsewhere; you can keep talking";
-    };
-    readonly 'codex-thread-deleted': {
-        readonly zh: "该会话已在别处删除";
-        readonly en: "This thread was deleted elsewhere";
-    };
-    readonly 'codex-rate-limit-reached': {
-        readonly zh: "已达到 Codex 用量上限（{{kind}}）";
-        readonly en: "The Codex usage limit is reached ({{kind}})";
-    };
-    readonly 'codex-hint-unauthorized': {
-        readonly zh: "Codex 凭据无效或已过期：在终端运行 codex login 重新登录";
-        readonly en: "The Codex credential is invalid or expired: sign in again with `codex login` in a terminal";
-    };
-    readonly 'codex-hint-context': {
-        readonly zh: "上下文已满：可以用 /compact 压缩后继续";
-        readonly en: "The context is full: run /compact and continue";
-    };
-    readonly 'codex-hint-limit': {
-        readonly zh: "已达到用量上限，稍后再试";
-        readonly en: "A usage limit is reached; try again later";
-    };
-    readonly 'codex-hint-sandbox': {
-        readonly zh: "沙箱出错：Linux 上请安装 bubblewrap（例如 apt install bubblewrap）";
-        readonly en: "Sandbox error: on Linux install bubblewrap (e.g. apt install bubblewrap)";
-    };
-    readonly 'codex-connection-lost': {
-        readonly zh: "Codex 进程退出，正在重连…";
-        readonly en: "The Codex process exited; reconnecting…";
-    };
-    readonly 'codex-connection-failed': {
-        readonly zh: "Codex 进程无法启动：{{err}}";
-        readonly en: "The Codex process cannot start: {{err}}";
-    };
-    readonly 'codex-connection-dead': {
-        readonly zh: "连接已断开且无法恢复，请重新打开会话";
-        readonly en: "The connection is gone for good; please reopen the session";
-    };
-    readonly 'codex-reconnected': {
-        readonly zh: "已重新连接 Codex";
-        readonly en: "Reconnected to Codex";
-    };
-    readonly 'codex-not-installed': {
-        readonly zh: "未找到 codex：npm i -g @openai/codex 或 brew install codex，或设置 CODEX_EXECUTABLE";
-        readonly en: "codex was not found: npm i -g @openai/codex or brew install codex, or set CODEX_EXECUTABLE";
-    };
-    readonly 'codex-too-old': {
-        readonly zh: "codex {{version}} 太旧（至少 {{min}}）：请升级";
-        readonly en: "codex {{version}} is too old (needs {{min}}): please upgrade";
-    };
-    readonly 'codex-auth-missing-hint': {
-        readonly zh: "未检测到 Codex 凭据：启动后用 /login 登录，或设置 OPENAI_API_KEY";
-        readonly en: "No Codex credential found: sign in with /login after start, or set OPENAI_API_KEY";
-    };
-    readonly 'codex-start-failed': {
-        readonly zh: "Codex app-server 启动失败：{{err}}";
-        readonly en: "The Codex app-server failed to start: {{err}}";
-    };
-    readonly 'codex-open-failed': {
-        readonly zh: "无法打开 Codex 会话：{{err}}";
-        readonly en: "Could not open the Codex thread: {{err}}";
-    };
-    readonly 'codex-thread-busy': {
-        readonly zh: "Codex 会话 {{id}} 正被另一个 Codex 进程使用，先关闭那边再打开";
-        readonly en: "The Codex thread {{id}} is in use by another Codex process; close it there first";
-    };
-    readonly 'codex-resume-not-found': {
-        readonly zh: "找不到 Codex 会话 {{id}}（{{err}}）";
-        readonly en: "The Codex thread {{id}} was not found ({{err}})";
-    };
-    readonly 'codex-version-drift': {
-        readonly zh: "codex {{version}} 未经本版 dsh-tui 验证（已验证：{{validated}}），继续运行";
-        readonly en: "codex {{version}} is not validated with this dsh-tui (validated: {{validated}}); continuing";
-    };
-    readonly 'codex-doctor-cli': {
-        readonly zh: "Codex CLI: {{path}}（{{source}}）· 版本 {{version}}";
-        readonly en: "Codex CLI: {{path}} ({{source}}) · version {{version}}";
-    };
-    readonly 'codex-doctor-home': {
-        readonly zh: "Codex 主目录: {{home}}";
-        readonly en: "Codex home: {{home}}";
-    };
-    readonly 'codex-doctor-thread': {
-        readonly zh: "Codex 会话: {{id}} · provider {{provider}} · 模型 {{model}}";
-        readonly en: "Codex thread: {{id}} · provider {{provider}} · model {{model}}";
-    };
-    readonly 'codex-doctor-mode': {
-        readonly zh: "权限模式: {{mode}}";
-        readonly en: "Permission mode: {{mode}}";
-    };
-    readonly 'codex-doctor-bubblewrap': {
-        readonly zh: "未找到 bubblewrap：Codex 改用自带沙箱；建议用系统包管理器安装 bubblewrap";
-        readonly en: "bubblewrap was not found: Codex uses its bundled sandbox; installing bubblewrap from the system package manager is recommended";
-    };
-    readonly 'codex-mode-read-only': {
-        readonly zh: "只读";
-        readonly en: "Read Only";
-    };
-    readonly 'codex-mode-read-only-desc': {
-        readonly zh: "只读取文件；命令和修改需审批";
-        readonly en: "Read files; commands and changes require approval";
-    };
-    readonly 'codex-mode-auto': {
-        readonly zh: "默认";
-        readonly en: "Default";
-    };
-    readonly 'codex-mode-auto-desc': {
-        readonly zh: "可修改工作区；工作区外和网络操作需审批";
-        readonly en: "Edit the workspace; ask before outside-workspace or network access";
-    };
-    readonly 'codex-mode-full-access': {
-        readonly zh: "完全访问";
-        readonly en: "Full Access";
-    };
-    readonly 'codex-mode-full-access-desc': {
-        readonly zh: "关闭沙箱和审批，仅通过显式选择进入";
-        readonly en: "Disable sandbox and approvals; explicit selection only";
-    };
-    readonly 'codex-mode-plan': {
-        readonly zh: "计划";
-        readonly en: "Plan";
-    };
-    readonly 'codex-mode-plan-desc': {
-        readonly zh: "先调研和规划，保留当前权限档";
-        readonly en: "Research and plan, preserving the current permissions";
-    };
-    readonly 'codex-mode-invalid': {
-        readonly zh: "未知 Codex 模式：{{mode}}";
-        readonly en: "Unknown Codex mode: {{mode}}";
-    };
-    readonly 'codex-settings-deferred': {
-        readonly zh: "当前 Codex 版本不支持即时改设置，选择将在下一回合生效";
-        readonly en: "This Codex version cannot update idle settings; your choices apply on the next turn";
-    };
-    readonly 'codex-capability-unavailable': {
-        readonly zh: "当前 Codex 版本不支持 {{feature}}，请升级";
-        readonly en: "This Codex version does not support {{feature}}; please upgrade";
-    };
-    readonly 'codex-effort-none': {
-        readonly zh: "无";
-        readonly en: "None";
-    };
-    readonly 'codex-effort-minimal': {
-        readonly zh: "极低";
-        readonly en: "Minimal";
-    };
-    readonly 'codex-effort-low': {
-        readonly zh: "低";
-        readonly en: "Low";
-    };
-    readonly 'codex-effort-medium': {
-        readonly zh: "中";
-        readonly en: "Medium";
-    };
-    readonly 'codex-effort-high': {
-        readonly zh: "高";
-        readonly en: "High";
-    };
-    readonly 'codex-effort-xhigh': {
-        readonly zh: "极高";
-        readonly en: "Extra high";
-    };
-    readonly 'codex-effort-ultra': {
-        readonly zh: "超高";
-        readonly en: "Ultra";
-    };
-    readonly 'codex-command-idle': {
-        readonly zh: "请先结束或中断当前回合";
-        readonly en: "Finish or interrupt the current turn first";
-    };
-    readonly 'codex-command-review': {
-        readonly zh: "审查未提交改动、分支、提交或自定义范围";
-        readonly en: "Review working changes, a branch, a commit, or custom instructions";
-    };
-    readonly 'codex-command-diff': {
-        readonly zh: "显示最近回合的文件差异";
-        readonly en: "Show the latest turn's file diff";
-    };
-    readonly 'codex-command-plan': {
-        readonly zh: "切换到 Plan 模式，可附带提示词";
-        readonly en: "Enter Plan mode, optionally with a prompt";
-    };
-    readonly 'codex-command-usage': {
-        readonly zh: "查看 Codex 额度和重置时间";
-        readonly en: "Show Codex usage limits and reset times";
-    };
-    readonly 'codex-diff-empty': {
-        readonly zh: "没有文件差异";
-        readonly en: "No file differences";
-    };
-    readonly 'codex-usage-window': {
-        readonly zh: "{{name}}：已用 {{used}}% · 重置 {{reset}}";
-        readonly en: "{{name}}: {{used}}% used · resets {{reset}}";
-    };
-    readonly 'codex-usage-credits': {
-        readonly zh: "额度余额 {{balance}} · 不限量：{{unlimited}}";
-        readonly en: "Credits {{balance}} · unlimited: {{unlimited}}";
-    };
-    readonly 'codex-usage-unavailable': {
-        readonly zh: "当前 provider 未提供额度信息";
-        readonly en: "The current provider supplies no usage-limit information";
-    };
-    readonly 'codex-yes': {
-        readonly zh: "是";
-        readonly en: "yes";
-    };
-    readonly 'codex-no': {
-        readonly zh: "否";
-        readonly en: "no";
-    };
-    readonly 'codex-question-auto-answered': {
-        readonly zh: "问卷等待超时，已按服务端设置选择默认答案";
-        readonly en: "The question timed out; the server's default answer was selected";
-    };
-    readonly 'codex-plan-implement': {
-        readonly zh: "要实施这个计划吗？";
-        readonly en: "Implement this plan?";
-    };
-    readonly 'codex-plan-yes': {
-        readonly zh: "是，实施这个计划";
-        readonly en: "Yes, implement this plan";
-    };
-    readonly 'codex-plan-clear': {
-        readonly zh: "是，清空上下文后实施";
-        readonly en: "Yes, clear context and implement";
-    };
-    readonly 'codex-plan-stay': {
-        readonly zh: "否，留在 Plan 模式";
-        readonly en: "No, stay in Plan mode";
-    };
-    readonly 'codex-plan-action-failed': {
-        readonly zh: "无法开始实施计划：{{error}}";
-        readonly en: "Could not start implementing the plan: {{error}}";
-    };
-    readonly 'codex-bwrap-warning': {
-        readonly zh: "未找到 bubblewrap，沙箱命令可能失败。请安装（如 apt install bubblewrap），或在 /permission 中明确选择完全访问";
-        readonly en: "bubblewrap was not found; sandboxed commands may fail. Install it (e.g. apt install bubblewrap), or explicitly select Full Access in /permission";
-    };
-    readonly 'codex-model-waiting': {
-        readonly zh: "等待模型响应…";
-        readonly en: "Waiting for the model…";
-    };
-    readonly 'codex-model-stalled': {
-        readonly zh: "模型长时间无响应，可按 Esc 中断";
-        readonly en: "The model has not responded for a long time; press Esc to interrupt";
-    };
-    readonly 'codex-working-command': {
-        readonly zh: "运行 {{command}}";
-        readonly en: "Running {{command}}";
-    };
-    readonly 'codex-working-files': {
-        readonly zh: "编辑 {{files}}";
-        readonly en: "Editing {{files}}";
-    };
-    readonly 'codex-working-subagents': {
-        readonly zh: "等待子代理";
-        readonly en: "Waiting for subagents";
-    };
-    readonly 'codex-working-thinking': {
-        readonly zh: "思考中…";
-        readonly en: "Thinking…";
-    };
-    readonly 'codex-channel-url-required': {
-        readonly zh: "渠道连接缺少 base URL，请用 /channel 配置";
-        readonly en: "The channel connection has no base URL; configure it with /channel";
-    };
-    readonly 'codex-channel-token-missing': {
-        readonly zh: "渠道 {{name}} 缺少可用令牌，请用 /channel 补充";
-        readonly en: "Channel {{name}} has no usable token; add one with /channel";
-    };
-    readonly 'codex-channel-store-unavailable': {
-        readonly zh: "宿主未提供渠道令牌库，无法保存令牌";
-        readonly en: "The host did not provide a channel token store; the token cannot be saved";
-    };
-    readonly 'codex-channel-token-write-failed': {
-        readonly zh: "渠道令牌保存失败，连接未更新";
-        readonly en: "The channel token could not be saved; the connection was not updated";
-    };
-    readonly 'codex-auth-login-needed': {
-        readonly zh: "Codex 需要凭据：用 /login 登录";
-        readonly en: "Codex needs credentials: sign in with /login";
-    };
-    readonly 'codex-auth-refresh-failed': {
-        readonly zh: "ChatGPT 订阅令牌刷新失败，已停止注入；用 /login 重新登录，或使用自己的 Codex 登录";
-        readonly en: "The ChatGPT subscription token refresh failed; injection stopped. Use /login again or your own Codex login";
-    };
-    readonly 'codex-auth-login-failed': {
-        readonly zh: "Codex 登录未完成，已停止托管令牌注入；请用 /login 重试";
-        readonly en: "Codex login did not complete; managed token injection stopped. Retry with /login";
-    };
-    readonly 'codex-auth-claims-missing': {
-        readonly zh: "内置 OAuth 令牌缺少 ChatGPT 账户信息，未注入；请用 /login 重新登录";
-        readonly en: "The built-in OAuth token has no ChatGPT account identity and was not injected; sign in again with /login";
-    };
-    readonly 'codex-auth-source-channel': {
-        readonly zh: "凭据来源：渠道 {{name}}";
-        readonly en: "Credential source: channel {{name}}";
-    };
-    readonly 'codex-auth-source-oauth': {
-        readonly zh: "凭据来源：dsh-auth ChatGPT 订阅";
-        readonly en: "Credential source: dsh-auth ChatGPT subscription";
-    };
-    readonly 'codex-auth-source-native': {
-        readonly zh: "凭据来源：Codex 自己的登录";
-        readonly en: "Credential source: Codex native login";
-    };
-    readonly 'codex-auth-source-api-key': {
-        readonly zh: "凭据来源：API key";
-        readonly en: "Credential source: API key";
-    };
-    readonly 'codex-auth-source-missing': {
-        readonly zh: "凭据来源：未登录";
-        readonly en: "Credential source: not signed in";
-    };
-    readonly 'codex-auth-source-unknown': {
-        readonly zh: "凭据来源：由 Codex 配置管理（无法确定）";
-        readonly en: "Credential source: managed by Codex configuration (unknown)";
-    };
-    readonly 'codex-auth-plan': {
-        readonly zh: "订阅：{{plan}}";
-        readonly en: "Subscription: {{plan}}";
-    };
-    readonly 'codex-auth-host': {
-        readonly zh: "Provider 主机：{{host}}";
-        readonly en: "Provider host: {{host}}";
-    };
-    readonly 'codex-auth-route-blocked': {
-        readonly zh: "当前路由不接受内置订阅令牌；请使用自己的 Codex 登录或 /channel 渠道";
-        readonly en: "This route does not accept built-in subscription tokens; use your own Codex login or /channel";
-    };
-    readonly 'codex-auth-channel-active': {
-        readonly zh: "当前使用渠道凭据；请在 /channel 管理连接，不改动 OpenAI 登录";
-        readonly en: "Channel credentials are active; manage the connection in /channel without changing OpenAI login";
-    };
-    readonly 'codex-auth-api-key-required': {
-        readonly zh: "请输入非空 API key";
-        readonly en: "Enter a non-empty API key";
-    };
-    readonly 'codex-login-choose': {
-        readonly zh: "选择 Codex 登录方式";
-        readonly en: "Choose a Codex sign-in method";
-    };
-    readonly 'codex-login-oauth': {
-        readonly zh: "内置 ChatGPT OAuth";
-        readonly en: "Built-in ChatGPT OAuth";
-    };
-    readonly 'codex-login-oauth-desc': {
-        readonly zh: "复用 dsh-auth 登录，只向第一方路由提供内存令牌";
-        readonly en: "Use dsh-auth; supply in-memory tokens only to first-party routes";
-    };
-    readonly 'codex-login-device': {
-        readonly zh: "Codex 设备码登录";
-        readonly en: "Codex device-code login";
-    };
-    readonly 'codex-login-device-desc': {
-        readonly zh: "在浏览器输入设备码，凭据由 Codex 保存";
-        readonly en: "Enter a device code in a browser; Codex stores the credential";
-    };
-    readonly 'codex-login-api-key': {
-        readonly zh: "API key";
-        readonly en: "API key";
-    };
-    readonly 'codex-login-api-key-prompt': {
-        readonly zh: "输入 OpenAI API key";
-        readonly en: "Enter an OpenAI API key";
-    };
-    readonly 'codex-login-api-key-storage': {
-        readonly zh: "此方式会把 API key 写入用户的 Codex 凭据存储";
-        readonly en: "This method writes the API key into your Codex credential store";
-    };
-    readonly 'codex-login-device-code': {
-        readonly zh: "在验证页面输入设备码：{{code}}";
-        readonly en: "Enter this device code on the verification page: {{code}}";
-    };
-    readonly 'codex-login-device-wait': {
-        readonly zh: "等待浏览器授权完成；可取消此次登录";
-        readonly en: "Waiting for browser authorization; you can cancel this login";
-    };
-    readonly 'codex-login-cancel': {
-        readonly zh: "取消此次登录";
-        readonly en: "Cancel this login";
-    };
-    readonly 'codex-login-success': {
-        readonly zh: "Codex 登录已完成";
-        readonly en: "Codex sign-in completed";
-    };
-    readonly 'codex-goal-usage-limited': {
-        readonly zh: "Codex 用量额度已达到上限";
-        readonly en: "The Codex usage limit was reached";
-    };
-    readonly 'codex-goal-budget-limited': {
-        readonly zh: "目标的 token 预算已用尽";
-        readonly en: "The goal token budget was exhausted";
-    };
-    readonly 'codex-goal-blocked': {
-        readonly zh: "Codex 目标暂时受阻";
-        readonly en: "The Codex goal is blocked";
-    };
-    readonly 'codex-tasks-unsupported': {
-        readonly zh: "此 Codex 不支持后台终端监控，任务能力已关闭";
-        readonly en: "This Codex does not support background terminal monitoring; task controls are unavailable";
-    };
-    readonly 'codex-terminal-ended': {
-        readonly zh: "终端已不在运行列表中；退出状态不可用";
-        readonly en: "The terminal is no longer running; exit status is unavailable";
-    };
-    readonly 'codex-terminal-stopped': {
-        readonly zh: "后台终端已停止";
-        readonly en: "The background terminal was stopped";
-    };
-    readonly 'codex-terminal-no-output': {
-        readonly zh: "此后台终端暂没有可读取的输出";
-        readonly en: "No readable output is available for this background terminal";
-    };
-    readonly 'codex-side-open-failed': {
-        readonly zh: "无法创建临时旁问会话";
-        readonly en: "Could not create the ephemeral side-question thread";
-    };
-    readonly 'codex-images-too-many': {
-        readonly zh: "Codex 一条消息最多接受 {{n}} 张图片";
-        readonly en: "Codex accepts at most {{n}} images per message";
-    };
-    readonly 'codex-image-type-refused': {
-        readonly zh: "图片 {{name}} 的格式 {{type}} 不受 Codex 支持";
-        readonly en: "Image {{name}} uses {{type}}, which Codex does not accept";
-    };
-    readonly 'codex-image-unreadable': {
-        readonly zh: "无法读取图片 {{name}}";
-        readonly en: "Image {{name}} could not be read";
-    };
-    readonly 'codex-image-too-large': {
-        readonly zh: "图片 {{name}} 超过 Codex 的 {{mb}} MiB 限制";
-        readonly en: "Image {{name}} exceeds the Codex {{mb}} MiB limit";
-    };
-    readonly 'codex-images-too-large': {
-        readonly zh: "本条消息的图片总大小超过 {{mb}} MiB";
-        readonly en: "The message images exceed {{mb}} MiB in total";
-    };
-    readonly 'codex-image-dimensions-refused': {
-        readonly zh: "图片 {{name}} 超过 {{px}} 像素限制，请缩小后重试";
-        readonly en: "Image {{name}} exceeds the {{px}} pixel limit; resize it and retry";
-    };
-    readonly 'codex-history-fetch-failed': {
-        readonly zh: "Codex 更早历史连续读取失败，暂时停止预取；可重新打开会话后重试";
-        readonly en: "Earlier Codex history could not be read after three attempts; reopen the session to retry";
-    };
-    readonly 'codex-preview-image': {
-        readonly zh: "[图片]";
-        readonly en: "[Image]";
-    };
-    readonly 'codex-archive-busy': {
-        readonly zh: "该 Codex 会话由活动中的内部任务使用，暂时无法归档";
-        readonly en: "This Codex thread is owned by an active internal worker and cannot be archived yet";
-    };
-    readonly 'codex-orphan-request': {
-        readonly zh: "无法确定 Codex 子代理请求所属会话，已取消该请求";
-        readonly en: "Could not find the session owning a Codex subagent request; the request was cancelled";
-    };
-    readonly 'codex-channel-url-invalid': {
-        readonly zh: "渠道 URL 只接受 HTTPS（HTTP 仅限 localhost/127.0.0.1），不能含账号密码、查询串、片段或疑似密钥路径";
-        readonly en: "A channel URL must use HTTPS (HTTP only on localhost/127.0.0.1), without userinfo, query, fragment, or key-like path segments";
-    };
-    readonly 'codex-channel-id-invalid': {
-        readonly zh: "渠道 ID 只能含字母、数字、下划线和连字符";
-        readonly en: "A channel ID may only contain letters, digits, underscores and hyphens";
-    };
-    readonly 'codex-channel-wire-api-invalid': {
-        readonly zh: "Codex 渠道仅支持 Responses API";
-        readonly en: "Codex channels only support the Responses API";
-    };
-    readonly 'codex-channel-env-invalid': {
-        readonly zh: "渠道 env 只能存非凭据变量；令牌请填入令牌输入框";
-        readonly en: "Channel env may only hold non-credential variables; use the token input for credentials";
-    };
-    readonly 'codex-anchor-missing': {
-        readonly zh: "找不到这条消息的原生回合，无法 fork 或回退";
-        readonly en: "The native turn for this message is unavailable; it cannot be forked or rewound";
-    };
-    readonly 'codex-rewind-files-unsupported': {
-        readonly zh: "Codex 仅支持对话回退，不恢复工作区文件";
-        readonly en: "Codex supports conversation rewind only; workspace files are not restored";
-    };
-    readonly 'codex-rewind-load-older': {
-        readonly zh: "请先加载更早的消息，再回退到这一回合";
-        readonly en: "Load earlier messages before rewinding to this turn";
-    };
-    readonly 'codex-goals-unsupported': {
-        readonly zh: "此 Codex 不支持目标管理，目标能力已关闭";
-        readonly en: "This Codex does not support goal management; goal controls are unavailable";
-    };
-    readonly 'codex-subagent-unavailable': {
-        readonly zh: "无法读取此 Codex 子代理的历史";
-        readonly en: "This Codex subagent history is unavailable";
-    };
-    readonly 'codex-reconnect-incomplete': {
-        readonly zh: "Codex 恢复缺口超过读取预算或游标失效，请重新打开会话";
-        readonly en: "Codex recovery exceeded its history budget or could not reach a known turn; reopen the session";
-    };
     readonly 'cmd-unavailable-backend': {
         readonly zh: "/{{cmd}} 在 {{backend}} 内核下不可用";
         readonly en: "/{{cmd}} is not available on the {{backend}} kernel";
@@ -1964,10 +626,6 @@ declare const dict: {
         readonly zh: "上下文窗口: {{window}} tokens";
         readonly en: "Context window: {{window}} tokens";
     };
-    readonly 'doctor-unknown': {
-        readonly zh: "未知";
-        readonly en: "unknown";
-    };
     readonly 'doctor-session': {
         readonly zh: "会话: {{id}}";
         readonly en: "Session: {{id}}";
@@ -2048,6 +706,10 @@ declare const dict: {
         readonly zh: "{{kind}} 任务";
         readonly en: "{{kind}} task";
     };
+    readonly 'task-complete-notification': {
+        readonly zh: "dsh-TUI · 任务已完成";
+        readonly en: "dsh-TUI · Task complete";
+    };
     readonly 'subagent-background': {
         readonly zh: "后台";
         readonly en: "background";
@@ -2092,10 +754,6 @@ declare const dict: {
         readonly zh: "无法读取该会话日志 · {{err}}";
         readonly en: "Could not read that session log · {{err}}";
     };
-    readonly 'rewind-first-message': {
-        readonly zh: "不能回退到第一条消息之前";
-        readonly en: "Cannot rewind past the very first message";
-    };
     readonly 'rewind-noop': {
         readonly zh: "该点之后没有可回退的内容";
         readonly en: "Nothing to rewind past this point";
@@ -2136,10 +794,6 @@ declare const dict: {
         readonly zh: "仅恢复文件（会话不变）";
         readonly en: "Restore files only (conversation unchanged)";
     };
-    readonly 'rename-failed': {
-        readonly zh: "重命名失败 · {{err}}";
-        readonly en: "Rename failed · {{err}}";
-    };
     readonly 'session-archive-failed': {
         readonly zh: "归档会话失败 · {{err}}";
         readonly en: "Archiving the session failed · {{err}}";
@@ -2180,6 +834,10 @@ declare const dict: {
         readonly zh: "已分叉（{{id}}）——仍在原会话中\n新进程进入分叉：{{command}}";
         readonly en: "Forked ({{id}}) — still in the original session\nEnter the fork in a new process: {{command}}";
     };
+    readonly 'fork-done-unstored': {
+        readonly zh: "已分叉（{{id}}）——仍在原会话中\n源会话还没有内容，分叉副本没有日志可恢复";
+        readonly en: "Forked ({{id}}) — still in the original session\nThe source session has no content yet, so the fork has no log to resume";
+    };
     readonly 'tree-title': {
         readonly zh: "会话树";
         readonly en: "Session tree";
@@ -2408,6 +1066,34 @@ declare const dict: {
         readonly zh: "新建会话失败 · {{err}}";
         readonly en: "New session failed · {{err}}";
     };
+    readonly 'startup-not-ready': {
+        readonly zh: "{{backend}} 还在启动——就绪后按 Enter 发送";
+        readonly en: "{{backend}} is still starting — press Enter to send once it is ready";
+    };
+    readonly 'startup-open-failed': {
+        readonly zh: "{{backend}} 会话没能打开：{{err}}";
+        readonly en: "{{backend}} session failed to open: {{err}}";
+    };
+    readonly 'startup-open-failed-hint': {
+        readonly zh: "/new 重试 · /kernel 切换内核 · /quit 退出";
+        readonly en: "/new to retry · /kernel to switch kernel · /quit to exit";
+    };
+    readonly 'startup-compose-failed-hint': {
+        readonly zh: "DSH 没能启动 · /kernel 切换内核 · /quit 退出";
+        readonly en: "DSH did not start · /kernel to switch kernel · /quit to exit";
+    };
+    readonly 'startup-compose-failed-hint-log': {
+        readonly zh: "启动日志：{{path}} · /kernel 切换内核 · /quit 退出";
+        readonly en: "Startup log: {{path}} · /kernel to switch kernel · /quit to exit";
+    };
+    readonly 'status-starting': {
+        readonly zh: "正在启动 {{backend}}…";
+        readonly en: "Starting {{backend}}…";
+    };
+    readonly 'host-dsh-unavailable': {
+        readonly zh: "没有用上已安装的 dsh：{{reason}}";
+        readonly en: "Not using the installed dsh: {{reason}}";
+    };
     readonly 'resume-raced': {
         readonly zh: "会话打开期间当前会话开始了新的回合，已取消恢复；该回合在当前会话中继续";
         readonly en: "The current session started a turn while the other one was opening — the resume was cancelled; the turn continues here";
@@ -2424,22 +1110,14 @@ declare const dict: {
         readonly zh: "回合运行中，无法切换模型";
         readonly en: "Cannot switch models while a turn is running";
     };
-    readonly 'model-switch-unavailable': {
-        readonly zh: "模型切换不可用——会话服务未加载";
-        readonly en: "Model switch unavailable — session services not loaded";
-    };
-    readonly 'model-switch-fork-failed': {
-        readonly zh: "无法切换模型 · {{err}}";
-        readonly en: "Cannot switch models · {{err}}";
+    readonly 'model-switch-legacy-unavailable': {
+        readonly zh: "同会话切换模型需要 DSH >= 0.1.2-alpha.3，请先升级 DSH";
+        readonly en: "Switching models within a session requires DSH >= 0.1.2-alpha.3; upgrade DSH first";
     };
     readonly 'model-switch-failed': {
         readonly zh: "模型切换失败 · {{err}}";
         readonly en: "Model switch failed · {{err}}";
     };
-    readonly 'model-switch-attach-failed': {
-        readonly zh: "模型已切换，但工作区挂载失败 · {{err}}";
-        readonly en: "Model switched, but workspace attachment failed · {{err}}";
-    };
     readonly 'model-usage': {
         readonly zh: "用法：/model <provider/model>（如 deepseek/deepseek-flash）";
         readonly en: "Usage: /model <provider/model> (e.g. deepseek/deepseek-flash)";
@@ -3679,8 +2357,8 @@ declare const dict: {
         readonly en: "btw";
     };
     readonly 'btw-thread-empty': {
-        readonly zh: "还没有侧问。输入 /btw <问题>，或在下方直接追问。";
-        readonly en: "No side questions yet. Type /btw <question>, or ask a follow-up below.";
+        readonly zh: "还没有侧问。输入 /btw <问题>，或点击下方输入框开始提问。";
+        readonly en: "No side questions yet. Type /btw <question>, or click the input below to ask.";
     };
     readonly 'btw-thread-new': {
         readonly zh: "新话题";
@@ -3702,6 +2380,18 @@ declare const dict: {
         readonly zh: "输入追问…（Enter 发送 · Esc 回到对话 · Tab 切列表）";
         readonly en: "Type a follow-up… (Enter send · Esc back to chat · Tab list)";
     };
+    readonly 'btw-input-placeholder': {
+        readonly zh: "点击或 Enter 提问";
+        readonly en: "Click or press Enter to ask";
+    };
+    readonly 'btw-input-hint-edit': {
+        readonly zh: "Enter 发送 · Esc";
+        readonly en: "Enter send · Esc";
+    };
+    readonly 'btw-empty-lines': {
+        readonly zh: "旁路问答不打断主线：答案只留在这里，不进主聊天与会话记录。";
+        readonly en: "Side questions never derail the main line: answers stay here, out of the main chat and session log.";
+    };
     readonly 'btw-thread-busy': {
         readonly zh: "上一个侧问还在回答，等它结束再追问";
         readonly en: "Still answering the last side question; ask again once it finishes";
@@ -3718,10 +2408,6 @@ declare const dict: {
         readonly zh: "有新回答";
         readonly en: "New answer";
     };
-    readonly 'btw-thread-send-to-chat': {
-        readonly zh: "发送到聊天";
-        readonly en: "Send to chat";
-    };
     readonly 'btw-thread-answer-attached': {
         readonly zh: "答案已附加到下一次主聊天提交";
         readonly en: "Answer attached to your next main chat submission";
@@ -3731,8 +2417,12 @@ declare const dict: {
         readonly en: "Answer exceeded the attach limit and was truncated";
     };
     readonly 'btw-fullscreen-title': {
-        readonly zh: "btw 侧问线程";
-        readonly en: "btw side thread";
+        readonly zh: "侧问线程";
+        readonly en: "Side thread";
+    };
+    readonly 'btw-scene-hints': {
+        readonly zh: "Enter 追问 · ↑/↓ 滚动 · n 新话题 · s 送聊天 · c 复制 · Esc 返回";
+        readonly en: "Enter ask · ↑/↓ scroll · n new · s to chat · c copy · Esc back";
     };
     readonly 'btw-panel-unavailable': {
         readonly zh: "btw 面板未启用（/settings → dsh-tui.sidePanel.panels）";
@@ -3962,10 +2652,6 @@ declare const dict: {
         readonly zh: "推理强度 → {{name}}";
         readonly en: "Reasoning effort → {{name}}";
     };
-    readonly 'effort-invalid': {
-        readonly zh: "未知推理等级 {{id}}（当前模型可选：{{ids}}）";
-        readonly en: "Unknown reasoning effort {{id}} (this model offers: {{ids}})";
-    };
     readonly 'effort-current': {
         readonly zh: "当前推理强度 {{name}}";
         readonly en: "Current reasoning effort {{name}}";
@@ -4022,6 +2708,10 @@ declare const dict: {
         readonly zh: "切换权限预设（沙箱模式 + 审批策略）";
         readonly en: "Switch the permission preset (sandbox mode + approval policy)";
     };
+    readonly 'upstream-retry-enabled': {
+        readonly zh: "已为当前渠道 {{routes}} 启用上游断链自动重试（最多重试 5 次；cordis.yml upstreamRetry: false 可关闭）";
+        readonly en: "Upstream auto-retry enabled for {{routes}} (the route in use) — up to 5 retries per request (opt out with upstreamRetry: false in cordis.yml)";
+    };
     readonly 'logo-tagline': {
         readonly zh: "探索未至之境！";
         readonly en: "Explore the uncharted!";
@@ -4353,10 +3043,6 @@ declare const dict: {
         readonly zh: "信号 {{name}}";
         readonly en: "signal {{name}}";
     };
-    readonly 'tool-name-bash': {
-        readonly zh: "Bash";
-        readonly en: "Bash";
-    };
     readonly 'tool-name-powershell': {
         readonly zh: "PowerShell";
         readonly en: "PowerShell";
@@ -4377,10 +3063,6 @@ declare const dict: {
         readonly zh: "写入";
         readonly en: "Write";
     };
-    readonly 'tool-name-edit': {
-        readonly zh: "编辑";
-        readonly en: "Edit";
-    };
     readonly 'tool-name-todo_write': {
         readonly zh: "待办清单";
         readonly en: "TodoWrite";
@@ -4596,6 +3278,10 @@ declare const dict: {
         readonly zh: "全屏设置已保存，重启 dsh-tui 后生效";
         readonly en: "Fullscreen preference saved — restart dsh-tui to apply";
     };
+    readonly 'settings-launchpad-restart': {
+        readonly zh: "启动页设置已保存，重启 dsh-tui 后生效";
+        readonly en: "Launchpad preference saved — restart dsh-tui to apply";
+    };
     readonly 'settings-terminal-images-restart': {
         readonly zh: "图片预览设置已保存，使用 /restart 重启 TUI 后生效";
         readonly en: "Image preview preference saved — use /restart to apply";
@@ -4840,6 +3526,14 @@ declare const dict: {
         readonly zh: "重启生效";
         readonly en: "applies on restart";
     };
+    readonly 'settings-badge-unreadable': {
+        readonly zh: "设置文件无法读取——已回退默认；保存前会先备份原文件";
+        readonly en: "settings file unreadable — defaults shown; saving backs up the original first";
+    };
+    readonly 'settings-badge-recovered': {
+        readonly zh: "损坏的设置文件已备份到 {{backup}}";
+        readonly en: "the broken settings file was backed up to {{backup}}";
+    };
     readonly 'settings-badge-dirty': {
         readonly zh: "未保存";
         readonly en: "unsaved";
@@ -5100,17 +3794,49 @@ declare const dict: {
         readonly zh: "最近使用";
         readonly en: "Recently used";
     };
-    readonly 'picker-group-count': {
-        readonly zh: "{{count}} 个模型";
-        readonly en: "{{count}} models";
+    readonly 'hint-model-provider': {
+        readonly zh: "**Tab** / **Shift+Tab** 提供商";
+        readonly en: "**Tab** / **Shift+Tab** providers";
+    };
+    readonly 'hint-model-navigation': {
+        readonly zh: "**↑/↓** 模型";
+        readonly en: "**↑/↓** model";
+    };
+    readonly 'hint-model-effort': {
+        readonly zh: "**←/→** 调整";
+        readonly en: "**←/→** adjust";
+    };
+    readonly 'hint-model-select': {
+        readonly zh: "**Enter** 选择";
+        readonly en: "**Enter** select";
+    };
+    readonly 'hint-model-cancel': {
+        readonly zh: "**Esc** 取消";
+        readonly en: "**Esc** cancel";
+    };
+    readonly 'picker-recents-empty': {
+        readonly zh: "暂无最近使用的模型，按 Tab 查看提供商";
+        readonly en: "No recent models; press Tab to browse providers";
+    };
+    readonly 'picker-models-empty': {
+        readonly zh: "暂无可用模型";
+        readonly en: "No models available";
     };
-    readonly 'hint-model-groups': {
-        readonly zh: "**Enter** 查看模型 · Esc 退出";
-        readonly en: "**Enter** to view models · Esc to exit";
+    readonly 'picker-effort-loading': {
+        readonly zh: "正在加载…";
+        readonly en: "Loading…";
     };
-    readonly 'hint-model-back': {
-        readonly zh: "**Enter** 切换模型 · Esc/⌫ 返回上级";
-        readonly en: "**Enter** to switch · Esc/⌫ to go back";
+    readonly 'picker-effort-error': {
+        readonly zh: "读取失败";
+        readonly en: "Failed to load";
+    };
+    readonly 'picker-effort-unavailable': {
+        readonly zh: "不支持";
+        readonly en: "Unavailable";
+    };
+    readonly 'picker-effort-default': {
+        readonly zh: "默认";
+        readonly en: "Default";
     };
     readonly 'picker-title-skills': {
         readonly zh: "技能";
@@ -5184,9 +3910,9 @@ declare const dict: {
         readonly zh: "正在加载模型";
         readonly en: "Loading models";
     };
-    readonly 'model-loading-subtitle': {
-        readonly zh: "正在查询 provider…";
-        readonly en: "Querying the provider…";
+    readonly 'model-load-failed': {
+        readonly zh: "模型列表加载失败";
+        readonly en: "Failed to load the model list";
     };
     readonly 'model-switching': {
         readonly zh: "正在切换模型到 {{name}}…";
@@ -5308,12 +4034,12 @@ declare const dict: {
         readonly en: "Effect ledger ({{file}}), last 5 records:";
     };
     readonly 'plugins-unknown-subcommand': {
-        readonly zh: "未知子命令：{{sub}}（支持：check <路径>）";
-        readonly en: "Unknown subcommand: {{sub}} (supported: check <path>)";
+        readonly zh: "未知子命令：{{sub}}（支持：list / check <路径> / info <spec> / registries）";
+        readonly en: "Unknown subcommand: {{sub}} (supported: list / check <path> / info <spec> / registries)";
     };
     readonly 'plugins-check-usage': {
-        readonly zh: "用法：/plugins check <dsh-plugin.json 路径>";
-        readonly en: "Usage: /plugins check <path-to-dsh-plugin.json>";
+        readonly zh: "用法：/plugin check <dsh-plugin.json 路径>";
+        readonly en: "Usage: /plugin check <path-to-dsh-plugin.json>";
     };
     readonly 'plugins-check-not-found': {
         readonly zh: "文件不存在：{{path}}";
@@ -5355,6 +4081,142 @@ declare const dict: {
         readonly zh: "当前没有 live Host Descriptor；只做静态 manifest 校验，不进行协议支持声明/协商。";
         readonly en: "No live Host Descriptor is available; only static manifest validation was performed, no protocol support declaration/negotiation.";
     };
+    readonly 'plugins-service-unavailable': {
+        readonly zh: "当前内核没有 profile 插件服务（ctx.pluginManager）：bundle/行列表不可用。装/卸/启用请从命令行运行 `dsh plugin --profile dsh-tui …`，或以 `dsh --profile dsh-tui` 启动本应用。";
+        readonly en: "This kernel provides no profile plugin service (ctx.pluginManager): the bundle/row list is unavailable. Install, remove, or enable from the CLI with `dsh plugin --profile dsh-tui …`, or start this app through `dsh --profile dsh-tui`.";
+    };
+    readonly 'plugins-service-error': {
+        readonly zh: "插件服务调用失败：{{err}}（上面的诊断部分照常显示。重试一次；仍失败请用 `dsh plugin --profile dsh-tui` 查看 CLI 侧的报错。）";
+        readonly en: "The plugin service call failed: {{err}} (the diagnostics above are unaffected. Retry once; if it keeps failing, read the CLI-side error with `dsh plugin --profile dsh-tui`.)";
+    };
+    readonly 'plugins-list-header': {
+        readonly zh: "你装的额外插件（{{count}}）：";
+        readonly en: "Plugins you added ({{count}}):";
+    };
+    readonly 'plugins-list-empty': {
+        readonly zh: "本 profile 没有额外插件：只有安装自带与 dsh-tui 自身。装好后用 /plugin list 复查。";
+        readonly en: "No extra plugins in this profile: only the installation-supplied bundles and dsh-tui itself. Run /plugin list again after installing one.";
+    };
+    readonly 'plugins-list-hint': {
+        readonly zh: "详情：/plugin info <名字>；安装源：/plugin registries；完整诊断：无参 /plugin。";
+        readonly en: "Details: /plugin info <name>; registries: /plugin registries; full diagnostics: bare /plugin.";
+    };
+    readonly 'plugins-bundles-header': {
+        readonly zh: "已装 bundle（数据来自 profile 插件服务）：";
+        readonly en: "Installed bundles (from the profile plugin service):";
+    };
+    readonly 'plugins-bundles-official': {
+        readonly zh: "安装自带";
+        readonly en: "Official (installation-supplied)";
+    };
+    readonly 'plugins-bundles-installed': {
+        readonly zh: "profile 依赖";
+        readonly en: "Profile dependencies";
+    };
+    readonly 'plugins-bundles-empty': {
+        readonly zh: "（这个 profile 里还没有 bundle）";
+        readonly en: "(no bundles in this profile yet)";
+    };
+    readonly 'plugins-bundle-on': {
+        readonly zh: "已启用";
+        readonly en: "on";
+    };
+    readonly 'plugins-bundle-off': {
+        readonly zh: "未启用";
+        readonly en: "off";
+    };
+    readonly 'plugins-bundle-kept': {
+        readonly zh: "不可卸载";
+        readonly en: "not removable";
+    };
+    readonly 'plugins-bundle-locked': {
+        readonly zh: "不可管理（{{reason}}）";
+        readonly en: "locked ({{reason}})";
+    };
+    readonly 'plugins-bundle-problem': {
+        readonly zh: "问题：{{code}}";
+        readonly en: "problem: {{code}}";
+    };
+    readonly 'plugins-bundle-rows': {
+        readonly zh: "行 {{rows}} / 覆盖 {{overrides}}";
+        readonly en: "rows {{rows}} / overrides {{overrides}}";
+    };
+    readonly 'plugins-rows-header': {
+        readonly zh: "没有 patch 行可管理的 loader 条目：";
+        readonly en: "Loader entries no patch row can address:";
+    };
+    readonly 'plugins-tag-undeclared': {
+        readonly zh: "未声明 TUI 贡献";
+        readonly en: "no TUI contribution declared";
+    };
+    readonly 'plugins-tag-undeclared-hint': {
+        readonly zh: "「未声明 TUI 贡献」= 该包没有包根 dsh-plugin.json（@dsh-std/manifest 0.15 形状）：它不会作为后端或贡献出现，运行时既不拒绝也不报错。声明写法见 tui-profile/docs/plugin-admission-and-development.md。";
+        readonly en: "“no TUI contribution declared” = the package ships no package-root dsh-plugin.json (@dsh-std/manifest 0.15): it will not appear as a backend or contribution, and the runtime neither refuses it nor reports an error. See tui-profile/docs/plugin-admission-and-development.md for how to declare one.";
+    };
+    readonly 'plugins-tag-invalid': {
+        readonly zh: "声明无法判定：{{err}}";
+        readonly en: "declaration undecidable: {{err}}";
+    };
+    readonly 'plugins-tag-declared': {
+        readonly zh: "TUI 贡献：{{state}}";
+        readonly en: "TUI contribution: {{state}}";
+    };
+    readonly 'plugins-info-usage': {
+        readonly zh: "用法：/plugin info <已装 bundle 名或待装 spec>";
+        readonly en: "Usage: /plugin info <installed bundle name or install spec>";
+    };
+    readonly 'plugins-info-bundle': {
+        readonly zh: "已装 bundle：{{name}}";
+        readonly en: "Installed bundle: {{name}}";
+    };
+    readonly 'plugins-info-rows-label': {
+        readonly zh: "  行：";
+        readonly en: "  rows:";
+    };
+    readonly 'plugins-info-overrides-label': {
+        readonly zh: "  覆盖的行：{{list}}";
+        readonly en: "  overridden rows: {{list}}";
+    };
+    readonly 'plugins-info-problem': {
+        readonly zh: "  问题：{{code}}{{diagnostic}}";
+        readonly en: "  problem: {{code}}{{diagnostic}}";
+    };
+    readonly 'plugins-info-inspect-refused': {
+        readonly zh: "不可安装：{{problem}} — {{reason}}";
+        readonly en: "Not installable: {{problem}} — {{reason}}";
+    };
+    readonly 'plugins-info-inspect-accepted': {
+        readonly zh: "可安装：{{name}} {{version}} · {{kind}} · bundle={{bundle}} · 来源 {{registry}}";
+        readonly en: "Installable: {{name}} {{version}} · {{kind}} · bundle={{bundle}} · from {{registry}}";
+    };
+    readonly 'plugins-info-inspect-description': {
+        readonly zh: "  {{description}}";
+        readonly en: "  {{description}}";
+    };
+    readonly 'plugins-info-inspect-host': {
+        readonly zh: "  来源主机：{{host}}";
+        readonly en: "  source host: {{host}}";
+    };
+    readonly 'plugins-info-registries-header': {
+        readonly zh: "安装源（首用优先，逐级回退）：";
+        readonly en: "Registries (asked first, then in order):";
+    };
+    readonly 'plugins-info-registries-first': {
+        readonly zh: "  首选：{{registry}}";
+        readonly en: "  first: {{registry}}";
+    };
+    readonly 'plugins-info-registries-fallbacks': {
+        readonly zh: "  回退：{{list}}";
+        readonly en: "  fallbacks: {{list}}";
+    };
+    readonly 'plugins-info-registries-resolved': {
+        readonly zh: "  pnpm 配置解析：{{registry}}";
+        readonly en: "  resolved from pnpm: {{registry}}";
+    };
+    readonly 'plugins-info-registries-none': {
+        readonly zh: "（无）";
+        readonly en: "(none)";
+    };
     readonly 'doctor-plugin-generation': {
         readonly zh: "插件运行时 generation：{{id}}";
         readonly en: "Plugin runtime generation: {{id}}";
@@ -5443,10 +4305,6 @@ declare const dict: {
         readonly zh: "无匹配";
         readonly en: "no matches";
     };
-    readonly 'rename-usage': {
-        readonly zh: "用法  /rename <新名称>";
-        readonly en: "Usage  /rename <new title>";
-    };
     readonly 'rename-current': {
         readonly zh: "当前名称  {{title}}";
         readonly en: "Current title  {{title}}";
@@ -5472,8 +4330,8 @@ declare const dict: {
         readonly en: "↓ back to bottom (Enter/End)";
     };
     readonly 'theme-builtin-base': {
-        readonly zh: "内置 · {{name}} 基底";
-        readonly en: "Built-in · {{name}} base";
+        readonly zh: "内置 · {{base}} 基底";
+        readonly en: "Built-in · {{base}} base";
     };
     readonly 'theme-auto-base': {
         readonly zh: "内置 · 跟随系统/终端背景自动选择 light/dark";
@@ -7204,6 +6062,15 @@ declare const dict: {
         readonly zh: "选择内核（切换后重启进入）";
         readonly en: "Choose the kernel (restarts into it)";
     };
+    readonly 'cmd-desc-dsh': {
+        readonly zh: "切换到 DSH 内核（重启进入新会话）";
+    };
+    readonly 'cmd-desc-codex': {
+        readonly zh: "切换到 Codex 内核（重启进入新会话）";
+    };
+    readonly 'cmd-desc-claude': {
+        readonly zh: "切换到 Claude 内核（重启进入新会话）";
+    };
     readonly 'cmd-desc-channel': {
         readonly zh: "渠道档案：切换 / 导入 / 查看映射（Claude）";
         readonly en: "Channel profiles: switch / import / view mappings (Claude)";
@@ -7592,6 +6459,22 @@ declare const dict: {
         readonly zh: "打开该面板";
         readonly en: "Open this panel";
     };
+    readonly 'sugg-plugin-list-desc': {
+        readonly zh: "列出你装的额外插件";
+        readonly en: "List the plugins this profile added";
+    };
+    readonly 'sugg-plugin-info-desc': {
+        readonly zh: "查单个条目或待装 spec";
+        readonly en: "Describe an installed plugin or an install spec";
+    };
+    readonly 'sugg-plugin-registries-desc': {
+        readonly zh: "查看安装源";
+        readonly en: "Show where installations ask";
+    };
+    readonly 'sugg-plugin-check-desc': {
+        readonly zh: "校验清单，不安装";
+        readonly en: "Validate a manifest without installing it";
+    };
     readonly 'panel-unavailable-hint': {
         readonly zh: "侧栏需要全屏且内容区 ≥93 列；该面板没有整屏形态";
         readonly en: "Sidebar needs fullscreen and ≥93 content columns; this panel has no fullscreen form";
@@ -7641,8 +6524,8 @@ declare const dict: {
     readonly 'cmd-desc-skills': {
         readonly zh: "列出所有可用技能";
     };
-    readonly 'cmd-desc-plugins': {
-        readonly zh: "显示插件契约、授权与台账诊断";
+    readonly 'cmd-desc-plugin': {
+        readonly zh: "插件诊断；`list` 列你装的额外插件，`info` 查单个条目或待装 spec";
     };
     readonly 'cmd-desc-update': {
         readonly zh: "更新 dsh-tui 并重启";
@@ -7886,17 +6769,13 @@ declare const dict: {
         readonly en: "Codex";
     };
     readonly 'kernel-login-in-session': {
-        readonly zh: "未登录 · 启动后用 /login 登录";
-        readonly en: "Not signed in · sign in with /login after start";
+        readonly zh: "未登录";
+        readonly en: "Not signed in";
     };
     readonly 'kernel-unavailable-not-installed': {
         readonly zh: "未安装";
         readonly en: "Not installed";
     };
-    readonly 'kernel-unavailable-auth-missing': {
-        readonly zh: "未登录";
-        readonly en: "Not signed in";
-    };
     readonly 'kernel-unavailable-too-old': {
         readonly zh: "版本过旧 · 需升级";
         readonly en: "Too old · upgrade needed";
@@ -7961,6 +6840,22 @@ declare const dict: {
         readonly zh: "上次选择的 {{name}} 内核启动失败，已先以 DSH 内核启动：{{reason}}";
         readonly en: "The remembered {{name}} kernel failed to start; booted on DSH instead: {{reason}}";
     };
+    readonly 'resume-target-revoked': {
+        readonly zh: "无法恢复上次会话：它由「{{from}}」后端记录，而本次启动使用的是「{{kernel}}」后端。启动恢复只针对所选后端——要恢复「{{from}}」记下的那条：dsh-tui --backend {{from}} --resume；要恢复本次所选后端自己的上次会话：dsh-tui --backend {{kernelId}} --resume；也可以去掉 --resume 重新启动。";
+        readonly en: "Cannot resume the last session: it was recorded by the \"{{from}}\" backend while this launch runs on \"{{kernel}}\". Startup recovery only ever targets the selected backend — to reopen the session \"{{from}}\" recorded: `dsh-tui --backend {{from}} --resume`; to reopen the last session of this launch's backend: `dsh-tui --backend {{kernelId}} --resume`; or drop --resume to start fresh.";
+    };
+    readonly 'resume-target-revoked-uninstalled': {
+        readonly zh: "无法恢复上次会话：它由「{{from}}」后端记录，而该后端本次启动未安装（或已不在此 profile 的注册表里），本次启动使用的是「{{kernel}}」后端。恢复它要先装上该后端，再运行 dsh-tui --backend {{from}} --resume；或去掉 --resume 重新启动。";
+        readonly en: "Cannot resume the last session: it was recorded by the \"{{from}}\" backend, which is not installed for this launch (or is no longer in this profile's registry), while this launch runs on \"{{kernel}}\". Resuming it needs that backend installed first, then `dsh-tui --backend {{from}} --resume`; or drop --resume to start fresh.";
+    };
+    readonly 'resume-target-revoked-retry': {
+        readonly zh: "安全模式重试：忽略由「{{from}}」后端记录的上次会话（本次启动用的是「{{kernel}}」），按冷启动继续。";
+        readonly en: "Safe-mode retry: ignoring the last session recorded by the \"{{from}}\" backend (this launch runs on \"{{kernel}}\") and continuing with a cold start.";
+    };
+    readonly 'resume-backend-unavailable': {
+        readonly zh: "无法恢复会话：本次启动指定的后端「{{backend}}」不可用（未安装或 id 不合法；已注册：{{installed}}），而要恢复的会话「{{session}}」属于它。回落 DSH 只会把别的后端的会话 id 交给 dsh，因此本次启动失败——装上该后端后重试，或去掉 --resume 重新启动。";
+        readonly en: "Cannot resume: the backend named for this launch, \"{{backend}}\", is unavailable (not installed, or not a valid id; registered: {{installed}}), and the session \"{{session}}\" belongs to it. Falling back to DSH would only hand another backend's session id to dsh, so this launch fails — install the backend and retry, or drop --resume to start fresh.";
+    };
     readonly 'kernel-pinned-hint': {
         readonly zh: "启动参数已指定内核：本次会按你的选择重启，下次直接启动仍按参数进入。";
         readonly en: "A startup flag pins the kernel: this restart follows your choice, a later direct launch follows the flag.";
@@ -7970,20 +6865,20 @@ declare const dict: {
         readonly en: "Not installed · Enter to install";
     };
     readonly 'sdk-install-title': {
-        readonly zh: "安装 Claude 内核";
-        readonly en: "Install the Claude kernel";
+        readonly zh: "安装内核依赖";
+        readonly en: "Install kernel dependencies";
     };
     readonly 'sdk-install-confirm-what': {
-        readonly zh: "将安装 Claude Agent SDK {{version}}（内置 Claude Code CLI）";
-        readonly en: "This installs Claude Agent SDK {{version}} (bundles the Claude Code CLI)";
+        readonly zh: "将安装 {{specifier}}（验证版本：{{version}}）";
+        readonly en: "This installs {{specifier}} (validated version: {{version}})";
     };
     readonly 'sdk-install-confirm-where': {
         readonly zh: "安装位置：{{dir}}";
         readonly en: "Install location: {{dir}}";
     };
     readonly 'sdk-install-confirm-note': {
-        readonly zh: "只装进 dsh-tui 自己的目录：版本经过验证、不随全局变化；PATH 上已有的 Claude Code 会优先使用，不受影响。需要网络与 pnpm。";
-        readonly en: "Installs only into the dsh-tui directory: the version is validated and never follows your global one; a Claude Code already on PATH is used first and is not touched. Needs network and pnpm.";
+        readonly zh: "只安装到当前 profile 目录。需要网络与 pnpm。";
+        readonly en: "Installs only into the current profile directory. Needs network and pnpm.";
     };
     readonly 'sdk-install-confirm-hint': {
         readonly zh: "**Enter** 安装 · Esc 返回";
@@ -8002,8 +6897,12 @@ declare const dict: {
         readonly en: "Esc to cancel";
     };
     readonly 'sdk-install-done': {
-        readonly zh: "SDK 安装完成，Claude 内核已可用。";
-        readonly en: "SDK installed — the Claude kernel is ready.";
+        readonly zh: "依赖安装完成，返回内核选择查看可用状态。";
+        readonly en: "Dependencies installed. Return to the kernel picker to check availability.";
+    };
+    readonly 'sdk-install-rebuilt': {
+        readonly zh: "检测到 pnpm store 漂移，已自动重建依赖后装好。";
+        readonly en: "pnpm store drift detected — dependencies were rebuilt automatically.";
     };
     readonly 'sdk-install-done-hint': {
         readonly zh: "**Enter** 返回内核选择 · Esc 关闭";
@@ -8073,14 +6972,6 @@ declare const dict: {
         readonly zh: "回合运行中，无法切换或改动渠道";
         readonly en: "Cannot switch or change channels while a turn is running";
     };
-    readonly 'channel-conn-settings-mismatch': {
-        readonly zh: "settings.json 的 ANTHROPIC_BASE_URL 与当前渠道 {{name}} 不一致；本会话按渠道配置连接（settings.json 不改，直接运行 claude 时仍按它）";
-        readonly en: "The ANTHROPIC_BASE_URL in settings.json differs from the active channel {{name}}; this session connects as the channel says (settings.json is left as is for running claude directly)";
-    };
-    readonly 'channel-conn-creds-superseded': {
-        readonly zh: "本会话使用渠道凭据，settings.json 里的 {{keys}} 本次不生效（settings.json 不改，直接运行 claude 时仍会用到）";
-        readonly en: "This session uses the channel credential; {{keys}} from settings.json do not apply (settings.json is left as is for running claude directly)";
-    };
     readonly 'channel-switched': {
         readonly zh: "已切换到 {{name}}，模型显示已刷新";
         readonly en: "Switched to {{name}}; the model display refreshed";
@@ -8632,6 +7523,46 @@ declare const dict: {
     readonly 'cmd-desc-setup': {
         readonly zh: "重跑首次引导（API Key / 语言主题 / 模型工作区 / 快捷键）";
     };
+    readonly 'capability-failed': Readonly<{
+        zh: "{{name}} 失败 · {{err}}";
+        en: "{{name}} failed · {{err}}";
+    }>;
+    readonly 'status-rate-limit-five-hour': Readonly<{
+        zh: "5小时";
+        en: "5h";
+    }>;
+    readonly 'status-rate-limit-seven-day': Readonly<{
+        zh: "7天";
+        en: "7d";
+    }>;
+    readonly 'doctor-unknown': Readonly<{
+        zh: "未知";
+        en: "unknown";
+    }>;
+    readonly 'effort-invalid': Readonly<{
+        zh: "未知推理等级 {{id}}（当前模型可选：{{ids}}）";
+        en: "Unknown reasoning effort {{id}} (this model offers: {{ids}})";
+    }>;
+    readonly 'tool-name-bash': Readonly<{
+        zh: "Bash";
+        en: "Bash";
+    }>;
+    readonly 'tool-name-edit': Readonly<{
+        zh: "编辑";
+        en: "Edit";
+    }>;
+    readonly 'rewind-first-message': Readonly<{
+        zh: "不能回退到第一条消息之前";
+        en: "Cannot rewind past the very first message";
+    }>;
+    readonly 'rename-failed': Readonly<{
+        zh: "重命名失败 · {{err}}";
+        en: "Rename failed · {{err}}";
+    }>;
+    readonly 'rename-usage': Readonly<{
+        zh: "用法  /rename <新名称>";
+        en: "Usage  /rename <new title>";
+    }>;
 };
 export type I18nKey = keyof typeof dict;
 export type I18nParams = Record<string, string | number>;