@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/i18n/messages.zh.js

@@ -0,0 +1,837 @@
+const ZH = {
+    'onboard.chrome.step': '第 {step} / {total} 步 · {label}',
+    'onboard.chrome.quitHint': '(连按两次 ctrl+C 退出)',
+    'onboard.chrome.quitArmed': '再按一次退出安装向导',
+    'onboard.station.language': '语言',
+    'onboard.station.theme': '主题',
+    'onboard.station.model': '模型',
+    'onboard.station.tiers': '模型档位',
+    'onboard.station.websearch': '联网搜索',
+    'onboard.station.memory': '记忆',
+    'onboard.station.mcp': 'MCP 服务器',
+    'onboard.station.skills': '技能',
+    'onboard.station.plugins': '插件',
+    'onboard.blurb.model': '添加 sema 要用的模型 —— 之后随时可用 `sema config model` 修改。',
+    'onboard.blurb.tiers': '把模型绑到各个档位(pro 跑日常、flash 跑便宜的量),并选一个默认档 —— 之后随时可用 `sema config tiers` 修改。',
+    'onboard.blurb.mcp': '导入 MCP 服务器 —— 之后随时可用 `sema config mcp` 修改。',
+    'onboard.blurb.skills': '导入技能 —— 之后随时可用 `sema config skills` 修改。',
+    'onboard.blurb.plugins': '安装插件 —— 之后随时可用 `sema config plugins` 修改。',
+    'onboard.welcome.title': '✻ 欢迎使用 Sema',
+    'onboard.welcome.tagline': '一个壳,管住你的整支舰队 —— 本地引擎自启、多智能体编排,想上云的时候再上云。',
+    'onboard.theme.hint': 'enter 继续 · esc 返回上一步 · 连按两次 q 退出',
+    'onboard.theme.hintFirst': 'enter 继续 · 连按两次 q/esc 退出',
+    'onboard.language.title': '选择你的语言',
+    'onboard.language.blurb': 'sema 自己的界面(安装向导、`sema config`、`sema doctor`)使用这个语言 —— 之后随时可用 `sema config language` 修改。',
+    'onboard.language.hint': '↑↓ 选择 · enter 继续',
+    'onboard.language.detected': '按系统语言推断',
+    'onboard.language.savedPreference': '你已保存的选择',
+    'onboard.language.sourceDefault': '缺省 —— 没有已保存的选择,也没读到系统语言',
+    'onboard.memory.title': '要让 sema 跨会话记住东西吗?',
+    'onboard.memory.on': '开 —— 记住有用的事实和偏好',
+    'onboard.memory.off': '关 —— 不保存、不召回、请求里也不带记忆',
+    'onboard.memory.current': '当前设置',
+    'onboard.memory.blurb': '自动记忆由引擎保存,你所有的项目共用一份。之后随时可用 /memory 或 `sema config` 修改。',
+    'onboard.memory.hint': '↑↓ 选择 · enter 继续',
+    'onboard.language.saveFailed': 'language   已选 {language},但没能存下来({error})—— 仅本次会话生效',
+    'config.header.subtitle': '设置',
+    'config.menu.hint': '↑↓ 选择 · enter 进入 · esc 退出',
+    'config.domain.model': '模型',
+    'config.domain.tiers': '模型档位',
+    'config.domain.mcp': 'MCP 服务器',
+    'config.domain.skills': '技能',
+    'config.domain.plugins': '插件',
+    'config.domain.marketplaces': '插件市场',
+    'config.domain.engine': '引擎',
+    'config.domain.language': '语言',
+    'config.language.title': '语言',
+    'config.language.intro': 'sema 自己界面使用的语言。模型回复用什么语言由你的提问和 /config 里的 `Language` 设置决定,与这里无关。',
+    'config.language.hint': '↑↓ 选择 · enter 保存 · esc 返回',
+    'config.language.saved': '语言已设为 {language}。',
+    'config.language.saveFailed': '语言没能保存:{error}',
+    'config.language.sourceSaved': '已保存',
+    'config.language.sourceSystem': '按系统语言推断',
+    'config.language.sourceDefault': '缺省(没有已保存的选择,也没读到系统语言)',
+    'doctor.section.diagnostics': '诊断',
+    'doctor.section.version': '版本',
+    'doctor.section.settings': '设置',
+    'doctor.section.updates': '更新',
+    'doctor.section.engine': '引擎',
+    'doctor.section.axes': '三轴',
+    'doctor.common.unknown': '未知',
+    'doctor.version.line': '└ 版本:sema {version}',
+    'doctor.version.enginePinned': '└ 引擎(锁定版本):{version}',
+    'doctor.version.ccBase': '└ CC 兼容底座:{version} · 安装形态 {installationType}',
+    'doctor.version.packageManager': '└ 包管理器:{packageManager}',
+    'doctor.version.path': '└ 路径:{path}',
+    'doctor.version.invoked': '└ 调用入口:{binary}',
+    'doctor.version.diagnosticUnavailable': '└ WARN 安装诊断不可用',
+    'doctor.row.warn': '└ 警告:{issue}',
+    'doctor.row.fix': '    修法:{fix}',
+    'doctor.row.learnMore': '    了解更多:{link}',
+    'doctor.settings.ok': '└ 设置文件:OK 没有报告问题',
+    'doctor.settings.fileUnspecified': '(未指明文件)',
+    'doctor.settings.checkUnavailable': '└ WARN 设置检查不可用',
+    'doctor.updates.devChannel': '└ 渠道:dev 工作目录(本地 dist 构建 —— 不是 npm 安装)',
+    'doctor.updates.npmChannel': '└ 渠道:npm 注册表(@sema-agent/cli)',
+    'doctor.updates.installed': '└ 已装版本:{version}',
+    'doctor.updates.latest': '└ 最新版本:{version}',
+    'doctor.updates.upToDateSuffix': '(已是最新)',
+    'doctor.updates.updateAvailable': '└ 有可用更新 —— 运行 `sema update`',
+    'doctor.updates.fetchFailed': '└ 未能从 sema 注册表取到最新版本',
+    'doctor.updates.checkUnavailable': '└ WARN 更新检查不可用',
+    'doctor.updates.localChannel': '└ 渠道:装在 {path} 的 npm 包(不是 npm 全局安装)',
+    'doctor.updates.unknownChannel': '└ 渠道:npm 包(安装位置未确认:{why})',
+    'doctor.updates.aheadSuffix': '(已装版本更新 —— 无需更新)',
+    'doctor.updates.updateAvailableLocal': '└ 有可用更新 —— 到它所在的项目里更新(sema update 只更新 npm 全局安装)',
+    'doctor.updates.autoOn': '└ 自动更新:开(每 4 小时检查一次)',
+    'doctor.updates.autoOff': '└ 自动更新:关({reason})',
+    'doctor.updates.lastAutoFailure': '└ 上次自动更新:{detail}',
+    'doctor.diag.managedSettingsInvalid.issue': 'managed-settings.json:strictPluginOnlyCustomization 的值无效(应为 true 或数组,实际是 {type})',
+    'doctor.diag.managedSettingsInvalid.fix': '该字段会被静默忽略(schema 的 .catch 兜底)。请设为 true,或设为以下项组成的数组:{surfaces}。',
+    'doctor.diag.managedSettingsUnknown.issue': 'managed-settings.json:strictPluginOnlyCustomization 里有 {count} 个本客户端不认识的值:{values}',
+    'doctor.diag.managedSettingsUnknown.fix': '这些值会被静默忽略(向前兼容)。本版本已知的界面:{surfaces}。要么删掉它们,要么说明这个客户端版本比 managed-settings 想用的旧。',
+    'doctor.diag.pathWindows.issue': '原生安装已存在,但 {path} 不在你的 PATH 里',
+    'doctor.diag.pathWindows.fix': '添加方法:打开系统属性 → 环境变量 → 编辑用户 PATH → 新建 → 添加上面这个路径,然后重启终端。',
+    'doctor.diag.pathUnix.issue': '原生安装已存在,但 ~/.local/bin 不在你的 PATH 里',
+    'doctor.diag.pathUnix.fix': '运行:echo \'export PATH="$HOME/.local/bin:$PATH"\' >> {configFile},然后开一个新终端,或运行:source {configFile}',
+    'doctor.diag.unknownShellConfig': '你的 shell 配置文件',
+    'doctor.diag.localMismatch.issue': '正在运行本地安装,但配置里的安装方式是 \'{method}\'',
+    'doctor.diag.nativeMismatch.issue': '正在运行原生安装,但配置里的安装方式是 \'{method}\'',
+    'doctor.diag.considerNative.fix': '可以考虑改用原生安装:sema install',
+    'doctor.diag.runSemaInstall.fix': '运行 sema install 来更新配置',
+    'doctor.diag.localExists.issue': '本地安装已存在,但当前没有在用',
+    'doctor.diag.localNotAccessible.issue': '本地安装无法访问',
+    'doctor.diag.localNotAccessibleAlias.fix': '别名已存在,但指向的目标无效:{alias}。更新别名:alias claude="~/.sema/local/claude"',
+    'doctor.diag.localNotAccessibleNoAlias.fix': '创建别名:alias claude="~/.sema/local/claude"',
+    'doctor.diag.linuxGlob.issue': 'sandbox 权限规则里的 glob 通配符在 Linux 上并非全部支持',
+    'doctor.diag.linuxGlob.fix': '发现 {count} 条通配模式:{patterns}。在 Linux 上,Edit/Read 规则里的 glob 通配符会被忽略。',
+    'doctor.diag.leftoverGlobal.issue': '{path} 处有残留的 npm 全局安装',
+    'doctor.diag.orphanGlobal.issue': '{path} 处有孤立的 npm 全局包',
+    'doctor.diag.leftoverLocal.issue': '{path} 处有残留的 npm 本地安装',
+    'doctor.diag.runCmd.fix': '运行:{cmd}',
+    'doctor.diag.insufficientPermissions.issue': '自动更新权限不足',
+    'doctor.diag.insufficientPermissions.fix': '任选一种:(1)不用 sudo 重装 node,或者(2)用 `sema install` 走原生安装',
+    'model.subagent.tiersInert': '子代理模型 {word} 是档位词,但这台引擎没有配置模型档位 —— 子代理将沿用父代理的模型。',
+    'model.subagent.chainUnbound': '子代理模型 {word} 在这台引擎上没有绑定(它和比它低的档位都没绑模型)—— 子代理将沿用父代理的模型。',
+    'model.subagent.bindingNotInCatalog': '子代理模型 {word} 绑定的模型不在这台引擎的模型目录里 —— 子代理将沿用父代理的模型。',
+    'model.subagent.ambiguous': '子代理模型 {word} 同时对上了几个只差大小写的模型名 —— 请照原样拼写;子代理将沿用父代理的模型。',
+    'session.devices.laneAbsent': '这个后端没有远程控制车道',
+    'session.devices.laneUnreported': '这个后端没有报告远程控制车道',
+    'session.devices.verbsOff': '这个后端的设备车道开着,但设备管理动作关着 —— 这里列不出也改不了设备',
+    'session.devices.probePending': '正在查这个后端有没有远程控制车道…',
+    'session.devices.probeFailedTransport': '连不上引擎,查不了远程控制车道 —— 请重试',
+    'session.devices.probeFailedRefused': '引擎拒绝了设备清单查询 —— 请重试',
+    'session.devices.probeFailedUnreadable': '读不懂引擎给的设备清单 —— 请重试',
+    'config.cloudLogin.accessDenied': '登录被拒绝了。',
+    'config.cloudLogin.expiredToken': '登录码在批准之前过期了 —— 请重新开始。',
+    'config.cloudLogin.invalidGrant': 'Cloud 登录已无法续期 —— 请重新登录。',
+    'config.cloudLogin.cancelled': '登录已取消。',
+    'config.cloudLogin.transport': '连不上注册中心(网络错误、重定向或超时)。',
+    'config.cloudLogin.refused': '注册中心拒绝了这次请求。',
+    'config.cloudLogin.refusedStatus': '注册中心拒绝了这次请求(HTTP {status})。',
+    'config.cloudLogin.noTokens': '登录失败(注册中心没有返回可用的令牌)。',
+    'config.cloudLogin.other': '登录失败。',
+    'config.engineTarget.busy': '还有会话在跑 —— 先停下它再切换引擎。',
+    'config.engineTarget.switching': '已经有一次切换在进行中。',
+    'config.engineTarget.notConfigured': 'Cloud 还没配好 —— 先登录并连上一台 Cloud 引擎。',
+    'config.engineTarget.notSignedIn': '请先登录 Sema Cloud(或在高级选项里粘贴引擎令牌)。',
+    'config.engineTarget.probeFailed': '引擎没通过连接检查。什么都没保存。',
+    'config.engineTarget.orgPolicy': '你的组织要求使用另一个 Cloud 引擎地址。',
+    'config.engineTarget.urlRefused': '这个引擎地址不能用 —— 必须是不带凭据的 http(s) 地址。',
+    'config.engineTarget.loginFailed': '登录失败。',
+    'config.engineTarget.storageUnavailable': '这台设备上没有可用的安全存储,保存不了 Cloud 凭据。什么都没改。',
+    'config.engineTarget.noLocalRuntime': '这台设备上没有本机引擎。',
+    'config.engineTarget.input': '请求的形状不对,什么都没改。',
+    'config.engineTarget.unknown': '引擎切换没有完成。',
+    'onboard.probe.endpointReachable': '{method} {path} → {status}(端点可达)',
+    'onboard.probe.modelSuggest': '{error} —— 列表里相近的 id:"{near}"',
+    'onboard.probe.redirected': '端点重定向了({status})到 {where} —— Sema 不会把你的钥匙跟着重定向带过去;请把最终地址填成根地址',
+    'onboard.probe.anotherAddress': '另一个地址',
+    'onboard.probe.keyEchoed': '(供应商的回复以编码形式回显了你的钥匙 —— 不显示)',
+    'onboard.probe.incomplete': '探活需要根地址和 API 形状 —— 什么都没发。',
+    'onboard.probe.noFetch': '这个宿主没有可用于探活的网络客户端 —— 什么都没发。',
+    'onboard.probe.judgeAbsent': '这个宿主没有装引擎的路由判官,探活拼不出请求地址 —— 什么都没发。',
+    'onboard.baseUrl.invalid': '根地址不是合法的 URL。',
+    'onboard.baseUrl.spaces': '根地址里不能有空格或制表符。',
+    'onboard.baseUrl.scheme': '根地址必须是 http(s)。',
+    'onboard.baseUrl.userinfo': '根地址里不能带凭据。',
+    'onboard.baseUrl.fragment': '根地址不能带片段(# 之后的部分)。',
+    'onboard.baseUrl.pathKey': '根地址的路径看起来带着凭据 —— 请把钥匙填进 API 钥匙栏。',
+    'onboard.baseUrl.queryKey': '根地址的查询串里不能带凭据 —— 请把钥匙填进 API 钥匙栏。',
+    'onboard.baseUrl.queryValueKey': '根地址的查询串看起来带着凭据 —— 请把钥匙填进 API 钥匙栏。',
+    'onboard.baseUrl.encoding': '根地址的百分号编码坏了。',
+    'onboard.catalog.keyEnvUnset': '"{name}" 从 {keyEnv} 读钥匙,而它没有设 —— 引擎会按名拒用这个模型。',
+    'onboard.catalog.unpaired': '"{name}" 有自己的根地址({host}),却没有自己的钥匙(没有 apiKeyEnv),而部署钥匙配对的是 {root} —— 请求会带错钥匙或不带钥匙出去。请给这个模型重新接入并配上它自己的钥匙。',
+    'onboard.catalog.noRoot': '没有 {rootKey}',
+    'onboard.catalog.unparseableHost': '一个解析不了的地址',
+    'onboard.catalog.judgeAbsent': '这个宿主没有装引擎的路由判官,查不了 "{name}" 有没有可用的钥匙。',
+    'onboard.plan.notObject': '模型目录不是 JSON 对象 —— 不覆盖它。请修好或挪走这个文件后再试。',
+    'onboard.plan.modelsNotList': '模型目录里的 "models" 不是列表 —— 不改写它。',
+    'onboard.plan.modelsItemNotObject': '模型目录里有一项 models[] 不是对象 —— 不改写它。',
+    'onboard.plan.envNotObject': '设置文件里的 "env" 不是对象 —— 不改写它。',
+    'onboard.plan.envCatalogPresent': '引擎正按环境变量供模型 "{model}",目录里没有启用的模型;写下第一条目录模型会替换掉环境里的那几只。请先把它们放进目录。',
+    'onboard.input.keyInFields': '模型 ID / 根地址里含着 API 钥匙 —— 请检查这几栏。',
+    'onboard.refusal.input': '模型接入信息不全或形状不对 —— 什么都没保存。',
+    'onboard.refusal.probeFailed': '供应商没有接受这套配置 —— 什么都没保存。',
+    'onboard.refusal.probeUnverified': '查不了供应商,所以什么都没保存 —— 请重试,或按「未验证」保存。',
+    'onboard.refusal.credentialUnpaired': '这个模型在引擎上会没有可用的钥匙,所以什么都没保存。',
+    'onboard.refusal.catalogUnreadable': '这台设备上的模型目录读不出来,所以没有覆盖它。',
+    'onboard.refusal.writeConflict': '保存过程中有别的程序改了配置 —— 什么都没保存;请重试。',
+    'onboard.refusal.writeFailed': '模型配置没能保存。',
+    'onboard.refusal.engineIsRemote': '正在用 Cloud 引擎 —— 本机模型接入对它不起作用。请先切回本机引擎。',
+    'onboard.refusal.envCatalogPresent': '引擎正按环境变量供模型;写下第一条目录模型会替换掉它们,所以没有保存。请先把那几只模型放进目录。',
+    'config.mcp.nameBlank': 'MCP 服务器条目{where}的名字为空({name}),没有启动。请给它起个名字,或删掉这一条。',
+    'config.mcp.nameEdgeWhitespace': 'MCP 服务器 {name}{where} 没有启动:名字带首尾空白,与其他设置里的同名对不上(例如禁用服务器列表)。请去掉名字里多余的空白。',
+    'config.mcp.nameCollides': 'MCP 服务器 {name}{where} 没有启动:名字带首尾空白,去掉后会与另一条 MCP 服务器重名。请去掉名字里多余的空白,或删掉重复的一条。',
+    'config.mcp.toolAxesInvalid': 'MCP 服务器 {name}{where} 没有启动:它的 toolAxes 设置不合法 —— {problem}。请修正这台服务器的 toolAxes(或删掉它);其他 MCP 服务器不受影响。',
+    'config.mcp.toolAxesFallbackProblem': '这份声明不是一组合法的按工具安全设置',
+    'config.mcp.elicitationInvalid': 'MCP 服务器 {name}{where} 没有启动:它的 elicitation 设置必须是 true 或 false。请修正这台服务器的 elicitation(或删掉它);其他 MCP 服务器不受影响。',
+    'config.mcp.cloudElicitationInvalid': '云配置:这些 MCP 服务器条目被略过,因为它们的 elicitation 设置不是 true 或 false —— 请修正或删掉 elicitation 条目:{who}',
+    'config.mcp.cloudToolAxesInvalid': '云配置:这些 MCP 服务器条目被略过,因为它们的 toolAxes 设置不合法(按工具的安全覆盖只认 effect、egress、irreversibility 三项,各带合法取值)—— 请修正或删掉 toolAxes 条目:{who}',
+    'approval.boundGrants.notActivated.one': '批准这一张不会激活卡上的技能:它的拒绝清单里有 1 条读作无物,而引擎不丢弃读不出的拒绝 —— 技能的说明不加载,清单里的一条都不授予。',
+    'approval.boundGrants.notActivated.other': '批准这一张不会激活卡上的技能:它的拒绝清单里有 {count} 条读作无物,而引擎不丢弃读不出的拒绝 —— 技能的说明不加载,清单里的一条都不授予。',
+    'approval.boundGrants.listsNoToolsWithNothing.one': '批准这一张会激活卡上的技能;它没有列出免问运行的工具,也没有列出要拒的工具。清单里有 1 条读作无物,什么都不授予。',
+    'approval.boundGrants.listsNoToolsWithNothing.other': '批准这一张会激活卡上的技能;它没有列出免问运行的工具,也没有列出要拒的工具。清单里有 {count} 条读作无物,什么都不授予。',
+    'approval.boundGrants.activatesWithNothing.one': '批准这一张会激活卡上的技能:{allow},且 {deny}。清单里有 1 条读作无物,什么都不授予。',
+    'approval.boundGrants.activatesWithNothing.other': '批准这一张会激活卡上的技能:{allow},且 {deny}。清单里有 {count} 条读作无物,什么都不授予。',
+    'approval.settle.cause.routingFailureFailClosed': '引擎找不到能回答它的去处,所以把它关闭了',
+    'approval.settle.cause.runCancelled': '发起它的 run 被取消了',
+    'approval.settle.cause.runExited': '发起它的 run 在有人回答之前就退出了',
+    'approval.settle.cause.batchAborted': '它所属的那一批工具调用被中止了',
+    'approval.settle.cause.batchSiblingWithdrawn': '同一批里的另一个审批被拒绝或撤回,连带撤回了这一个',
+    'approval.settle.cause.batchBoundElsewhere': '这一批的决断已绑定到另一个审批上',
+    'approval.settle.cause.adhocLegNoDurableDomain': '在这个部署上,这类请求无法保留着等人回答',
+    'approval.settle.cause.orphanTtlExceeded': '它无主地搁置,超过了引擎的时限',
+    'approval.settle.cause.crashedBeforePark': '引擎进程在能把请求保留着等待之前就停了',
+    'approval.settle.cause.shutdownBeforePark': '引擎在能把请求保留着等待之前就关闭了',
+    'approval.settle.cause.ttlExpired': '在 approval window 内没有人回答',
+    'approval.settle.cause.broadcastLost': '它没有送达任何一个打开着的连接',
+    'approval.settle.cause.streamDisconnected': '承载这张卡的连接断了',
+    'approval.settle.cause.undeliverable': '它没能送达任何审批界面',
+    'approval.settle.subject.named': '{tool} 的审批请求',
+    'approval.settle.subject.generic': '这个审批请求',
+    'approval.settle.endedKnown': '{subject}在引擎上结束了,没有得到回答:{clause}。这张卡上没有批准任何东西;如果仍然需要这一步,请再请求一次。',
+    'approval.settle.endedUnknown': '{subject}在引擎上结束了,没有得到回答(引擎给出的原因,这个版本还不认识)。这张卡上没有批准任何东西;如果仍然需要这一步,请再请求一次。',
+    'approval.settle.what.approved': '已批准',
+    'approval.settle.what.denied': '已拒绝',
+    'approval.settle.what.answered': '已回答',
+    'approval.settle.late': '(迟批)',
+    'approval.settle.where': '(任务 {task})',
+    'approval.settle.follow.following': 'sema 正在这里跟着那次 run',
+    'approval.settle.follow.alreadyFollowing': '这块屏已经在跟着那次 run',
+    'approval.settle.executed.allowed': '引擎还报告,这个已经决断的步骤在执行时被「放行」(ALLOWED)了。',
+    'approval.settle.executed.denied': '引擎还报告,这个已经决断的步骤在执行时被「拒绝」(DENIED)了(部署侧的审查可以事后推翻一次批准)。',
+    'approval.settle.acceptedFollowing': '{what}{late} —— 引擎已收下这个决断{where};{follow},所以它接下来的动作会显示在下面。{tail}',
+    'approval.settle.acceptedNotFollowing': '{what}{late} —— 引擎已收下这个决断{where}。这条 parked 的调用是否已经恢复,这句话说不了;这块屏没有在跟那次 run,所以它接下来的动作不会自己显示在这里。{tail}',
+    'approval.settle.parkedNote.approval': '这一步在这张卡弹出之前,就已经 parked 在引擎的 durable queue 里等待决断了。选 Yes 现在批准它,让这一步迟一点再运行;选 No 放弃这一步 —— 模型会收到一次拒绝,可以改走别的路。',
+    'approval.settle.parkedNote.question': '这一步在这张卡弹出之前,就已经 parked 在引擎的 durable queue 里等待决断了。现在作答会迟一点送出你的决断,让 parked 的这一步带着它继续;不作答就关掉这张卡则放弃这一步 —— 模型会收到一次拒绝,可以改走别的路。',
+    'approval.settle.parkedNote.queueNoDeadline': '{subject}在引擎的 durable queue 里(没有报告它的截止时间)。它在等你的决断 —— 没有任何东西被替你决定。',
+    'approval.settle.parkedSubject.named': '{tool} 的审批',
+    'approval.settle.parkedSubject.generic': '这个审批',
+    'session.crashConverged.reason.approvedThenInterrupted.one': '已经被批准,上一次引擎运行结束时可能正在运行,所以可能有副作用只落了一部分',
+    'session.crashConverged.reason.approvedThenInterrupted.many': '已经被批准,上一次引擎运行结束时可能正在运行,所以可能有副作用只落了一部分',
+    'session.crashConverged.reason.pendingUnsafe.one': '按记录看还没开始,但引擎没有把它标成可以安全重跑',
+    'session.crashConverged.reason.pendingUnsafe.many': '按记录看还没开始,但引擎没有把它们标成可以安全重跑',
+    'session.crashConverged.reason.contradictory.one': '的记录自相矛盾',
+    'session.crashConverged.reason.contradictory.many': '的记录自相矛盾',
+    'session.crashConverged.reason.unstableRow.one': '的记录每次读出来都不一样',
+    'session.crashConverged.reason.unstableRow.many': '的记录每次读出来都不一样',
+    'session.crashConverged.fallback.one': '已经被批准,或者说不清去向,所以可能有副作用只落了一部分',
+    'session.crashConverged.fallback.many': '已经被批准,或者说不清去向,所以可能有副作用只落了一部分',
+    'session.crashConverged.resumeSafe': '按记录看还没开始,可以重跑',
+    'session.crashConverged.counted': '{total} 条里有 {n} 条{clause}',
+    'session.crashConverged.clauseJoin': ';',
+    'session.crashConverged.needsHumanBody.one': '{clauses} —— 重跑之前请人工核对它',
+    'session.crashConverged.needsHumanBody.many': '{clauses} —— 重跑之前请人工逐条核对',
+    'session.crashConverged.rerunnable.one': '按记录看,它可以重跑',
+    'session.crashConverged.rerunnable.many': '按记录看,它们都可以重跑',
+    'session.crashConverged.droppedOnly.one': '上一个会话留下了 {count} 条这个版本读不出来的崩溃收敛审批记录。sema 没有重跑任何东西。',
+    'session.crashConverged.droppedOnly.many': '上一个会话留下了 {count} 条这个版本读不出来的崩溃收敛审批记录。sema 没有重跑任何东西。',
+    'session.crashConverged.recordedAs': '(记录为 {causes})',
+    'session.crashConverged.head.one': '上一次引擎运行结束时还有 {total} 个审批在等待{recorded},引擎把它收敛成了 denied',
+    'session.crashConverged.head.many': '上一次引擎运行结束时还有 {total} 个审批在等待{recorded},引擎把它们收敛成了 denied',
+    'session.crashConverged.droppedTail.one': '(另有 {count} 条记录读不出来。)',
+    'session.crashConverged.droppedTail.many': '(另有 {count} 条记录读不出来。)',
+    'session.crashConverged.line': '{head};{body}。sema 没有重跑任何东西。{dropped}',
+    'session.crashConverged.cause.neutral': '这个决断被自动收敛了',
+    'session.crashConverged.cause.withClause': '{clause},这个决断被自动收敛了',
+    'session.corrupt.content': '这个会话保存的历史读不出来 —— 它存的日志已损坏 —— 所以引擎打不开这个会话。重试没有用:得由运维这台引擎的人修复或移除那份存储的日志。在那之前,请在新会话里继续。',
+    'resume.reopen.first.envFailed': '这件 parked 的工作所需的执行环境没能恢复',
+    'resume.reopen.first.toolUnavailable': '这个审批所授予的工具在这台引擎上不可用',
+    'resume.reopen.first.toolContractMismatch': '这个审批所授予的工具,自审批记录以来已经变了',
+    'resume.reopen.content': '{first} · 引擎在消耗任何东西之前,就把这件工作重新 parked 了 —— 审批仍待决,你的决断没有被消耗 · 请重新获取待决审批,并在同一个工具可用的引擎上再决断一次',
+    'session.inheritEnv.notConfirmed': '引擎没有确认它不会把自己的凭据交给工具 shell,所以工具 shell 拿到的是过滤后的环境(GH_TOKEN 这类看着像凭据的变量会被去掉),直到引擎升级。',
+    'session.inheritEnv.withheld.all': '这次请求没有带上它:引擎的版本还不知道,而不认识「让 shell 继承本机整份环境」这项设置的引擎会拒掉整个请求,所以先扣下了;这次 run 的 shell 拿到的是缺省环境(看着像凭据的变量已去掉);在认识这项设置的引擎上,不带它还会清掉本会话更早的整份环境选择。',
+    'session.inheritEnv.withheld.scrub': '这次请求没有带上它:引擎的版本还不知道,所以缺省环境这项设置没有带;效果相同,因为不带它同样让这次 run 拿到缺省环境(看着像凭据的变量已去掉)。',
+    'session.inheritEnv.withheld.unknown': '这次请求没有带上它:shell 环境这项设置因为一个这个版本不认识的原因被扣下了。',
+    'session.inheritEnv.refusal': '引擎把这次请求当作无效拒掉了,用的是许多不同请求字段共用的一个拒绝码 · 这次请求要求 shell 继承本机的整份环境,而引擎只有在工具直接跑在它自己那台机器上、且请求属于某个会话时才接受这一项;如果它拒的正是这一项,请去掉这项设置(或改用缺省)再发一次',
+    'session.fileHistoryLeg.notHonored': '引擎仍在为这个会话捕获文件历史,尽管你的设置要求它别这么做。',
+    'resume.refusal.placementMismatch': '这次续跑指定的放置根,和这件工作 parked 时记下的不是同一个 · 引擎在消耗任何东西之前就拒了它 —— parked 的工作原封未动 · 请用记下的那个根重试,或者省略放置根让它沿用记下的',
+    'resume.refusal.preflightWaitable': '部署的续跑预检拒绝了这次尝试 · 拒绝发生在提交之前 —— 你的决断没有被消耗 · 引擎给了等待窗,所以障碍清除之后这个令牌仍可再赎',
+    'resume.refusal.preflightNoWait': '部署的续跑预检拒绝了这次尝试 · 拒绝发生在提交之前 —— 你的决断没有被消耗 · 引擎没给等待窗,所以这次拒绝没有说明这个令牌还能不能再赎',
+    'resume.refusal.policyBlock': '引擎在准入检查处拒绝续跑这件 parked 的工作(引擎说明,自这件工作最初被接受以来,它的准入策略变了) · {reason} · 这次拒绝没有说明在它之前有没有东西被消耗、重试是否会通过 —— 请先查看任务当前的状态再决断,如果它反复出现,请问运维这个部署的人',
+    'resume.refusal.policyBlockReason.coarse': '这次拒绝没有指明更具体的检查(它只带了对应 HTTP 状态的通用码:{code})',
+    'resume.refusal.policyBlockReason.named': '拒绝它的检查:{code}',
+    'resume.refusal.policyBlockReason.absent': '这次拒绝没有指明更具体的检查',
+    'resume.refusal.policyBlockReason.unreadable': '这次拒绝带了更具体的原因,但读不出来',
+    'resume.refusal.requireExisting.sessionNotFound': '引擎没有继续这段对话:要求继续的那段对话在那里不存在(可能已过期、已被移除,或从未在那台引擎上创建过;这个客户端分不出是哪种),而这次请求只要求继续一段已有的对话,所以没有开新对话 · 请开始一段新对话,或选另一段来继续',
+    'resume.refusal.requireExisting.sessionIdMissing': '引擎没有继续这段对话:这次请求只要求继续一段已有的对话,却没有点名是哪一段,所以没有可继续的对象,也没有开新对话 · 请指明要继续的对话,或开始一段新的',
+    'resume.refusal.requireExisting.generic': '引擎没有继续这段对话:这次请求只要求继续一段已有的对话,而没有它能继续的对话,所以没有开新对话 · 请开始一段新对话,或选另一段来继续',
+    'resume.refusal.contextUnavailable': '这个审批无处可投:发起这次 run 的会话,此刻没有可用的上下文来继续它 · 什么都没有决断,你的决断没有被消耗;这张卡仍在等待 · {third}',
+    'resume.refusal.contextThird.withRun': '错误里带着这条 run 的 id:请用它自己恢复这条 run,然后再决断一次;调大会话保留时长只能避免以后再发生,救不回这一次{retention}',
+    'resume.refusal.contextThird.noRun': '错误里没有 run id:请回到 run 列表找到这条 run 并自己恢复它,然后再决断一次;调大会话保留时长只能避免以后再发生,救不回这一次{retention}',
+    'resume.refusal.contextRetention': '(这个部署把会话保留 {sec} 秒)',
+    'resume.refusal.startup.resumeRejected': '引擎没能启动 parked 的工作来应用这个决断(它的会话可能已经没了,也可能是引擎拒绝了决断本身;这个客户端分不出是哪种) · 这次拒绝没有说明这张卡是否还在等待 —— 请重新获取待决审批 · 如果卡还在,请从刷新后的列表里再决断一次',
+    'resume.refusal.startup.undetermined': '引擎没能启动 parked 的工作来应用这个决断 · 这次拒绝没有说明这张卡是否还在等待 —— 请重新获取待决审批 · 如果卡还在:引擎拒的是决断本身时(例如答非所问),请更正后再决断;如果被批准的工具是代理从启动它的任务里继承来的,在这台服务端上再批一次不会生效 —— 请拒绝这张卡,或等服务端升级',
+    'resume.refusal.startup.cause.environment': '引擎没能启动 parked 的工作来应用这个决断:它运行所需的环境没能起来(例如工作区没能恢复);决断本身没有被拒 · 这次拒绝没有说明这张卡是否还在等待 —— 请重新获取待决审批 · 如果卡还在,再决断一次会重放同一个决断',
+    'resume.refusal.startup.cause.sessionGone': '引擎没能启动 parked 的工作来应用这个决断:它要续跑的那个代理的会话已经没了 · 这次拒绝没有说明这张卡是否还在等待 —— 请重新获取待决审批 · 如果卡还在,请拒绝它来关闭;它等着的那件工作无法续跑',
+    'resume.refusal.startup.cause.toolUnavailable': '引擎没能启动 parked 的工作来应用这个决断:被批准的工具对续跑的工作不可用(它没了,或者现在有别的工具占了它的名字) · 这次拒绝没有说明这张卡是否还在等待 —— 请重新获取待决审批 · 这个审批无法按所决断的执行 —— 如果卡还在,请重新决断(拒绝它就了结了)',
+    'resume.refusal.startup.cause.configuration': '引擎没能启动 parked 的工作来应用这个决断:这个部署的配置拒绝续跑的这件工作 · 这次拒绝没有说明这张卡是否还在等待 —— 请重新获取待决审批 · 在同样的配置下再决断会以同样的方式失败 —— 得先改配置;拒绝这张卡就了结了',
+    'resume.refusal.startup.cause.decisionRejected': '引擎没能启动 parked 的工作来应用这个决断:引擎拒绝了决断本身(例如答非所问,或是约束不接受的编辑后输入) · 这次拒绝没有说明这张卡是否还在等待 —— 请重新获取待决审批 · 如果卡还在,请更正决断,从刷新后的列表里再决断一次',
+    'resume.refusal.startup.cause.transcriptCorrupt': '引擎没能启动 parked 的工作来应用这个决断:它要续跑的那个代理的转录在,但读不成会话(已损坏) · 这次拒绝没有说明这张卡是否还在等待 —— 请重新获取待决审批 · 再决断会以同样的方式失败,直到那份转录被修复或恢复;拒绝这张卡就了结了',
+    'resume.refusal.checkpoint.newerEngine': '这件 parked 的工作是比这台引擎({reader})更新的引擎版本({writer})存下的 · 什么都没有决断或续跑,parked 的工作仍在等待,但原样再发同一个请求本身不会让它继续 · 请在版本为 {writer} 或更新的引擎上继续它',
+    'resume.refusal.checkpoint.content': '这台服务端无法按它存下来的样子继续这件 parked 的工作 · 什么都没有决断或续跑,parked 的工作仍在等待,但原样再发同一个请求本身不会让它继续 · {outlet} —— 运维这个部署的人可以在升级之前,用服务端的升级前排空检查找出这类 parked 的工作',
+    'resume.refusal.checkpoint.outletWithRun': '如果它是在这台服务端升级之前 parked 的,请先取消它的 run{named},再把这项工作作为新任务重新提交',
+    'resume.refusal.checkpoint.runNamed': '({runId})',
+    'resume.refusal.checkpoint.outletNoRun': '如果它是在这台服务端升级之前 parked 的,就没有要取消的 run:请在那段对话里开始一个新任务',
+    'resume.refusal.checkpoint.outletUnknownKind': '如果它是在这台服务端升级之前 parked 的,请把这项工作作为新任务重新提交(这个客户端分不出这是哪一类 parked 的工作,所以两条出路都给了):如果它还有一条 run 在等它(工具审批、计划审阅或暂停的资源),请先取消那条 run;如果它是在等被唤醒,或是延续其宿主对话的工作流步骤,就没有要取消的 run,请在那段对话里开始一个新任务',
+    'resume.refusal.park.whyWalltime': '它的 run 带着一个墙钟时间额度,而这一版引擎不再强制执行这个额度',
+    'resume.refusal.park.whyInheritedGate': '它 parked 时带的权限模式设置已经读不出来了',
+    'resume.refusal.park.whyConfigRefused': '引擎拒绝它 parked 时带的任务配置',
+    'resume.refusal.park.whyUnsupported': '它是在这一版引擎不支持的条件下 parked 的(例如由更早的引擎版本)',
+    'resume.refusal.park.whatDefault': 'parked 步骤',
+    'resume.refusal.park.head': '这个 {what} 无法被这一版引擎续跑:{why}。同样的拒绝每次都会回来,所以再答一次也没有用(什么都没有决断,什么都没有续跑)。',
+    'resume.refusal.park.configMayReturn': '如果那份配置恢复了,同样的回答就能再次通过。',
+    'resume.refusal.park.printEnded': '{head}引擎已结束那条 run({code});请把这项工作作为新任务重新提交。',
+    'resume.refusal.park.printHolds': '{head}{configMayReturn}parked 的那条 run 仍占着这个会话({code}):请取消它({cancel}),再把这项工作作为新任务重新提交。',
+    'resume.refusal.park.interactiveEnded': '{head}引擎已结束那条 parked 的 run,所以这段对话空出来了:请把这项工作作为新消息重新发一次。',
+    'resume.refusal.park.interactiveBusy': '{head}{configMayReturn}parked 的那条 run 会一直占着这段对话,直到它被取消。',
+    'resume.refusal.park.blockedPrint': 'sema 不会自己把 run {run} 的卡放回屏幕:这一版引擎拒绝续跑它。请取消这条 run({cancel}),再把这项工作作为新任务重新提交。',
+    'resume.refusal.park.blockedInteractive': 'sema 不会自己把 run {run} 的卡放回屏幕:这一版引擎拒绝续跑它。要空出这段对话,请发一条消息把卡带回来并作答 —— sema 随后会提出取消那条 run,之后你就可以把这项工作作为新消息重新发一次。',
+    'session.selfHeal.wayOut.interactive': '运行 /clear,在全新会话里继续工作',
+    'session.selfHeal.freshSession.default': '开一个新会话(去掉 --resume/--continue)',
+    'session.selfHeal.freshSession.defaultCapitalized': '开一个新会话(去掉 --resume/--continue)',
+    'session.selfHeal.gate.kind': '一个 {kind} 决定',
+    'session.selfHeal.gate.generic': '一个决定',
+    'session.selfHeal.handle.run': '(run {taskId})',
+    'session.selfHeal.viaEngine': '你也可以直接在引擎上决定它:POST {decidePath}。',
+    'session.selfHeal.decidePathClause': '引擎说那次 run 在等{gate},要在 POST {decidePath} 上决定 —— 决定了就会释放这个会话。',
+    'session.selfHeal.governanceOrigin': '那道门是这个部署的治理策略强制的,不是你设的权限规则。',
+    'session.selfHeal.lastActivity': '引擎最后一次记录那次 run 的活动是在 {ago} 前。',
+    'session.selfHeal.noCardView.afterColon': ':这个会话没有接上能显示决断卡的界面',
+    'session.selfHeal.noCardView.inParens': '(这个会话没有接上能显示决断卡的界面)',
+    'session.selfHeal.userClosedCardNotPutBack': 'sema 不会自己把你关掉的卡重新放回屏幕',
+    'session.selfHeal.lastEngineStatus': '(引擎最后报告的状态:{status})',
+    'session.selfHeal.injected.lead': 'sema 自己发出的一条后续消息(不是你输入的)',
+    'session.selfHeal.injected.id': '(id {id})',
+    'session.selfHeal.injected.attach': '{lead}没有送达:你选了改看正在进行的那一轮回复{id},sema 正在这里重放那一轮回复,所以上面已经显示过的部分会在下面再出现一遍。sema 没有重试,所以模型没有看到它。',
+    'session.selfHeal.injected.steerUnknown': '{lead}已交给正在进行的那一轮回复{id},但无法确认是否送达({detail})—— 那一轮回复可能收到了,也可能没收到。sema 没有重试,因为发两次不安全;请留意那一轮回复接下来的动作。',
+    'session.selfHeal.injected.steerRejected': '{lead}没有送达:把它交给正在进行的那一轮回复{id}被拒绝了({detail})。sema 没有重试,所以模型没有看到它。',
+    'session.selfHeal.injected.decisionInFlight': '{lead}没有送达:这个会话还被较早的一轮回复占着{id},而你对它在等的那个决断的回答还在路上。sema 没有重试,所以模型没有看到它。',
+    'session.selfHeal.injected.dismissedPlan': '{lead}没有送达:这个会话被较早的一轮回复占着{id},它的计划在等你审阅,而你关掉了那张审批卡 —— {closed}。想让卡回来时请发一条消息;sema 没有重试,所以模型没有看到它。',
+    'session.selfHeal.injected.queuedOn': '{lead}排在较早的一轮回复{id}上,那一轮回复停在那里等一个决断',
+    'session.selfHeal.injected.queuedShown': '{queuedOn};sema 已经把那张决断卡显示出来了,你回答之后这条消息才会被取走。',
+    'session.selfHeal.injected.queuedInFlight': '{queuedOn};你对它的回答还在路上,那个回答生效之后这条消息才会被取走。',
+    'session.selfHeal.injected.queuedDismissed': '{queuedOn};那张卡是你自己关掉的,所以 sema 没有把它放回屏幕 —— 发一条消息可以把它叫回来,那个决断做出之后这条消息才会被取走。',
+    'session.selfHeal.injected.queuedCannotShow': '{queuedOn},sema 没能在这里显示它{noView};那个决断做出之后这条消息才会被取走。',
+    'session.selfHeal.injected.parkedForWake': '{lead}还没有到达模型:较早的那一轮回复{id}已经结束了,所以这条消息被搁在它上面、没有另开一轮回复,sema 也没有重试。',
+    'session.selfHeal.injected.unknownDelivery': '{lead}被正在进行的那一轮回复{id}收下了,但没有报告会怎样送达,所以 sema 说不准那一轮回复会不会用到它',
+    'session.selfHeal.injected.unknownDeliveryFollowing': '{unknown}。sema 正在跟着那一轮回复,它接下来要什么都会显示出来;请先看它怎么处理,再决定要不要再发一次。',
+    'session.selfHeal.injected.unknownDeliveryWatch': '{unknown} —— 请先看着那一轮回复,再决定要不要再发一次。',
+    'session.selfHeal.injected.heldForDecision': '{lead}被暂扣了:这个会话正被较早的一轮回复{id}占着,那一轮在等一个决断。sema 把这条消息留在队列里,你回答了那张打开的卡之后会发出去。',
+    'session.selfHeal.injected.resendingConfirmed': '{lead}之前被拦住了,因为这个会话当时被较早的一轮回复{id}占着;现在会话已经空出来了,所以 sema 正在发送这条消息 —— 你不用做什么。',
+    'session.selfHeal.injected.resendingInferred': '{lead}之前被拦住了,因为这个会话当时被较早的一轮回复{id}占着;现在那一轮回复报告已结束,所以 sema 正在发送这条消息 —— 你不用做什么(如果会话还没完全空出来,它可能会再被拦一次)。',
+    'session.selfHeal.injected.handedOffFollowing': '{lead}已交给正在进行的那一轮回复{id},没有另开一轮。sema 正在跟着那一轮回复,它接下来要什么都会显示出来;你现在不用做什么。',
+    'session.selfHeal.injected.handedOffWatch': '{lead}已交给正在进行的那一轮回复{id},没有另开一轮 —— 请留意那一轮回复怎么处理它。',
+    'session.selfHeal.injected.notDelivered': '{lead}没有送达:这个会话还被较早的一轮回复占着{id},而且没有可以回答来放行的打开的卡{noView}。sema 没有重试,所以模型没有看到它。',
+    'session.selfHeal.decisionInFlight': '上一个 turn 处于 parked 状态,{parkedOn},而你对那张卡的回答还在送往引擎的路上,所以 sema 没有再次显示那张卡 —— 再回答一次会发出第二个决断。它没有取消这次 run。你的消息没有发出;请稍等片刻,等引擎应用了那个决断之后再发一次。',
+    'session.selfHeal.parkedOn.ask': '在等你的决断(run {taskId})',
+    'session.selfHeal.parkedOn.plan': '停在一次计划审阅上(run {taskId})',
+    'session.selfHeal.row.decisionPending': '这个会话被较早的一个 turn{handle}占着,它在等你还没做出的一个决断,并且有一张决断卡开着。sema 没有取消它 —— 回答那张卡才会释放这个会话,而取消等于替你做了决断。你的消息没有发出;请回答那张打开的卡,然后再发一次。',
+    'session.selfHeal.row.askReopened.firstSight': '上一个 turn 推进到了一个需要你做的决断(run {taskId}),所以新的内容起不来 —— sema 已经把那张决断卡显示出来了。请回答它,然后再发一次你的消息。(sema 没有取消这次 run:取消等于替你做了决断。)',
+    'session.selfHeal.row.askReopened.reseen': '上一个 turn 处于 parked 状态,在等你的决断(run {taskId}),所以新的内容起不来 —— 那张卡被关掉了却没有回答,所以 sema 把它重新打开了。请回答它,然后再发一次你的消息。(sema 没有取消这次 run:取消等于替你做了决断。)',
+    'session.selfHeal.row.planReviewReopened.firstSight': '上一个 turn 产出了一份在等你审阅的计划(run {taskId}),所以新的内容起不来 —— sema 已经把审阅卡显示出来了。请回答它,然后再发一次你的消息。(sema 没有取消这次 run:取消等于替你把计划丢掉了。)',
+    'session.selfHeal.row.planReviewReopened.reseen': '上一个 turn 处于 parked 状态,在等你审阅它的计划(run {taskId}),所以新的内容起不来 —— 那张审批卡被关掉了却没有回答,所以 sema 把它重新打开了。请回答它,然后再发一次你的消息。(sema 没有取消这次 run:取消等于替你把计划丢掉了。)',
+    'session.selfHeal.row.askDecided.confirmed': '上一个 turn 曾 parked 在一个审批上,你的权限规则自己做了决断(不需要卡);run {taskId} 已经 resume,引擎确认它不再占着这个会话 —— sema 正在重新发送你的消息。',
+    'session.selfHeal.row.askDecided.inferred': '上一个 turn 曾 parked 在一个审批上,你的权限规则自己做了决断(不需要卡);run {taskId} 已经 resume 并随后结束 —— sema 正在重新发送你的消息;如果那次 run 还没完全放开这个会话,你可能得再发一次。',
+    'session.selfHeal.row.askDecided.releaseUnknown': '上一个 turn 曾 parked 在一个审批上,你的权限规则自己做了决断(不需要卡),所以 run {taskId} 应该正在 resume{status}。sema 还不能确认它已经结束,所以你的消息没有发出 —— 请稍等片刻再发一次。',
+    'session.selfHeal.row.askReopenFailed.withKeep': '上一个 turn 处于 parked 状态,在等你的决断(run {taskId}),而 sema 没能在这里重新打开那张卡{noView}。它没有取消这次 run —— 那等于替你做了决断。你的消息没有发出。想保住这段对话,请{keep}:会话 resume 之后,如果它还在等,那张卡会回来。如果你不再需要它,也可以{wayOut}。{viaEngine}',
+    'session.selfHeal.row.askReopenFailed.noKeep': '上一个 turn 处于 parked 状态,在等你的决断(run {taskId}),而 sema 没能在这里重新打开那张卡{noView}。它没有取消这次 run —— 那等于替你做了决断。你的消息没有发出;如果你不再需要它,请{wayOut}。{viaEngine}',
+    'session.selfHeal.row.planReopenFailed.dismissed': '上一个 turn 处于 parked 状态,在等一次计划审阅(run {taskId}),而你关掉了它的审批卡 —— {closed}。它没有取消这次 run —— 那等于替你把计划丢掉了。你的消息没有发出;再发一次可以把卡叫回来。',
+    'session.selfHeal.row.planReopenFailed.withKeep': '上一个 turn 处于 parked 状态,在等一次计划审阅(run {taskId}),而 sema 没能重新打开那张审批卡{noView}。它没有取消这次 run —— 那等于替你把计划丢掉了。你的消息没有发出。想保住这段对话,请{keep}:会话 resume 之后,如果它还在等,那张卡会回来。如果你不再需要那份计划,也可以{wayOut}。{viaEngine}',
+    'session.selfHeal.row.planReopenFailed.noKeep': '上一个 turn 处于 parked 状态,在等一次计划审阅(run {taskId}),而 sema 没能重新打开那张审批卡{noView}。它没有取消这次 run —— 那等于替你把计划丢掉了。你的消息没有发出;如果你不再需要那份计划,请{wayOut}。{viaEngine}',
+    'session.selfHeal.row.steered.textOnly': '只有你消息的文字交了出去 —— steer 不带附件,所以那次提交里的图片都没有送出。',
+    'session.selfHeal.row.steered.tail.following': 'sema 正在跟着那次 run,它接下来要什么都会显示出来。',
+    'session.selfHeal.row.steered.tail.watch': '请留意那次 run 怎么处理它。',
+    'session.selfHeal.row.steered.unknownTail.following': 'sema 正在跟着那次 run,它接下来要什么都会先显示出来,你再决定要不要重发。',
+    'session.selfHeal.row.steered.unknownTail.watch': '重发之前请先留意那次 run。',
+    'session.selfHeal.row.steered.applied': 'sema 把你的消息交给了已经在干活的那次 run(run {taskId})—— 引擎已把它应用到那次 run 上,所以会在那次 run 的下一步被取用。{textOnly}没有取消任何东西,你的消息也没有开启新的 turn —— {tail}',
+    'session.selfHeal.row.steered.parked.withStatus': '停着(状态 {status})',
+    'session.selfHeal.row.steered.parked.plain': '停着',
+    'session.selfHeal.row.steered.next.shown': 'sema 已经把那张决断卡显示出来了 —— 回答它才能让那次 run resume 并取用你的消息。',
+    'session.selfHeal.row.steered.next.inFlight': '你对那个决断的回答还在送往引擎的路上,所以 sema 没有再次显示那张卡;引擎应用它之后,那次 run 就会继续。',
+    'session.selfHeal.row.steered.next.dismissed': '那张决断卡是你自己关掉的,所以 sema 没有把它放回屏幕;在那个决断做出之前,没有任何东西会让那次 run resume —— 发一条消息可以把卡叫回来。',
+    'session.selfHeal.row.steered.next.cannotShow': 'sema 没能在这里把那张决断卡显示出来{noView},所以在那个决断做出之前,没有任何东西会让那次 run resume;如果你不再需要它,请{wayOut}。',
+    'session.selfHeal.row.steered.queued': 'run {taskId} 其实此刻并没有在干活:引擎报告它{parked}在一个需要你做的决断上,所以把你的消息排在了那次 park 上,没有运行它。{next}{textOnly}没有取消任何东西,你的消息也没有开启新的 turn。',
+    'session.selfHeal.row.steered.parkedForWake': 'run {taskId} 已经结束了,所以引擎把你的消息 parked 在了那次已结束的 run 上,没有运行它 —— parked 的消息只有在这个会话于引擎上被唤醒(POST /v1/sessions/:id/wake)时才会送达,而 sema 在这里不做这件事。那次 run 已不再占着这个会话:请再发一次你的消息,把它作为新的 turn 运行 —— 但请注意,那份 parked 的副本并没有被丢弃,所以如果将来有什么在引擎上唤醒了这个会话,这条指令会再运行第二次。{textOnly}没有取消任何东西。',
+    'session.selfHeal.row.steered.reported': '(它把那次 run 报告为 {status})',
+    'session.selfHeal.row.steered.unknown': 'sema 把你的消息交给了 run {taskId},但引擎没有说会怎样送达{reported}。{textOnly}没有取消任何东西,你的消息也没有开启新的 turn —— {tail}',
+    'session.selfHeal.row.steerFailed.rejected': '把你的消息交给正在运行的 run(run {taskId})被拒绝了:{detail}。sema 没有重试(steer 不能安全地发两次),也没有取消那次 run。你的消息没有发出;如果你还想要它,请再发一次。',
+    'session.selfHeal.row.steerFailed.unknown': 'sema 把你的消息发给了正在运行的 run(run {taskId}),但无法确认它的下场({detail})。steer 不能安全地发两次,所以 sema 没有重试,也没有取消那次 run。那次 run 可能收到了你的消息,也可能没收到 —— 重发之前请先看它接下来怎么做。',
+    'session.selfHeal.row.attach': '{disclosure}你的消息没有发出;等那次 run 结束后,请再发一次。',
+    'session.selfHeal.row.cancelled.confirmed': '你选择了取消 run {taskId}。引擎确认它不再占着这个会话,所以 sema 现在就发送你的消息。',
+    'session.selfHeal.row.cancelled.reported': '你选择了取消 run {taskId}。引擎现在报告那次 run 已结束,所以 sema 现在就发送你的消息;如果那次 run 还没完全放开这个会话,你可能得再发一次。',
+    'session.selfHeal.row.cancelTimeout.aborted': 'sema 请引擎取消 run {taskId},而你在它还在确认的时候中断了(已过 {waited})。取消是异步的,所以那次 run 可能仍在收尾,仍占着这个会话。你的消息没有发出;请稍等片刻再发一次,或者{wayOut}。',
+    'session.selfHeal.row.cancelTimeout.unread': 'sema 请引擎取消 run {taskId},但在 {waited} 内读不回那次 run 的状态,所以确认不了会话是否已被释放。你的消息没有发出;请稍等片刻再发一次(如果那次 run 真的没了,它就会直接运行),或者{wayOut}。',
+    'session.selfHeal.row.cancelTimeout.held': 'sema 请引擎取消 run {taskId},但 {waited} 之后那次 run 仍占着这个会话 —— 取消是异步的,它可能仍在收尾。你的消息没有发出;请稍等片刻再发一次,或者{wayOut}。',
+    'session.selfHeal.row.cancelFailed.unknown': 'sema 发出了对 run {taskId} 的取消,但无法确认它的下场({detail}),也没能读回那次 run 已被释放。那次 run 可能仍占着这个会话,也可能没有。你的消息没有发出;请稍等片刻再发一次,或者{wayOut}。',
+    'session.selfHeal.row.cancelFailed.rejected': 'sema 没能取消 run {taskId} —— 引擎拒绝了那个请求({detail}),所以什么都没有被取消,sema 也说不准那次 run 是否仍占着这个会话。你的消息没有发出;请再发一次看看,或者{wayOut}。',
+    'session.selfHeal.row.askRunNotFound': '上一个 turn 被记录为 parked 在一个决断上(run {taskId}),但它在等的那个审批已经不在引擎上了,而直接向引擎询问那次 run 得到的是 not-found —— 这种查询分不清是那次 run 真的没了,还是这个会话根本无权读取它。无论哪种,sema 在这里都没有可以操作的东西,所以没有取消任何东西。你的消息没有发出;请再发一次(如果会话真的空闲,它就会直接运行),或者{wayOut}。',
+    'session.selfHeal.row.askRunSettled': '上一个 turn 曾被记录为 parked 在一个决断上(run {taskId}),但那次 run 已经结束了(状态 {status})—— 没有什么可回答的,也没有什么可取消的,所以 sema 没有取消任何东西。你的消息没有发出;请再发一次(那次 run 放开会话之后,它就会直接运行),或者{wayOut}。',
+    'session.selfHeal.row.stale.cancelled.confirmed': 'run {taskId} 曾 parked 在一个已经不在引擎上的审批上,所以没有什么需要你回答了。你选择了取消那次 run,引擎确认它不再占着这个会话,所以 sema 现在重新发送你的消息。',
+    'session.selfHeal.row.stale.cancelled.reported': 'run {taskId} 曾 parked 在一个已经不在引擎上的审批上,所以没有什么需要你回答了。你选择了取消那次 run:引擎现在报告它已结束,所以它不会 resume —— 那个 turn 没做完的事不会回来了。sema 现在重新发送你的消息;如果那次 run 还没完全放开这个会话,你可能得再发一次。',
+    'session.selfHeal.row.stale.cancelTimeout.aborted': 'sema 请引擎取消 run {taskId}(它 parked 在一个已经不在那里的审批上),而你在它还在确认的时候中断了(已过 {waited})。取消是异步的,所以那次 run 可能仍在收尾,仍占着这个会话。你的消息没有发出;请稍等片刻再发一次,或者{wayOut}。',
+    'session.selfHeal.row.stale.cancelTimeout.unread': 'sema 请引擎取消 run {taskId}(parked 在一个已经不在那里的审批上),但在 {waited} 内读不回那次 run 的状态,所以确认不了会话是否已被释放。你的消息没有发出;请稍等片刻再发一次(如果那次 run 真的没了,它就会直接运行),或者{wayOut}。',
+    'session.selfHeal.row.stale.cancelTimeout.held': 'sema 请引擎取消 run {taskId}(parked 在一个已经不在那里的审批上),但 {waited} 之后那次 run 仍占着这个会话 —— 取消是异步的,它可能仍在收尾。你的消息没有发出;请稍等片刻再发一次,或者{wayOut}。',
+    'session.selfHeal.row.stale.cancelFailed.unknown': 'sema 发出了对 run {taskId}(parked 在一个已经不在引擎上的审批上)的取消,但无法确认它的下场({detail}),也没能读回那次 run 已被释放。那次 run 可能仍占着这个会话,也可能没有。你的消息没有发出;请稍等片刻再发一次,或者{wayOut}。',
+    'session.selfHeal.row.stale.wait.offered': 'run {taskId} 仍 parked(状态 {status})在一个已经不在引擎上的审批上。sema 已经问过该拿它怎么办,你选了不动它,所以不再问了。你的消息没有发出;请在引擎上取消那次 run(POST /v1/runs/{taskId}/cancel —— 这会彻底结束它),或者{wayOut}。',
+    'session.selfHeal.row.stale.wait.first': 'run {taskId} 仍 parked(状态 {status})在一个已经不在引擎上的审批上,所以没有卡可回答了,那次 run 也不会自己落定。sema 没有取消它 —— 是你选了不动它。你的消息没有发出;请在引擎上取消那次 run(POST /v1/runs/{taskId}/cancel —— 这会彻底结束它),或者{wayOut}。',
+    'session.selfHeal.row.runNotFound': '引擎报告这个会话被 run {taskId} 占着(状态 running),但直接询问时它已经不认识那次 run 了 —— 这个占用声明看起来已过期(那次 run 多半已经不存在)。sema 没有提议 steer 或取消它:已经没有可操作的东西了。你的消息没有发出;请再发一次(如果会话真的空闲,它就会直接运行),或者{wayOut}。',
+    'session.selfHeal.row.runSettled': 'run {taskId} 已经结束了(状态 {status}),但引擎仍报告它占着这个会话 —— 这个占用声明看起来已过期,或正在释放中。sema 没有提议 steer 或取消它:那次 run 已经结束。你的消息没有发出;请再发一次(占用声明清掉之后,它就会直接运行),或者{wayOut}。',
+    'session.selfHeal.row.notParked.offered': 'run {taskId} 仍占着这个会话(状态 {status})。sema 已经问过该拿它怎么办,你选了不动它,所以不再问了。你的消息没有发出;请等那次 run 结束,或在引擎上取消它(POST /v1/runs/{taskId}/cancel),或者{wayOut}。',
+    'session.selfHeal.row.notParked.parkedOn': '这个会话被较早的一次 run(run {taskId},状态 {status})占着,它在等{parkedOn} —— 它不会自己结束。sema 没有取消它,因为取消等于替你决定了那一项。你的消息没有发出;如果你不再需要它,请{wayOut}。',
+    'session.selfHeal.row.notParked.inFlight': '这个会话已经有一次 run 在跑了(run {taskId},状态 {status})—— 多半是你送去后台的一个 turn。sema 没有取消它,因为那会丢掉你要的活。请等它结束,或者{wayOut}。',
+    'session.selfHeal.row.stateUnknown': '这个会话上仍有一次 run 在活动{handle},而 sema 读不出那次 run 的状态,所以没有动它({detail})。sema 没有发送你的消息:在那次 run 落定之前,这个会话开不了新的 turn —— {wayOut}。',
+    'session.selfHeal.headless.status': '(状态 {status})',
+    'session.selfHeal.headless.decide': '这个会话被较早的一次 run{handle}占着{status},它 parked 在等{gate},所以这条消息没有发出。决定它,会话就解锁:POST {decidePath}。改为取消({cancelPath})也能解锁,但那等于替你否决了那一项。或者{freshSession}。{governance}',
+    'session.selfHeal.headless.statusOnly': '这个会话被较早的一次 run{handle}占着,状态是 {status},所以这条消息没有发出。引擎报告那次 run 上没有待决的决断:如果它还在干活,请等它结束;如果它永远落定不了,用 {cancelPath} 释放它(那会丢掉它正在做的事)。或者{freshSession}。',
+    'session.selfHeal.headless.neverReleased': '这个会话上仍有一次 run 在活动{handle},而且从未被释放,所以 sema 没有发送这条消息。这里没有任何东西会自己清掉。{startOver},或者在引擎上释放那次 run:{cancelPath}',
+    'approval.deniedBy.policy': '被这个部署的权限策略拒绝',
+    'approval.deniedBy.hook': '被 PreToolUse hook 拒绝',
+    'approval.deniedBy.org': '被一条组织规则拒绝',
+    'approval.deniedBy.persistedRule': '被一条持久规则拒绝',
+    'approval.deniedBy.classifier': '被 auto 模式分类器拒绝',
+    'approval.deniedBy.compliance': '被合规锁拒绝',
+    'approval.deniedBy.writeProtection': '被拒绝,因为这次写入落在了写保护路径上',
+    'approval.deniedBy.askResolution': '在这次审批被处理时被拒绝',
+    'approval.deniedBy.readBoundary': '被读取边界拒绝',
+    'approval.deniedBy.mode': '被这个会话的权限模式拒绝',
+    'approval.deniedBy.unknown': '被一个这个版本不认识的层拒绝({word}) —— 这个版本不认识这个层名,所以说不清是哪一层拒绝了这次调用、为什么拒绝',
+    'approval.card.noWord': '(无)',
+    'approval.origin.contentQuestion': '工具自己向你提了一个问题',
+    'approval.origin.planReview': '模型为了请你对它提出的计划下判断,让它的 run 停了下来',
+    'approval.origin.ancestorMarked': '一个祖先任务标记了这次调用(继承来的「审批者不可用」浮标,或一条耐久强制令;光凭出身,这个客户端分不出是哪一种):它必须不经任何同步决策者,直接进入停驻(park)',
+    'approval.origin.orgUnavailable': '组织策略当时不可用,所以这次调用要问你',
+    'approval.origin.orgRule': '一条组织规则要求就这次调用询问你',
+    'approval.origin.ruleStoreUnavailable': '这次调用没法对照你的常驻 deny/ask 规则检查,所以要问你',
+    'approval.origin.hook': 'PreToolUse hook 就这次调用提了问',
+    'approval.origin.askRule': '一条已保存的 ask 规则命中了这次调用',
+    'approval.origin.denialLimitFallback': 'auto 模式分类器达到了它的拒绝上限,把这次调用交回给你',
+    'approval.origin.shellGateTighten': '粗粒度的 shell 检查把这条命令评在它放行的档位之上,所以要问你',
+    'approval.origin.safetyTighten': '门依据这次调用自身的事实收紧了(网络外联、不可逆性,或受保护的写入;光凭出身,这个客户端分不出是哪一种)',
+    'approval.origin.policy': '这个部署的权限策略,或权限模式的缺省设置,要求就这次调用询问你',
+    'approval.origin.unknownWithWord': '这次调用要问你;它的出身 {word} 是比这个客户端更新的词,请照常回答',
+    'approval.origin.unknownNoWord': '这次调用要问你;它的出身是比这个客户端更新的词,请照常回答',
+    'approval.ruleOffer.absence.allowOutranked': '这里没有「不再询问」这一选项:已经有一条 allow 规则命中了这次调用,但这一问的优先级更高 —— 再加一条 allow 规则也会被同样压过',
+    'approval.ruleOffer.absence.askRuleMatched': '这里没有「不再询问」这一选项:一条 ask 规则命中了这次调用,并会一直询问 —— 它还在的时候,allow 规则改变不了什么;想不再被询问,请检查你的 ask 规则',
+    'approval.ruleOffer.absence.askRuleMatchedDeploymentList': '这里没有「不再询问」这一选项:这个部署对这个工具的每次调用都会询问,你自己的规则关不掉它 —— 选 "in this session" 这一项,可以让它在本会话结束之前不再询问',
+    'approval.ruleOffer.absence.laneCannotSpeak': '这里没有「不再询问」这一选项:这条审批通道存不了规则',
+    'approval.ruleOffer.absence.unknown': '这里没有「不再询问」这一选项(原因是这个版本还不认识的一种)',
+    'approval.ruleOffer.uncovered.redirection': '一直会询问(shell 重定向)',
+    'approval.ruleOffer.uncovered.noRuleForm': '没有可覆盖的规则形式',
+    'approval.ruleOffer.uncovered.capOverflow': '被候选条数上限裁掉了',
+    'approval.ruleOffer.uncovered.unknown': '这个版本还不认识的一种原因',
+    'approval.mandate.generic': '任何已保存的 allow 规则和记住的回答都清不掉这一问;每次调用都单独决断 —— 在这里由你来答,或由部署运行的自动检查来答 —— 而且一次回答只管那一次调用',
+    'approval.mandate.noAutomaticCheck': '任何已保存的 allow 规则和记住的回答都清不掉这一问,也没有任何自动检查能回答它;每次调用都单独决断,在这里由你来答,而且一次回答只管那一次调用',
+    'approval.mandate.word.operatorAlways': '这个部署要求对每条 shell 命令单独确认,而这次调用就是其中之一',
+    'approval.mandate.word.toolMarks': '这个工具声明它会触及本机之外,或做出无法撤销的改动',
+    'approval.mandate.word.probeMandate': '对这次调用运行的检查把它标成了需要单独确认(内置的 shell 检查会对读取本会话允许目录之外的路径这样标)',
+    'approval.mandate.word.probeUnanswered': '对这次调用运行的检查没有给出答复(超时或失败了;这个客户端分不出是哪种),所以这次调用是否留在本会话允许的目录之内,不得而知',
+    'approval.mandate.word.writeProtection': '这次改动落在受保护的位置(代理自己的配置)上,这类改动要逐次确认',
+    'approval.mandate.word.targetUnresolved': '这次改动落在磁盘上哪里,没能确定(路径上的一个链接没能检查,或目标没能解析),所以它是否落在受守护的位置上,不得而知',
+    'approval.mandate.unknownWord': '这次确认所报告的原因,这个客户端不认识,所以不显示原因',
+    'approval.card.payloadUnreadable': '这个客户端读不懂这张审批卡的格式,所以只显示它的基本事实 —— 请据此决定,不确定它会做什么的话就拒绝它。',
+    'approval.card.more.one': '这张卡还有 1 条原因没有显示。',
+    'approval.card.more.other': '这张卡还有 {count} 条原因没有显示。',
+    'approval.card.denialLimit.plain': 'auto-deny 上限已到 —— auto 模式自己拒绝的调用已经够多,引擎现在要一个真人来决断;到目前为止连续 {consecutive} 次 / 共 {total} 次自动拒绝;触发的上限:{limit}',
+    'approval.card.denialLimit.withAutoDeny': 'auto-deny 上限已到 —— auto 模式自己拒绝的调用已经够多,引擎现在要一个真人来决断;到目前为止连续 {consecutive} 次 / 共 {total} 次自动拒绝;触发的上限:{limit};如果没人回答,引擎会在 {seconds} 秒后自动拒绝它',
+    'approval.card.shadow.unreadable': '有一条 allow 规则命中了这次调用,但清不掉这一问;读不出是哪一条规则,所以这一问要单独确认。',
+    'approval.card.shadow.single': '你保存的权限规则 {entry} 仍然在 —— 只是它清不掉这一次调用,所以这一问要单独确认。',
+    'approval.card.shadow.several': '有 allow 规则命中了这次调用,但清不掉这一问,所以这一问要单独确认 —— {members}。',
+    'approval.card.shadow.unrecognisedSource': '一个无法识别的来源',
+    'approval.card.shadow.memberUnreadable': '{word}(读不出来)',
+    'approval.card.shadow.memberWithParts': '{word}:{parts}',
+    'approval.card.shadow.partJoin': ';',
+    'approval.card.shadow.moreNotListed': '另有 {count} 条没列出',
+    'approval.card.shadow.notListed': '{count} 条没列出',
+    'approval.card.shadow.partUnreadable': '其中一部分读不出来',
+    'approval.probe.withProse': '自动检查没能放行这次调用,所以改问你。',
+    'approval.probe.withProseCode': '自动检查没能放行这次调用,所以改问你(检查码:{code})。',
+    'approval.probe.noProse': '自动检查没能放行这次调用,所以改问你;引擎没有说明具体原因。',
+    'approval.probe.noProseCode': '自动检查没能放行这次调用,所以改问你;引擎没有说明具体原因(检查码:{code})。',
+    'approval.probe.proseJoin': '{sentence}{prose}',
+    'approval.priorCard.earlier.allowed': '你已经批准过更早的那一张',
+    'approval.priorCard.earlier.denied': '更早的那一张被拒绝了',
+    'approval.priorCard.earlier.shown': '更早的那一张先呈现过',
+    'approval.priorCard.fromRule': '这是同一次调用的第二个审批:{earlier},那一张是你的 ask 规则要求的。这一张是另一道检查,不是出自你的 ask 规则,需要单独回答。',
+    'approval.priorCard.plain': '这是同一次调用的第二个审批:{earlier}。这一张是另一道检查,需要单独回答。',
+    'approval.classifier.noRulingError': 'auto 模式分类器没能对这次调用运行(它失败了),所以改问你。',
+    'approval.classifier.noRulingTimeout': 'auto 模式分类器没能对这次调用运行(它超时了),所以改问你。',
+    'approval.classifier.noRulingParseError': 'auto 模式分类器对这次调用作了答复,但没有给出可用的裁决,所以改问你。',
+    'approval.classifier.noRulingOther': 'auto 模式分类器没有对这次调用作出裁决(原因:{reason}),所以改问你。',
+    'approval.classifier.noRulingBare': 'auto 模式分类器没有对这次调用作出裁决,所以改问你。',
+    'approval.boundGrants.noSkill': '这次调用没有点到任何已加载的技能,所以批准它除了这次调用本身,不授予任何东西。',
+    'approval.boundGrants.listsNoTools': '批准这一张会激活卡上的技能;它没有列出免问运行的工具,也没有列出要拒的工具。',
+    'approval.boundGrants.allowPart.one': '它列出的 1 条工具条目,在技能激活后免问运行',
+    'approval.boundGrants.allowPart.other': '它列出的 {count} 条工具条目,在技能激活后免问运行',
+    'approval.boundGrants.denyPart.one': '1 条工具条目在本次 run 剩余的时间里被拒绝',
+    'approval.boundGrants.denyPart.other': '{count} 条工具条目在本次 run 剩余的时间里被拒绝',
+    'approval.boundGrants.activates': '批准这一张会激活卡上的技能:{allow},且 {deny}。',
+    'session.fileHistoryRefusal.notYet': '没有发送:你的设置里已关闭文件检查点,但这台引擎的能力信息还没读到,所以不知道它能否按会话停止记录文件历史,现在发送仍可能把它记录下来。请稍后再试;如果要照常发送、并让这一次的文件历史被记录,请在设置里把文件检查点重新打开。',
+    'session.fileHistoryRefusal.notSaid': '没有发送:你的设置里已关闭文件检查点,但这台引擎没有报告它能否按会话停止记录文件历史,所以现在发送仍可能把它记录下来。只要这台引擎还是同样的报告,重试也不会改变这一点;要发送并让这一次的文件历史被记录,请在设置里把文件检查点重新打开。',
+    'session.fileHistoryRefusal.unrecognized': '没有发送:你的设置里已关闭文件检查点,但这台引擎报告了一个本客户端不认识的文件历史捕获模式,所以不知道它能否按会话停止记录文件历史,现在发送仍可能把它记录下来。只要这台引擎还是同样的报告,重试也不会改变这一点;要发送并让这一次的文件历史被记录,请在设置里把文件检查点重新打开。',
+    'session.fileHistoryRefusal.unreadable': '没有发送:你的设置里已关闭文件检查点,但这台引擎关于能否按会话停止记录文件历史的报告,本客户端读不出来,所以现在发送仍可能把它记录下来。只要这台引擎还是同样的报告,重试也不会改变这一点;要发送并让这一次的文件历史被记录,请在设置里把文件检查点重新打开。',
+    'model.identity.lane.processEnv': '本客户端启动时的环境',
+    'model.identity.lane.settingsEnv': '本客户端的设置文件',
+    'model.identity.lane.modelCatalogFile': '本地模型目录文件',
+    'model.identity.lane.followedSettingsFile': '本客户端所跟随的另一个工具的设置文件',
+    'model.identity.lane.followedProviderEnv': '本客户端所跟随的供应商环境变量',
+    'model.identity.routeGap.fact.endpointMissing': '这个模型走 OpenAI 兼容路由,而网关地址(MODEL_GATEWAY_BASEURL)没有设置,引擎没有网关地址就拒绝启动',
+    'model.identity.routeGap.fact.laneCredentialMissing': '已选择 anthropic 通道(MODEL_PROVIDER=anthropic),ANTHROPIC_API_KEY 与 ANTHROPIC_AUTH_TOKEN 都没有设置,也没有网关地址(MODEL_GATEWAY_BASEURL)可回落,所以引擎在任何路由上都起不来',
+    'model.identity.routeGap.sentence': '{lane}提供了模型名,但本机引擎没有可达它的路由 —— {fact}',
+    'config.hooks.valueShape.nothing': '没有值',
+    'config.hooks.valueShape.null': '空值 null',
+    'config.hooks.valueShape.array': '一个数组',
+    'config.hooks.valueShape.object': '一个对象',
+    'config.hooks.valueShape.typeof': '一个 {type} 类型的值',
+    'config.hooks.valueShape.unreadable': '读不出的值',
+    'config.hooks.forWire.gotShape': 'hooksForWire:请传 { plan },值取这一回合 hooksWirePlan() 返回的计划 —— 收到了{shape}。',
+    'config.hooks.forWire.readPlanThrew': 'hooksForWire:请传 { plan },值取这一回合 hooksWirePlan() 返回的计划 —— 读取 opts.plan 时抛了异常。',
+    'config.hooks.forWire.readWireThrew': 'hooksForWire:请传 { plan },值取这一回合 hooksWirePlan() 返回的计划 —— 读取计划的 wire 时抛了异常。',
+    'config.hooks.forWire.planUnreadable': 'hooksForWire:请传 { plan },值取这一回合 hooksWirePlan() 返回的计划 —— opts.plan 读不成一份计划。',
+    'config.hooks.forWire.planPassedBare': 'hooksForWire:请传 { plan },值取这一回合 hooksWirePlan() 返回的计划 —— 传进来的是计划本身;请包成 { plan }。',
+    'config.hooks.forWire.planMissing': 'hooksForWire:请传 { plan },值取这一回合 hooksWirePlan() 返回的计划 —— opts.plan 缺失。',
+    'config.hooks.forWire.planNotPlan': 'hooksForWire:请传 { plan },值取这一回合 hooksWirePlan() 返回的计划 —— opts.plan 不是这样的计划(收到了{shape})。',
+    'config.taskRequest.memoryOff.settingsSectionNotObject': 'memoryOffDeclared: settings 的 memory 段必须是对象 —— 收到 {shape}。',
+    'config.taskRequest.memoryOff.enabledNotBoolean': 'memoryOffDeclared: settings memory.enabled 在场时必须是布尔 —— 收到 {shape}。',
+    'config.taskRequest.inputKeysUnreadable': 'buildTaskRequest: 入参的键集 / 属性描述符读不出(代理 trap 抛)—— 无法安全快照声明,拒绝装配。错误文本只报形状,不回显值。',
+    'config.taskRequest.userInvokedSkillsMalformed': 'buildTaskRequest: userInvokedSkills 只接受字符串数组(`[]` / 缺席 = 没点名)—— 收到 {shape}。这一位是人用名字点过的技能:本层若把坏形静默删键,这一 run 会按「没点名」跑,声明人以为点过了。值经片段口 userInvokedSkillsDeclaration 给。错误文本只报形状,不回显值。',
+    'config.taskRequest.hostSettingsMalformed': 'buildTaskRequest: hostSettings 只接受 hostTurnSettings({ sources }) 的产物或缺席 —— 收到 {shape}。宿主自供的四把 settings 子键(hooks / resolved / webSearch / outputStyle)只经这只产物进请求体;把读不懂的产物当缺席 = 权限快照与 hooks 静默不带。错误文本只报形状,不回显值。',
+    'config.taskRequest.hostSuppliedKeysByHand': 'buildTaskRequest: {keys} 由宿主经装配产物供 —— 改交 hostSettings: hostTurnSettings({ sources: { {fields} } })。0.99.0 起这几把键只有这一条进请求体的路(漏接在产物上一行一键可见);入参 settings 上只剩渲染端载的 ultracode。错误文本只报键名,不回显值。',
+    'config.taskRequest.requireExisting.shapeAbsent': '缺席',
+    'config.taskRequest.requireExisting.shapeEmpty': '空串',
+    'config.taskRequest.requireExisting.layerAssembly': '本层在装配前拒,不让它走一次往返。',
+    'config.taskRequest.requireExisting.layerLive': '本层(live 兜底层)落位之后复判:宿主交的 mock 会话常量让本层删掉了会话 id、又没有已捕获的会话 id,而断言不删(删 = 找不到就静默新开)⇒ 在发出前拒,不让它走一次往返。',
+    'config.taskRequest.requireExisting.noSession': '{where}: requireExistingSession: true 要求续一个已存在的会话,但 sessionId {shape} —— 没有可续的会话。上游对这一形同样拒收(不会新开会话,也不会续上任何东西);{layer}处置:要续哪个会话,就把它的 id 交在 sessionId 上;要开新会话,就别带 requireExistingSession(或给 false)。错误文本只报形状,不回显值。',
+    'config.assembly.thrownDuringAssembly': '{who}: 装配时出错,拒绝装配(原抛出物见 cause)。',
+    'session.steerRefusal.notRunning.happened': '那个 run 现在不接收消息 —— 它刚刚结束,或正在另一台服务器上运行,或不是它所在会话的活动 run',
+    'session.steerRefusal.notRunning.nextStep': '先看一下它当前的状态,再把消息发给处于活动状态的 run',
+    'session.steerRefusal.invalidContent.happened': '消息被拒了,因为它的文本里含有引擎不接受的控制标记,所以什么都没有送达',
+    'session.steerRefusal.invalidContent.nextStep': '改写这条消息后再发一次',
+    'session.steerRefusal.queueFull.happened': '那个 run 已暂停,等待中的消息已达它能容纳的上限,所以这一条没有被接受',
+    'session.steerRefusal.queueFull.nextStep': '等排队的消息送达之后(run 恢复或会话被唤醒时)再发一次',
+    'session.steerRefusal.duplicateInputId.happened': '这个幂等键下已经接受过另一条不同的指令,先前那条指令仍然有效',
+    'session.steerRefusal.duplicateInputId.nextStep': '如果你改了文字,请用新的键发送新文字;否则不要重发 —— 换一个新键会把同一条指令送达两次',
+    'session.steerRefusal.ambiguousTarget.happened': '有不止一个正在运行的代理匹配这个目标,所以消息没有送达',
+    'session.steerRefusal.ambiguousTarget.nextStep': '子代理请用它的 tool-call id 指定;工作流代理在还有别的运行中的代理与它同名标签时无法被单独点名,所以等只剩一个时再发一次',
+    'session.steerRefusal.stillRunning.happened': '那个代理还在运行,所以不能被恢复',
+    'session.steerRefusal.stillRunning.nextStep': '改为给它发一条消息,或者等它结束',
+    'session.steerRefusal.blockedByHook.happened': '消息没有被接受:这个部署上的提示检查拦下了它,所以什么都没有送达',
+    'session.steerRefusal.blockedByHook.nextStep': '修改消息后再发一次 —— 这不算重复提交',
+    'session.steerRefusal.ledgerUnavailable.happened': '服务器没能记录这条消息,在任何内容到达引擎之前就拒绝了它,所以什么都没有送达',
+    'session.steerRefusal.ledgerUnavailable.nextStep': '稍后再把同样的文字发一次',
+    'session.steerRefusal.steeringOther.happened': '消息因一个这个版本不认识的原因被拒,所以没有落地',
+    'session.steerRefusal.steeringOther.nextStep': '如果一直这样,请上报它的错误码;不要去猜它的意思',
+    'session.steerRefusal.steeringOtherUnknown.happened': '消息因一个这个版本不认识的原因被拒,而它有没有送达并不清楚',
+    'session.steerRefusal.steeringOtherUnknown.nextStep': '不要把它当作肯定没送到而重发 —— 先看一下那个 run,如果一直这样,请上报它的错误码',
+    'session.steerRefusal.advice': '{happened} —— {nextStep}',
+    'session.steerRefusal.hostQueue.queued': '它留在队列里,在这个 turn 结束时会原样提交',
+    'session.steerRefusal.hostQueue.dropped': '它没有被保留;{nextStep}',
+    'notice.capability.subject.userInvokedSkills': '用户点名的技能',
+    'notice.capability.subject.skillToolLists': '技能工具清单',
+    'notice.capability.subject.permissionRulesWrite': '权限规则写入口',
+    'notice.capability.subject.workflowsJournal': '工作流日志',
+    'notice.capability.subject.sessionPolicy': '会话规则面',
+    'notice.capability.subject.mcpProbe': '逐服务器 MCP 状态面',
+    'notice.capability.unreadable.subject': '{subject}读不出来 —— 引擎的 /v1/capabilities 回报到了,但这一项不是本端能读的形状,所以按「未知」显示,而不是按「没有」;只要引擎还这样报,再探同一台引擎也不会变',
+    'notice.capability.unreadable.bare': '读不出来 —— 引擎的 /v1/capabilities 回报到了,但这一项不是本端能读的形状,所以按「未知」显示,而不是按「没有」;只要引擎还这样报,再探同一台引擎也不会变',
+    'notice.capability.unobserved': '{subject}没有观测到 —— 引擎在 /v1/capabilities 上报这一项({key});本进程没有缓存可用的能力读数(没收到过、最近一次读不出,或最近一次在引擎连接重置时被丢弃;本进程分不出是哪一种)',
+    'notice.capability.userInvokedSkills.notReported': '这台引擎没有报告用户点名的技能 —— 这说不清它收不收,所以用户在请求里点名的技能不会被发出',
+    'notice.capability.userInvokedSkills.absent': '用户点名的技能在这个部署上是关着的 —— 请求里点名技能不会被接受',
+    'notice.capability.userInvokedSkills.present': '用户点名的技能已开启 —— 用户在请求里点名的技能会在 run 开始时生效',
+    'notice.capability.skillToolLists.notReported': '这台引擎没有报告技能工具清单 —— 这说不清它读不读,所以请求技能上的工具清单可能并不会限制任何工具',
+    'notice.capability.skillToolLists.absent': '技能工具清单在这个部署上是关着的 —— 请求技能上的工具清单不会被读取',
+    'notice.capability.skillToolLists.present': '技能工具清单已开启 —— 请求技能的允许与禁用工具清单会被当作这个 run 的规则来读取',
+    'notice.capability.permissionRulesWrite.notReported': '这台引擎没有报告权限规则写入口 —— 这说不清入口在不在,所以把它藏起来,不要去调它',
+    'notice.capability.permissionRulesWrite.absent': '这次调用够不着权限规则写入口 —— 要么这个部署没开规则车道,要么这次调用拿不出可验证的身份;引擎对两种情形只报同一位,所以本端分不出是哪一种',
+    'notice.capability.permissionRulesWrite.present': '这次调用够得着权限规则写入口 —— 方向、文本和范围收不收,仍由每一次尝试各自回答',
+    'notice.capability.workflowsJournal.notReported': '这台引擎没有报告工作流日志 —— 这说不清它有没有单独的日志开关,所以仍由工作流列表开关管着日志',
+    'notice.capability.workflowsJournal.absent': '这个部署上没有工作流日志 —— 工作流可以列出和跟随,但读不了它们的执行日志',
+    'notice.capability.workflowsJournal.present': '工作流日志已开启 —— 可以读取工作流的执行日志',
+    'notice.capability.sessionPolicy.notReported': '这台引擎没有报告会话规则面 —— 这说不清这个面在不在,所以先去读规则,不要盲写',
+    'notice.capability.sessionPolicy.absent': '这个部署上没有会话规则店 —— 这里读不了也写不了这个会话的工具规则',
+    'notice.capability.sessionPolicy.present': '会话规则面已开启 —— 可以读取这个会话的工具规则,收紧写入由引擎逐次接受或拒绝',
+    'notice.capability.mcpProbe.unobserved': '逐服务器 MCP 状态面没有观测到 —— 引擎在 /v1/capabilities 上报它有没有这个面;本进程没有缓存可用的能力读数(没收到过、最近一次读不出,或最近一次在引擎连接重置时被丢弃;本进程分不出是哪一种)',
+    'notice.capability.mcpProbe.notReported': '这台引擎没有报告逐服务器 MCP 状态面 —— 这说不清这个面在不在,所以这条路在这里可能并不存在(直接问它,可能得到机读的「路由不存在」答复,但超时或不带码的网关答复两头都说明不了什么);有会话面板的末腿名册时优先用它,否则就把这个原因摆出来,而不是摆一个答不了的入口',
+    'notice.capability.mcpProbe.absent': '逐服务器 MCP 状态面在这个部署上报告为关 —— 这台引擎在那里不回答任何读数;本端不猜原因,而调用方自带的声明会不会被认,是另一位独立的问题、有它自己的答案',
+    'notice.capability.mcpProbe.present': '逐服务器 MCP 状态面已开启 —— 这台引擎按请求去连它自己声明的 MCP 服务器,不需要 run,而对调用方自带声明的探测会答回同一种体形',
+    'notice.capability.hands.noneStem': '这条 run 腿装配时没有任何内置的文件与 shell 工具',
+    'notice.capability.hands.noneTail': '所以在这条腿上,模型没有引擎自己的、用来改文件或跑命令的工具(由别的条件挂载的工具,例如外部服务器,以及委派给别的腿的子 run,不在这一读数的范围内)',
+    'notice.capability.hands.noneLine': '{stem} —— {why},{tail}',
+    'notice.capability.hands.notReported': '这里没有说明这条腿有没有内置的文件与 shell 工具 —— 引擎没有报告它的 hands 接缝(清单的静态一半永远不报);工具名册仍可能回答这个问题',
+    'notice.capability.hands.seamMounted': '这条 run 腿装配时挂上了内置的文件工具 —— 这是引擎自己说的;shell 够不够得着,由工具名册回答,不由这句话回答',
+    'notice.capability.hands.whyNoReason': '引擎声明它在这条腿上没有挂载 hands(没有给原因)',
+    'notice.capability.hands.whyNoExecutionEnv': '引擎声明它在这条腿上没有挂载 hands,因为没有提供执行环境',
+    'notice.capability.hands.whyUnknownReason': '引擎声明它在这条腿上没有挂载 hands(原因:{reason},这是这个版本不认识的词)',
+    'notice.capability.hands.rosterMounted': '这次 run 装配时挂上了文件与 shell 工具(共 {rows} 个)',
+    'notice.capability.hands.rosterNotMounted': '{stem} —— 引擎报告了一份名册,而没有任何一行是由那个条件挂载的,{tail}',
+    'notice.capability.hands.unknownNoManifest': '这次 run 有没有文件与 shell 工具,目前不知道 —— 没有观测到它的装配清单',
+    'notice.capability.hands.unknownNoRoster': '这次 run 有没有文件与 shell 工具,目前不知道 —— 清单里没有带工具名册(静态那一半永远不带;只有引擎铸的生效清单才会报一份)',
+    'notice.capability.hands.unknownRosterUnreadable': '这次 run 有没有文件与 shell 工具,目前不知道 —— 工具名册不是这个读口认识的形状,读不出来',
+    'notice.capability.hands.unknownMountConditionAbsent': '这次 run 有没有文件与 shell 工具,目前不知道 —— 这台引擎不报每个工具是由哪个条件挂载的,所以这里数出一个空的计数,说的是读口的事,不是这次 run 的事',
+    'rules.sessionPolicy.tighten.written': '会话规则已保存(版本 {rev})—— 记录现在包含它原有的全部内容加上这里送来的条目,并从这个会话的下一道工具门起生效;已经在跑的那一步不会被打断。',
+    'rules.sessionPolicy.tighten.conflict': '写入这次收紧的过程中,会话规则被别人改了,连续两次 —— 什么都没写。请重新读一遍当前的规则再试,或者先让另一个写入方写完。',
+    'rules.sessionPolicy.tighten.loosenForbidden': '引擎拒绝了这次写入,因为它会放宽会话规则:这里送来的条目里至少有一条是放宽允许范围而不是收窄。这条路上只接受增加限制的条目。',
+    'rules.sessionPolicy.tighten.capabilityAbsent': '这个部署不保存会话级的工具规则,所以这里没有什么可收紧的。',
+    'rules.sessionPolicy.tighten.capabilityNotReported': '这台引擎没有说明它保不保存会话级的工具规则,所以收紧入口保持隐藏,而不是盲目写入。',
+    'rules.sessionPolicy.tighten.earlierGrammar': '什么都没写:这个会话的规则是在当前规则文法之前保存的,那时用工具自己的规则形式写的 allow 条目(例如 Bash(git:*))会被当成普通工具名来读,因此什么都不放行。现在把记录写回去,会用当前文法读这些条目,它们就真的会放行调用 —— 没有人要求的放宽 —— 所以记录保持原样。请先用当前的写法重写这个会话的 allow 条目,或者先把这些条目拿掉,再在这里改它的规则。',
+    'rules.sessionPolicy.tighten.inertEntry': '引擎拒绝写入这些会话规则,已保存的记录完全没有改动:其中有一条读作什么都匹配不上 —— 写进去既不会拦也不会放行任何调用(引擎自己的报错文字会点名这一条和原因)。请改正或拿掉那一条,再重新写入这些规则。如果那一条本来就在这个会话的规则记录里,得先把它从记录里移除,记录才能再次写入。',
+    'rules.sessionPolicy.tighten.unknown.faceUnavailable': '这个部署不保存会话级的工具规则,所以什么都没写。',
+    'rules.sessionPolicy.tighten.unknown.sessionNotFound': '从这里读不到这个会话 —— 它可能不存在,也可能属于别人(引擎对两种情形答得一样,所以本端分不出是哪一种);什么都没写。',
+    'rules.sessionPolicy.tighten.unknown.sessionOwnerless': '这个会话没有属主,为它写的规则永远读不回来;什么都没写。请先给会话绑上身份再试。',
+    'rules.sessionPolicy.tighten.unknown.unauthorized': '这次调用拿不出可验证的身份,所以什么都没写。',
+    'rules.sessionPolicy.tighten.unknown.requestRejected': '引擎拒绝了这份规则记录的形状,所以什么都没写。请先修正条目再发。',
+    'rules.sessionPolicy.tighten.unknown.storeCorrupt': '引擎确定不了这个会话的规则处在哪个版本,拒绝盖新的版本号,所以什么都没写。问题不在这里送来的条目 —— 需要运维的人去查看规则店。',
+    'rules.sessionPolicy.tighten.unknown.readUnreadable': '这个会话当前的规则读不出来,所以什么都没写 —— 覆盖一份读不出来的记录,会把真实的限制换成一份空的。',
+    'rules.sessionPolicy.tighten.unknown.readFailed': '这个会话当前的规则没能取回,所以什么都没写。',
+    'rules.sessionPolicy.tighten.unknown.writeRefused': '引擎拒绝了这次写入,所以什么都没写。再试之前请重新读一遍当前的规则。',
+    'rules.sessionPolicy.tighten.unknown.writeIndeterminate': '这次写入一直没有等到引擎的答复 —— 它可能生效了,也可能没有。在写别的之前请重新读一遍当前的规则。',
+    'rules.sessionPolicy.tighten.unknown.writeReceiptUnreadable': '收紧已经送出,但引擎的答复读不出来 —— 它可能已经生效。在写别的之前请重新读一遍当前的规则。',
+    'rules.sessionPolicy.tighten.unknown.writeReceiptMismatch': '收紧已经送出,但引擎的答复对不上它(版本没有前进、这里送来的条目不在返回的记录里,或者返回的记录没带送出时的规则文法标记,所以它的条目现在可能读成别的意思)—— 它可能已经生效。在写别的之前请重新读一遍当前的规则。',
+    'approval.settleHuman.resumed': '{what} —— 引擎已收下这个决断,并恢复了那条 parked 的调用{where}。请在转录里看这条调用接下来做了什么。{tail}',
+    'approval.settleHuman.resumedLate': '{what}(迟了)—— 引擎在 approval window 关闭之后才收下这个决断,并恢复了那条 parked 的调用{where}。请在转录里看这条调用接下来做了什么。{tail}',
+    'approval.settleHuman.expiredReaped': '那个审批超过了它的截止时间,引擎把它收割了 —— 什么都没有运行,你的回答没有被记录。如果仍然需要这一步,请再请求一次。',
+    'approval.settleHuman.settledElsewhere': '引擎已不再为你保留那个审批 —— 你的回答没有被记录。它可能已经在别处被决断了(而且那一步可能已经运行过):再请求之前请先看一下转录。',
+    'rules.origin.user': '你自己添加的',
+    'rules.origin.importedCc': '导入的',
+    'rules.origin.starter': '预设的',
+    'rules.origin.unknownWord': '这个版本不认识的来源',
+    'rules.origin.none': '来源未知',
+    'rules.origin.join': '、',
+    'rules.scope.all': '所有项目',
+    'rules.scope.unknown': '这个版本不认识的作用域',
+    'rules.revoke.thisRule': '这条规则',
+    'rules.revoke.removed.yes.notice': '{rule}:写入了墓碑,但这条规则仍然有效 —— 它在这次调用期间又被批准了一次。',
+    'rules.revoke.removed.yes.change': '已撤销已保存的规则 {rule}(仍然有效 —— 期间又被批准了一次)',
+    'rules.revoke.removed.unknown.notice': '{rule}:写入了墓碑,但无法确认这条规则是否仍然有效 —— 请当它仍然生效,并检查列表。',
+    'rules.revoke.removed.unknown.change': '已撤销已保存的规则 {rule}(无法确认是否仍然有效 —— 按仍然生效处理)',
+    'rules.revoke.removed.no.notice': '已移除 {rule}。',
+    'rules.revoke.removed.no.change': '已撤销已保存的规则 {rule}',
+    'rules.revoke.nothingWritten.yes.notice': '{rule}:什么都没有写入,而且这条规则仍然有效 —— 它没有被移除;请检查列表。',
+    'rules.revoke.nothingWritten.yes.change': '移除已保存的规则 {rule} 什么都没有写入 —— 这条规则仍然有效',
+    'rules.revoke.nothingWritten.unknown.notice': '{rule}:什么都没有写入,而且无法确认这条规则是否仍然有效 —— 请当它仍然生效,并检查列表。',
+    'rules.revoke.nothingWritten.unknown.change': '移除已保存的规则 {rule} 什么都没有写入 —— 无法确认是否仍然有效',
+    'rules.revoke.nothingWritten.no.notice': '{rule}:没有可移除的内容。',
+    'rules.revoke.nothingWritten.no.change': '移除已保存的规则 {rule} 什么都没有写入(没有可移除的内容)',
+    'rules.revoke.absent.notice': '{rule}:引擎没有说明这次移除做了什么,所以不清楚有没有移除任何东西 —— 请检查列表。',
+    'rules.revoke.absent.change': '移除已保存的规则 {rule} 的回应没有说明它做了什么',
+    'rules.revoke.unrecognised.notice': '{rule}:引擎答了一个这个版本不认识的状态,所以不清楚有没有移除任何东西 —— 请检查列表。',
+    'rules.revoke.unrecognised.change': '移除已保存的规则 {rule} 返回了一个这个版本不认识的状态',
+    'rules.revoke.liveness.yes': '它还报告这条规则仍然有效。',
+    'rules.revoke.liveness.unknown': '同样无法确认这条规则是否仍然有效。',
+    'rules.match.exact': '精确匹配',
+    'rules.match.prefix': '前缀匹配',
+    'rules.match.wildcard': '通配匹配',
+    'rules.match.subpath': '子路径匹配',
+    'rules.match.path': '路径匹配',
+    'rules.match.name': '技能名匹配',
+    'rules.match.namePrefix': '技能名前缀匹配',
+    'rules.match.host': '网站域名匹配(单个主机)',
+    'rules.match.subdomain': '网站域名匹配(该域名下的每个主机)',
+    'rules.match.unreported': '没有报告匹配形式',
+    'rules.match.unknown': '这个版本不认识的匹配形式',
+    'model.tier.blurb.ultra': '预留在 max 之上 —— 等更强的模型出现时再绑定',
+    'model.tier.blurb.max': '最难的问题 —— 深度推理、大型重构',
+    'model.tier.blurb.pro': '日常主力 —— 默认档',
+    'model.tier.blurb.flash': '又快又省 —— 标题、回顾、批量活儿',
+    'model.tier.blurb.lite': '最省 —— 批量分类、简单查询',
+    'model.catalog.candidateRejected': '部署拒绝了最近一次配置改动{which},仍在使用它之前的那份配置 —— 那次改动里新增的模型或设置没有生效',
+    'notice.failure.headline.connectionLostNotSent': '连不上引擎 —— 你的消息没有运行。请确认引擎已经启动,然后再发送一次。',
+    'notice.failure.headline.connectionLost': '与引擎的连接断了 —— 不知道你的消息是否已经运行。重新发送之前,请先查看这次 run 的状态,或者重新接上它。',
+    'notice.failure.headline.timeout': '事件流静默了 —— 这次 run 可能仍在引擎上运行。再次发送之前,请先查看它的状态。',
+    'notice.failure.headline.parked': '事件流结束时这次 run 还没到终态 —— 这次 run 很可能是 parked 在等一个决断,而不是崩溃了。请查看它的状态并处理待决的事项;这个 turn 没有在这里完成。',
+    'notice.failure.headline.internal': '这个客户端遇到了内部错误 —— 这是客户端的 bug,不是引擎故障,这个 turn 没有完成。',
+    'notice.failure.quota.fiveHour': '你的 5 小时额度已用完',
+    'notice.failure.quota.weekly': '你的每周额度已用完',
+    'notice.failure.quota.budgetPersonal': '你的个人预算已用完',
+    'notice.failure.quota.budgetPool': '预算池 "{pool}" 的额度已用完',
+    'notice.failure.quota.budget': '你的预算额度已用完',
+    'notice.failure.quota.usage': '你的用量额度已用完',
+    'notice.failure.quota.remainingBudget': '剩余 {amount}',
+    'notice.failure.quota.remainingTokens': '剩余 {count} 个 token',
+    'notice.failure.quota.resetAt': '预计在 {time} 重置',
+    'notice.failure.quota.resetAround': '预计在 {time} 前后重置(估算)',
+    'notice.failure.quota.refresh': '你也可以申请刷新额度',
+    'notice.failure.quota.noBypass': '换模型绕不过这个限额',
+    'notice.failure.quota.join': ';',
+    'notice.failure.quota.instantOtherDay': '{month}{day}日 {time}',
+    'notice.failure.month.jan': '1月',
+    'notice.failure.month.feb': '2月',
+    'notice.failure.month.mar': '3月',
+    'notice.failure.month.apr': '4月',
+    'notice.failure.month.may': '5月',
+    'notice.failure.month.jun': '6月',
+    'notice.failure.month.jul': '7月',
+    'notice.failure.month.aug': '8月',
+    'notice.failure.month.sep': '9月',
+    'notice.failure.month.oct': '10月',
+    'notice.failure.month.nov': '11月',
+    'notice.failure.month.dec': '12月',
+    'notice.failure.settings.lead': '这次提交在运行之前就被拒绝了,所以它带的设置对这条消息没有生效。如果上面那一行点名了设置键:列为 unknown 的是拼写问题 —— 请在设置文件里改正名字后重新发送;列为 unsupported 的是这个服务没有接线的设置 —— 请不要再发送它们(额外目录跟随请求本身,不属于设置)。',
+    'notice.failure.settings.safety': '安全提示:其中包括 {risks} —— 这个 turn 运行(或失败)时没有它们,所以不要当作它们已经生效。',
+    'notice.failure.settings.stillLocal': '这些键在本机上仍然生效 —— 不要为了让报错消失而把它们从设置文件里删掉。',
+    'notice.failure.settings.denyRules.one': '{count} 条 deny 规则',
+    'notice.failure.settings.denyRules.other': '{count} 条 deny 规则',
+    'notice.failure.settings.askRules.one': '{count} 条 ask 规则',
+    'notice.failure.settings.askRules.other': '{count} 条 ask 规则',
+    'notice.failure.settings.riskJoin': '、',
+    'notice.failure.wait.one': '服务器要求在 1 秒后重试(Retry-After)。',
+    'notice.failure.wait.other': '服务器要求在 {seconds} 秒后重试(Retry-After)。',
+};
+export const ZH_MESSAGES = Object.freeze(ZH);
+export const TERM_SLOTS = Object.freeze({
+    'config.mcp.toolAxesInvalid': ['toolAxes'],
+    'config.mcp.cloudToolAxesInvalid': ['toolAxes'],
+    'config.mcp.elicitationInvalid': ['elicitation'],
+    'config.mcp.cloudElicitationInvalid': ['elicitation'],
+    'approval.settle.cause.runCancelled': ['run'],
+    'approval.settle.cause.runExited': ['run'],
+    'approval.settle.cause.ttlExpired': ['approval window'],
+    'approval.settle.follow.following': ['run'],
+    'approval.settle.follow.alreadyFollowing': ['run'],
+    'approval.settle.acceptedNotFollowing': ['parked', 'run'],
+    'approval.settle.parkedNote.approval': ['durable queue', 'parked'],
+    'approval.settle.parkedNote.question': ['durable queue', 'parked'],
+    'approval.settle.parkedNote.queueNoDeadline': ['durable queue'],
+    'resume.reopen.first.envFailed': ['parked'],
+    'session.inheritEnv.withheld.all': ['run'],
+    'session.inheritEnv.withheld.scrub': ['run'],
+    'resume.refusal.placementMismatch': ['parked'],
+    'resume.refusal.policyBlock': ['parked'],
+    'resume.refusal.contextUnavailable': ['run'],
+    'resume.refusal.contextThird.withRun': ['run'],
+    'resume.refusal.contextThird.noRun': ['run'],
+    'resume.refusal.startup.resumeRejected': ['parked'],
+    'resume.refusal.startup.undetermined': ['parked'],
+    'resume.refusal.startup.cause.environment': ['parked'],
+    'resume.refusal.startup.cause.sessionGone': ['parked'],
+    'resume.refusal.startup.cause.toolUnavailable': ['parked'],
+    'resume.refusal.startup.cause.configuration': ['parked'],
+    'resume.refusal.startup.cause.decisionRejected': ['parked'],
+    'resume.refusal.startup.cause.transcriptCorrupt': ['parked'],
+    'resume.refusal.checkpoint.newerEngine': ['parked'],
+    'resume.refusal.checkpoint.content': ['parked'],
+    'resume.refusal.checkpoint.outletWithRun': ['parked', 'run'],
+    'resume.refusal.checkpoint.outletNoRun': ['parked', 'run'],
+    'resume.refusal.checkpoint.outletUnknownKind': ['parked', 'run'],
+    'resume.refusal.park.whyWalltime': ['run'],
+    'resume.refusal.park.whyInheritedGate': ['parked'],
+    'resume.refusal.park.whyConfigRefused': ['parked'],
+    'resume.refusal.park.whyUnsupported': ['parked'],
+    'resume.refusal.park.whatDefault': ['parked'],
+    'resume.refusal.park.printEnded': ['run'],
+    'resume.refusal.park.printHolds': ['parked', 'run'],
+    'resume.refusal.park.interactiveEnded': ['parked', 'run'],
+    'resume.refusal.park.interactiveBusy': ['parked', 'run'],
+    'resume.refusal.park.blockedPrint': ['run'],
+    'resume.refusal.park.blockedInteractive': ['run'],
+    'session.selfHeal.handle.run': ['run'],
+    'session.selfHeal.decidePathClause': ['run'],
+    'session.selfHeal.lastActivity': ['run'],
+    'session.selfHeal.decisionInFlight': ['parked', 'run', 'turn'],
+    'session.selfHeal.parkedOn.ask': ['run'],
+    'session.selfHeal.parkedOn.plan': ['run'],
+    'session.selfHeal.row.decisionPending': ['turn'],
+    'session.selfHeal.row.askReopened.firstSight': ['run', 'turn'],
+    'session.selfHeal.row.askReopened.reseen': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.planReviewReopened.firstSight': ['run', 'turn'],
+    'session.selfHeal.row.planReviewReopened.reseen': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.askDecided.confirmed': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.askDecided.inferred': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.askDecided.releaseUnknown': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.askReopenFailed.withKeep': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.askReopenFailed.noKeep': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.planReopenFailed.dismissed': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.planReopenFailed.withKeep': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.planReopenFailed.noKeep': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.steered.tail.following': ['run'],
+    'session.selfHeal.row.steered.tail.watch': ['run'],
+    'session.selfHeal.row.steered.unknownTail.following': ['run'],
+    'session.selfHeal.row.steered.unknownTail.watch': ['run'],
+    'session.selfHeal.row.steered.applied': ['run', 'turn'],
+    'session.selfHeal.row.steered.next.shown': ['run', 'resume'],
+    'session.selfHeal.row.steered.next.inFlight': ['run'],
+    'session.selfHeal.row.steered.next.dismissed': ['run', 'resume'],
+    'session.selfHeal.row.steered.next.cannotShow': ['run', 'resume'],
+    'session.selfHeal.row.steered.queued': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.steered.parkedForWake': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.steered.reported': ['run'],
+    'session.selfHeal.row.steered.unknown': ['run', 'turn'],
+    'session.selfHeal.row.steerFailed.rejected': ['run'],
+    'session.selfHeal.row.steerFailed.unknown': ['run'],
+    'session.selfHeal.row.attach': ['run'],
+    'session.selfHeal.row.cancelled.confirmed': ['run'],
+    'session.selfHeal.row.cancelled.reported': ['run'],
+    'session.selfHeal.row.cancelTimeout.aborted': ['run'],
+    'session.selfHeal.row.cancelTimeout.unread': ['run'],
+    'session.selfHeal.row.cancelTimeout.held': ['run'],
+    'session.selfHeal.row.cancelFailed.unknown': ['run'],
+    'session.selfHeal.row.cancelFailed.rejected': ['run'],
+    'session.selfHeal.row.askRunNotFound': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.askRunSettled': ['parked', 'run', 'turn'],
+    'session.selfHeal.row.stale.cancelled.confirmed': ['parked', 'run'],
+    'session.selfHeal.row.stale.cancelled.reported': ['parked', 'run', 'resume', 'turn'],
+    'session.selfHeal.row.stale.cancelTimeout.aborted': ['parked', 'run'],
+    'session.selfHeal.row.stale.cancelTimeout.unread': ['parked', 'run'],
+    'session.selfHeal.row.stale.cancelTimeout.held': ['parked', 'run'],
+    'session.selfHeal.row.stale.cancelFailed.unknown': ['parked', 'run'],
+    'session.selfHeal.row.stale.wait.offered': ['parked', 'run'],
+    'session.selfHeal.row.stale.wait.first': ['parked', 'run'],
+    'session.selfHeal.row.runNotFound': ['run'],
+    'session.selfHeal.row.runSettled': ['run'],
+    'session.selfHeal.row.notParked.offered': ['run'],
+    'session.selfHeal.row.notParked.parkedOn': ['run'],
+    'session.selfHeal.row.notParked.inFlight': ['run', 'turn'],
+    'session.selfHeal.row.stateUnknown': ['run', 'turn'],
+    'session.selfHeal.headless.decide': ['parked', 'run'],
+    'session.selfHeal.headless.statusOnly': ['run'],
+    'session.selfHeal.headless.neverReleased': ['run'],
+    'approval.deniedBy.hook': ['hook'],
+    'approval.origin.planReview': ['run'],
+    'approval.origin.hook': ['hook'],
+    'approval.boundGrants.denyPart.one': ['run'],
+    'approval.boundGrants.denyPart.other': ['run'],
+    'session.steerRefusal.notRunning.happened': ['run'],
+    'session.steerRefusal.notRunning.nextStep': ['run'],
+    'session.steerRefusal.queueFull.happened': ['run'],
+    'session.steerRefusal.queueFull.nextStep': ['run'],
+    'session.steerRefusal.steeringOtherUnknown.nextStep': ['run'],
+    'session.steerRefusal.hostQueue.queued': ['turn'],
+    'notice.capability.userInvokedSkills.present': ['run'],
+    'notice.capability.skillToolLists.present': ['run'],
+    'notice.capability.mcpProbe.present': ['run'],
+    'notice.capability.hands.noneStem': ['run'],
+    'notice.capability.hands.seamMounted': ['run'],
+    'notice.capability.hands.rosterMounted': ['run'],
+    'notice.capability.hands.unknownNoManifest': ['run'],
+    'notice.capability.hands.unknownNoRoster': ['run'],
+    'notice.capability.hands.unknownRosterUnreadable': ['run'],
+    'notice.capability.hands.unknownMountConditionAbsent': ['run'],
+    'approval.settleHuman.resumed': ['parked'],
+    'approval.settleHuman.resumedLate': ['approval window', 'parked'],
+    'notice.failure.headline.connectionLost': ['run'],
+    'notice.failure.headline.timeout': ['run'],
+    'notice.failure.headline.parked': ['parked', 'run', 'turn'],
+    'notice.failure.headline.internal': ['turn'],
+    'notice.failure.settings.safety': ['turn'],
+});