@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/i18n/messages.zh.js

@@ -180,14 +180,43 @@ const ZH = {
     '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.nameBlank': 'MCP 服务器条目{where}的名字不可用({name}),没有启动。请给它起个名字,或删掉这一条。',
+    'config.mcp.nameEdgeWhitespace': 'MCP 服务器名 {name}{where} 不能照原样使用,所以没有启动:它与其他设置里的同名对不上(例如禁用服务器列表)。请去掉名字里多余的空白。',
+    'config.mcp.nameCollides': 'MCP 服务器名 {name}{where} 不能照原样使用,所以没有启动:去掉首尾空白后会与另一条 MCP 服务器重名。请去掉名字里多余的空白,或删掉重复的一条。',
+    'config.mcp.nameTooLong': 'MCP 服务器名 {name}{where} 不可用,所以没有启动:服务器名最长 128 个字符。请缩短名字。',
+    'config.mcp.identityHeadersBothSet': 'MCP 服务器 {name}{where} 没有启动:它同时设置了 principalHeader 和 assertionHeader,而这两项指的是同一个身份头 —— 只保留其中一项。其他 MCP 服务器不受影响。',
+    'config.mcp.transportUnreadable': '读不出(声明上的取值器或代理陷阱抛了错)',
+    'config.mcp.transportInvalid': 'MCP 服务器 {name}{where} 没有启动:它的传输设置不可用 —— {path} {problem}。请修正这台服务器的这项设置(或删掉这台服务器);其他 MCP 服务器不受影响。',
+    'config.mcp.transportDegraded': 'MCP 服务器 {name}{where} 已启动,但它的部分传输设置不能照原样使用、被略去了:{lost}。其余设置照常生效;请修正上面点名的设置,让它们也生效。',
     'config.mcp.toolAxesInvalid': 'MCP 服务器 {name}{where} 没有启动:它的 toolAxes 设置不合法 —— {problem}。请修正这台服务器的 toolAxes(或删掉它);其他 MCP 服务器不受影响。',
     'config.mcp.toolAxesFallbackProblem': '这份声明不是一组合法的按工具安全设置',
+    'config.mcp.toolFacesInvalid': 'MCP 服务器 {name}{where} 没有启动:它的 toolFaces 设置不合法 —— {problem}。请修正这台服务器的 toolFaces(或删掉它);其他 MCP 服务器不受影响。',
+    'config.mcp.toolFacesFallbackProblem': '这份声明不是一组合法的按工具展示与审批设置',
+    'config.mcp.toolFacesUnreadable': '这项设置读不出来(它上面的取值器或代理陷阱抛了错)',
     'config.mcp.elicitationInvalid': 'MCP 服务器 {name}{where} 没有启动:它的 elicitation 设置必须是 true 或 false。请修正这台服务器的 elicitation(或删掉它);其他 MCP 服务器不受影响。',
+    'config.mcp.entryNotObject': 'MCP 服务器 {name}{where} 没有启动:它在配置里的条目不是一个对象。MCP 服务器条目必须是带 command(本地服务器)或 url(远程服务器)的对象。请修正或删掉这一条;其他 MCP 服务器不受影响。',
+    'config.mcp.entryUnreadable': 'MCP 服务器 {name}{where} 没有启动:它在配置里的条目读不出来(条目上的取值器或代理陷阱抛了错)。请修正或删掉这一条;其他 MCP 服务器不受影响。',
+    'config.mcp.entryNotObjectProblem': '这一条不是对象(应是带 command 或 url 的对象)',
+    'config.mcp.transportTypeUnsupported': '这种传输类别请求面承载不了(只支持 stdio 与 http)',
+    'config.mcp.transportIdentityBothSetProblem': '同时设置了 principalHeader 与 assertionHeader,而这两项指的是同一个身份头 —— 只保留其中一项',
     'config.mcp.cloudElicitationInvalid': '云配置:这些 MCP 服务器条目被略过,因为它们的 elicitation 设置不是 true 或 false —— 请修正或删掉 elicitation 条目:{who}',
+    'config.mcp.allowToolsInvalid': 'MCP 服务器 {name}{where} 没有启动:它的 allowTools 设置不能使用 —— {problem}。请修正这台服务器的 allowTools 条目(工具名字符串的列表);其他 MCP 服务器不受影响。',
+    'config.mcp.allowToolsNotArray': '{path} 必须是字符串数组(实际是 {got})',
+    'config.mcp.allowToolsElementNotString': '{path} 必须是字符串(实际是 {got})',
+    'config.mcp.allowToolsHole': '{path} 缺失:列表中不允许有空缺,每个位置都必须是字符串',
+    'config.mcp.allowToolsUnreadable': '{path} 读不出来(它上面的取值器或代理陷阱抛了错)',
+    'config.mcp.allowToolsTooMany': '{path} 的条目太多,无法逐项检查(超过 {got} 项)',
+    'config.mcp.cloudAllowToolsInvalid': '云配置:这些 MCP 服务器条目被略过,因为它们的 allowTools 设置不是工具名字符串的列表 —— 请修正 allowTools 条目:{who}',
+    'config.mcp.cloudEntryUnreadable': '云配置:这些 MCP 服务器条目被略过,因为条目读不出来(条目上的取值器或代理陷阱抛了错)—— 请修正或删掉这一条:{who}',
     'config.mcp.cloudToolAxesInvalid': '云配置:这些 MCP 服务器条目被略过,因为它们的 toolAxes 设置不合法(按工具的安全覆盖只认 effect、egress、irreversibility 三项,各带合法取值)—— 请修正或删掉 toolAxes 条目:{who}',
+    'config.mcp.cloudToolFacesInvalid': '云配置:这些 MCP 服务器条目被略过,因为它们的 toolFaces 设置不合法(按工具的展示与审批设置)—— 请修正或删掉 toolFaces 条目:{who}',
+    'config.mcp.cloudNameUnusable': '云配置:这些 MCP 服务器条目被略过,因为它们的名字不能照原样使用(名字超过 128 个字符,或带首尾空白)—— 请修正名字:{who}',
+    'config.mcp.cloudTransportInvalid': '云配置:这些 MCP 服务器条目被略过,因为它们的传输设置引擎不能照原样使用(例如地址不是 http(s) URL)—— 请修正传输设置:{who}',
+    'config.mcp.cloudTransportDegraded': '云配置:这些 MCP 服务器条目已启动,但它们的部分传输设置不能照原样使用(点名的设置被略去,其余照常生效)—— 请修正点名的设置:{who}',
+    'config.mcp.cloudTransportDegradedUnreadable': '云配置:「已启动但部分设置被略去」的 MCP 服务器条目清单本客户端读不出来 —— 有的服务器可能在缺少部分已配置设置的情况下运行,且没有任何提示',
+    'config.skills.cloudToolListInvalid': '云配置:这些技能被略过,因为它们的 allowedTools 或 disallowedTools 不是字符串列表(技能的工具清单要么照原样发送、要么不发送,不做裁剪)—— 请修正或删掉该清单:{who}',
+    'config.skills.cloudDroppedUnreadable': '云配置:「因工具清单不可用而被略过的技能」清单本客户端读不出来 —— 可能有技能缺席且没有任何提示',
+    'config.skills.toolListTooMany': '的条目太多,无法逐项检查(超过 {got} 项)—— 这张清单整张拒收,不会只读一部分或被截短',
     'approval.boundGrants.notActivated.one': '批准这一张不会激活卡上的技能:它的拒绝清单里有 1 条读作无物,而引擎不丢弃读不出的拒绝 —— 技能的说明不加载,清单里的一条都不授予。',
     'approval.boundGrants.notActivated.other': '批准这一张不会激活卡上的技能:它的拒绝清单里有 {count} 条读作无物,而引擎不丢弃读不出的拒绝 —— 技能的说明不加载,清单里的一条都不授予。',
     'approval.boundGrants.listsNoToolsWithNothing.one': '批准这一张会激活卡上的技能;它没有列出免问运行的工具,也没有列出要拒的工具。清单里有 1 条读作无物,什么都不授予。',
@@ -208,6 +237,13 @@ const ZH = {
     'approval.settle.cause.broadcastLost': '它没有送达任何一个打开着的连接',
     'approval.settle.cause.streamDisconnected': '承载这张卡的连接断了',
     'approval.settle.cause.undeliverable': '它没能送达任何审批界面',
+    'approval.decision.grantChanged': '引擎拒收了这次批准:它绑定的技能授予在卡呈出之后已经变了 · 什么都没有决定,这一请求仍在等待,但再批一次会以同样的理由被拒 · 请拒绝这一请求,让模型重新激活那个技能',
+    'approval.decision.settledElsewhereContrary.deniedFirst': '这一请求已在别处被答复为拒绝,你的批准没有生效。',
+    'approval.decision.settledElsewhereContrary.approvedFirst': '这一请求已在别处被答复为批准,你的拒绝没有生效。',
+    'approval.decision.unconfirmedAfterRetry': '不知道你的答复有没有生效:之前那一发没有得到确认,重发时这一请求已不在等待 · 动手之前先看任务当前的状态',
+    'notice.decide.rowUnrevivable': '引擎已经无法恢复这张审批卡,批准和拒绝都不会生效 · 这张卡只能在服务端清理 —— 请等待清理完成,或联系运维这台引擎的人',
+    'approval.askPark.autoReopenBlocked.policyInteractive': '引擎的准入策略拒绝续跑这一停驻步骤(run {run}),所以 sema 不会自己把它的卡放回屏幕。请换成这台部署允许的权限模式,或联系部署的运维方,然后发一条消息把卡带回来。',
+    'approval.askPark.autoReopenBlocked.policyPrint': '引擎的准入策略拒绝续跑这一停驻步骤(run {run}),所以 sema 不会自己把它的卡放回屏幕。请换成这台部署允许的权限模式,或联系部署的运维方,然后发一条消息把卡带回来;或者停掉这条 run({cancel})。',
     'approval.settle.subject.named': '{tool} 的审批请求',
     'approval.settle.subject.generic': '这个审批请求',
     'approval.settle.endedKnown': '{subject}在引擎上结束了,没有得到回答:{clause}。这张卡上没有批准任何东西;如果仍然需要这一步,请再请求一次。',
@@ -261,10 +297,17 @@ const ZH = {
     'resume.reopen.first.toolContractMismatch': '这个审批所授予的工具,自审批记录以来已经变了',
     'resume.reopen.content': '{first} · 引擎在消耗任何东西之前,就把这件工作重新 parked 了 —— 审批仍待决,你的决断没有被消耗 · 请重新获取待决审批,并在同一个工具可用的引擎上再决断一次',
     'session.inheritEnv.notConfirmed': '引擎没有确认它不会把自己的凭据交给工具 shell,所以工具 shell 拿到的是过滤后的环境(GH_TOKEN 这类看着像凭据的变量会被去掉),直到引擎升级。',
+    'session.inheritEnv.valuesNotConfirmed': '引擎会把自己的凭据变量挡在工具 shell 之外,但没有确认它也会挡住这些凭据以别的名字出现的副本(比如你同时导出为 OPENAI_API_KEY 的模型密钥),所以工具 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.inheritEnv.refusalNamed': '引擎拒掉了「让 shell 继承本机整份环境」这项设置,它只有在工具直接跑在它自己那台机器上、且请求属于某个会话时才接受这一项 · 请去掉这项设置(或改用缺省)再发一次',
+    'session.projectMemory.withheld.absent': '这次请求没有带上它:这台引擎没有声明支持「别读项目指令文件」这项设置,而不认识它的引擎会拒掉整个请求,所以先扣下了;项目指令文件仍会发给模型。',
+    'session.projectMemory.withheld.declined': '这次请求没有带上它:这台引擎声明了不支持「别读项目指令文件」这项设置,所以先扣下了;项目指令文件仍会发给模型。',
+    'session.projectMemory.withheld.unreadable': '这次请求没有带上它:引擎的能力声明没读到,所以不知道它是否支持「别读项目指令文件」这项设置,而不认识它的引擎会拒掉整个请求,所以先扣下了;项目指令文件仍会发给模型。',
+    'session.projectMemory.withheld.unknown': '这次请求没有带上它:「别读项目指令文件」这项设置因为一个这个版本不认识的原因被扣下了。',
+    'session.policy.withheld.namespaceCoveringUnconfirmed': '没有写进这条会话的规则记录:这条规则点的是整个服务器或对端,或按模式点了它的一组工具,而引擎还没有确认这份记录会把这样的规则读成一组 —— 按精确工具名比对记录的引擎会一只都拦不住。',
     'session.fileHistoryLeg.notHonored': '引擎仍在为这个会话捕获文件历史,尽管你的设置要求它别这么做。',
     'resume.refusal.placementMismatch': '这次续跑指定的放置根,和这件工作 parked 时记下的不是同一个 · 引擎在消耗任何东西之前就拒了它 —— parked 的工作原封未动 · 请用记下的那个根重试,或者省略放置根让它沿用记下的',
     'resume.refusal.preflightWaitable': '部署的续跑预检拒绝了这次尝试 · 拒绝发生在提交之前 —— 你的决断没有被消耗 · 引擎给了等待窗,所以障碍清除之后这个令牌仍可再赎',
@@ -298,12 +341,15 @@ const ZH = {
     'resume.refusal.park.whyWalltime': '它的 run 带着一个墙钟时间额度,而这一版引擎不再强制执行这个额度',
     'resume.refusal.park.whyInheritedGate': '它 parked 时带的权限模式设置已经读不出来了',
     'resume.refusal.park.whyConfigRefused': '引擎拒绝它 parked 时带的任务配置',
+    'resume.refusal.park.whyDeps': '引擎拒绝续跑时要用的部署自身配置(或作为继承约束传下来的策略)—— 这是部署的问题,不是你的决定',
     '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.depsMayReturn': '这张卡仍然挂着:运维这台引擎的人修好部署之后,同一张卡可以再决一次。',
+    'resume.refusal.park.blockedByTail': '准入码:{blockedBy}。',
+    'resume.refusal.park.printEnded': '{head}引擎已结束那条 run({code});请把这项工作作为新任务重新提交。{blocked}',
+    'resume.refusal.park.printHolds': '{head}{configMayReturn}parked 的那条 run 仍占着这个会话({code}):请取消它({cancel}),再把这项工作作为新任务重新提交。{blocked}',
     'resume.refusal.park.interactiveEnded': '{head}引擎已结束那条 parked 的 run,所以这段对话空出来了:请把这项工作作为新消息重新发一次。',
     'resume.refusal.park.interactiveBusy': '{head}{configMayReturn}parked 的那条 run 会一直占着这段对话,直到它被取消。',
     'resume.refusal.park.blockedPrint': 'sema 不会自己把 run {run} 的卡放回屏幕:这一版引擎拒绝续跑它。请取消这条 run({cancel}),再把这项工作作为新任务重新提交。',
@@ -343,6 +389,7 @@ const ZH = {
     'session.selfHeal.injected.resendingInferred': '{lead}之前被拦住了,因为这个会话当时被较早的一轮回复{id}占着;现在那一轮回复报告已结束,所以 sema 正在发送这条消息 —— 你不用做什么(如果会话还没完全空出来,它可能会再被拦一次)。',
     'session.selfHeal.injected.handedOffFollowing': '{lead}已交给正在进行的那一轮回复{id},没有另开一轮。sema 正在跟着那一轮回复,它接下来要什么都会显示出来;你现在不用做什么。',
     'session.selfHeal.injected.handedOffWatch': '{lead}已交给正在进行的那一轮回复{id},没有另开一轮 —— 请留意那一轮回复怎么处理它。',
+    'session.selfHeal.injected.interruptedFinishing': '{lead}没有送达:被叫停的较早那一轮回复{id}仍在收尾,sema 没有发送它也没有重试,所以模型没有看到它。稍等片刻后再试一次。',
     'session.selfHeal.injected.notDelivered': '{lead}没有送达:这个会话还被较早的一轮回复占着{id},而且没有可以回答来放行的打开的卡{noView}。sema 没有重试,所以模型没有看到它。',
     'session.selfHeal.decisionInFlight': '上一个 turn 处于 parked 状态,{parkedOn},而你对那张卡的回答还在送往引擎的路上,所以 sema 没有再次显示那张卡 —— 再回答一次会发出第二个决断。它没有取消这次 run。你的消息没有发出;请稍等片刻,等引擎应用了那个决断之后再发一次。',
     'session.selfHeal.parkedOn.ask': '在等你的决断(run {taskId})',
@@ -360,7 +407,7 @@ const ZH = {
     '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.textOnly': '只有你消息的文字交了出去 —— 如果那次提交里还有图片或附件,它们都没有送出。',
     'session.selfHeal.row.steered.tail.following': 'sema 正在跟着那次 run,它接下来要什么都会显示出来。',
     'session.selfHeal.row.steered.tail.watch': '请留意那次 run 怎么处理它。',
     'session.selfHeal.row.steered.unknownTail.following': 'sema 正在跟着那次 run,它接下来要什么都会先显示出来,你再决定要不要重发。',
@@ -373,10 +420,11 @@ const ZH = {
     '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.parkedForWake': 'run {taskId} 已经结束了,所以引擎把你的消息 parked 在了那次已结束的 run 上,没有运行它 —— parked 的消息只有在这个会话于引擎上被唤醒{wakeOn}时才会送达,而 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.runEnded': 'sema 想把你的消息交给 run {taskId} 时,它已经结束了(状态 {status}),所以引擎拒绝了。sema 没有重试,也没有取消任何东西。那次 run 已不再占着这个会话:请再发一次你的消息,把它作为新的 turn 运行。',
     '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 现在就发送你的消息。',
@@ -394,18 +442,23 @@ const ZH = {
     '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.stale.wait.offered': 'run {taskId} 仍 parked(状态 {status})在一个已经不在引擎上的审批上。sema 已经问过该拿它怎么办,你选了不动它,所以不再问了。你的消息没有发出;请{endRun}(这会彻底结束它),或者{wayOut}。',
+    'session.selfHeal.row.stale.wait.first': 'run {taskId} 仍 parked(状态 {status})在一个已经不在引擎上的审批上,所以没有卡可回答了,那次 run 也不会自己落定。sema 没有取消它 —— 是你选了不动它。你的消息没有发出;请{endRun}(这会彻底结束它),或者{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.offered': 'run {taskId} 仍占着这个会话(状态 {status})。sema 已经问过该拿它怎么办,你选了不动它,所以不再问了。你的消息没有发出;请等那次 run 结束,或{endRun},或者{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}',
+    'session.selfHeal.endRun.engine': '在引擎上取消那次 run({cancelPath})',
+    'session.selfHeal.endRun.engineInteractive': '在引擎上结束 run {taskId}',
+    'session.selfHeal.endRun.engineInteractive.noId': '在引擎上结束那条 run',
+    'session.selfHeal.wakeOn.engine': '(POST /v1/sessions/:id/wake)',
+    'session.selfHeal.wakeOn.host': '({where})',
+    'session.selfHeal.headless.decide': '这个会话被较早的一次 run{handle}占着{status},它 parked 在等{gate},所以这条消息没有发出。决定它,会话就解锁:POST {decidePath}。改为结束那次 run 也能解锁,但那等于替你否决了那一项:{endRun}。或者{freshSession}。{governance}',
+    'session.selfHeal.headless.statusOnly': '这个会话被较早的一次 run{handle}占着,状态是 {status},所以这条消息没有发出。引擎报告那次 run 上没有待决的决断:如果它还在干活,请等它结束;如果它永远落定不了,请{endRun} —— 那会丢掉它正在做的事。或者{freshSession}。',
+    'session.selfHeal.headless.neverReleased': '这个会话上仍有一次 run 在活动{handle},而且从未被释放,所以 sema 没有发送这条消息。这里没有任何东西会自己清掉。{startOver},或者{endRun}。',
     'approval.deniedBy.policy': '被这个部署的权限策略拒绝',
     'approval.deniedBy.hook': '被 PreToolUse hook 拒绝',
     'approval.deniedBy.org': '被一条组织规则拒绝',
@@ -449,6 +502,8 @@ const ZH = {
     'approval.mandate.word.probeUnanswered': '对这次调用运行的检查没有给出答复(超时或失败了;这个客户端分不出是哪种),所以这次调用是否留在本会话允许的目录之内,不得而知',
     'approval.mandate.word.writeProtection': '这次改动落在受保护的位置(代理自己的配置)上,这类改动要逐次确认',
     'approval.mandate.word.targetUnresolved': '这次改动落在磁盘上哪里,没能确定(路径上的一个链接没能检查,或目标没能解析),所以它是否落在受守护的位置上,不得而知',
+    'approval.mandate.word.crossBoundaryTaint': '这次运行在部署信任边界之外的设备上执行,而且这个部署服务多个租户,所以对组织一侧的写入(或在从别处读取之后、指向该设备的调用)要由部署的审批人对这一次调用单独确认',
+    'approval.mandate.wayOut.crossBoundaryTaint': '来自配置的放行(放行一切的设置,或策略自己的回答)对这次调用会被拒绝,所以由你在这里批准或拒绝来决定它',
     'approval.mandate.unknownWord': '这次确认所报告的原因,这个客户端不认识,所以不显示原因',
     'approval.card.payloadUnreadable': '这个客户端读不懂这张审批卡的格式,所以只显示它的基本事实 —— 请据此决定,不确定它会做什么的话就拒绝它。',
     'approval.card.more.one': '这张卡还有 1 条原因没有显示。',
@@ -491,6 +546,23 @@ const ZH = {
     'session.fileHistoryRefusal.notSaid': '没有发送:你的设置里已关闭文件检查点,但这台引擎没有报告它能否按会话停止记录文件历史,所以现在发送仍可能把它记录下来。只要这台引擎还是同样的报告,重试也不会改变这一点;要发送并让这一次的文件历史被记录,请在设置里把文件检查点重新打开。',
     'session.fileHistoryRefusal.unrecognized': '没有发送:你的设置里已关闭文件检查点,但这台引擎报告了一个本客户端不认识的文件历史捕获模式,所以不知道它能否按会话停止记录文件历史,现在发送仍可能把它记录下来。只要这台引擎还是同样的报告,重试也不会改变这一点;要发送并让这一次的文件历史被记录,请在设置里把文件检查点重新打开。',
     'session.fileHistoryRefusal.unreadable': '没有发送:你的设置里已关闭文件检查点,但这台引擎关于能否按会话停止记录文件历史的报告,本客户端读不出来,所以现在发送仍可能把它记录下来。只要这台引擎还是同样的报告,重试也不会改变这一点;要发送并让这一次的文件历史被记录,请在设置里把文件检查点重新打开。',
+    'session.hostSettings.memorySwitchMalformed': '设置文件里的记忆设置读不出,所以「关闭记忆」没有生效:这一次请求照常带着记忆发出。改好记忆那一段(memory.enabled 只能是 true 或 false)即可关闭。',
+    'session.hostSettings.fileHistoryRestoreConflict': '没有发送:这次请求准备好之后,你在设置里关闭了文件检查点,但这次请求同时要从检查点还原文件,两者不能放在同一个请求里。要还原文件,请在设置里把文件检查点重新打开;否则请去掉文件还原再发送。',
+    'session.hostSettings.projectionUnchecked': '这一次请求要带的设置在发出前没法核对,所以没有发送。请重新载入设置后再试。',
+    'session.hostSettings.projectionUncheckedPortsMissing': '这一次请求要带的设置在发出前没法核对,所以没有发送:这个应用没有装上核对权限规则要用的检查件({ports})。重新载入设置解决不了,需要应用把它们装上。',
+    'session.hostSettings.projectionUncheckedJudgeFailed': '这一次请求要带的设置在发出前没法核对,所以没有发送:这个应用装上的权限规则检查件在核对时出了故障。重新载入设置解决不了,需要应用修好这个检查件。',
+    'session.hostSettings.managedUnreadable': '没有发送:管理员下发的托管设置此刻读不出,它设的限制没法生效。托管设置恢复可读后,请求会照常发送。',
+    'session.hostSettings.layerNotLoaded.hold.unreadable': '{layer}读不出,那份文件里的规则和 hooks 不会作用于这一次请求。可以不带这些设置继续,或者先取消、改好文件。',
+    'session.hostSettings.layerNotLoaded.hold.rejected': '{layer}没有装上:那份文件里一个守着工具调用的 hook 写坏了,文件里的规则和 hooks 不会作用于这一次请求。可以不带这些设置继续,或者先取消、改好文件。',
+    'session.hostSettings.layerNotLoaded.sent.unreadable': '{layer}读不出:这一次请求没有带那份文件里的规则和 hooks。',
+    'session.hostSettings.layer.policySettings': '托管设置',
+    'session.hostSettings.layer.userSettings': '你的用户设置',
+    'session.hostSettings.layer.projectSettings': '项目设置',
+    'session.hostSettings.layer.localSettings': '本地项目设置',
+    'session.hostSettings.layer.flagSettings': '启动时传入的设置',
+    'session.hostSettings.heldPrevious': '刚才有一份设置文件没能完整读出(可能正在保存),所以仍按上一次完整读到的权限规则执行。',
+    'session.hostSettings.styleMissing': '设置里选中的输出风格「{name}」找不到或读不出,这一次请求不套用它。',
+    'session.hostSettings.styleSafeMode': '安全模式已开启,设置里的输出风格不套用。',
     'model.identity.lane.processEnv': '本客户端启动时的环境',
     'model.identity.lane.settingsEnv': '本客户端的设置文件',
     'model.identity.lane.modelCatalogFile': '本地模型目录文件',
@@ -499,6 +571,46 @@ const ZH = {
     '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}',
+    'model.identity.catalogAdoption.refused': '{lane}里列了模型,但据报引擎会把这份目录按现状整个拒掉,所以其中任何一个都当不了缺省模型',
+    'model.identity.catalogAdoption.notResolvable': '本机引擎没有配置可用来启动的模型名 —— {clause},而且引擎没有模型名就不会启动',
+    'model.identity.catalogAdoption.notResolvableWithPartial': '本机引擎没有配置可用来启动的模型名 —— {clause};另外{partial},而且引擎没有模型名就不会启动',
+    'notice.injectionLane.sentence': '在这台引擎的 {lane} 车道上,工具跑在与引擎不同的机器上,所以随任务发送的{items}也在那里运行、而不是在本机 —— 依赖本机程序或凭据的会在那里失败',
+    'notice.injectionLane.item.stdioMcp': '本机 stdio MCP 服务器',
+    'notice.injectionLane.item.credentialedMcp': '使用本机凭据的 MCP 服务器',
+    'notice.injectionLane.item.taskHooks': '钩子',
+    'notice.injectionLane.itemSeparator': '、',
+    'notice.wayOut.checkCredentials': '模型服务拒绝了这次运行所用的凭据 —— 请检查凭据后重试',
+    'notice.wayOut.checkCredentialsFrom': '模型服务拒绝了这次运行所用的凭据(来源:{source})—— 请检查凭据后重试',
+    'notice.wayOut.switchModel': '模型服务此刻无法处理这个请求 —— 请换一个模型试试',
+    'notice.wayOut.wait': '模型服务仍在处理这个请求 —— 请稍等片刻后重试',
+    'notice.wayOut.fixRequest': '模型服务拒绝了这个请求 —— 请修改请求后再发送;原样重发不会有变化',
+    'rules.refusal.sentence.one': '权限:有 1 条规则不会被执行 —— {list}',
+    'rules.refusal.sentence.other': '权限:有 {count} 条规则不会被执行 —— {list}',
+    'rules.refusal.item': '{rule}({reason})',
+    'rules.refusal.itemSeparator': ';',
+    'rules.refusal.list.more': '{shown},另有 {count} 条',
+    'rules.refusal.reason.toolName': '它的工具名不是这台引擎认得的名字',
+    'rules.refusal.reason.homePath': '它用了引擎无法锚定的 ~/ 路径 —— 请改写成相对项目的路径或绝对路径',
+    'rules.refusal.reason.neverMatches': '这种写法作为这只工具的拒绝或询问规则永远匹配不上,引擎不会执行它 —— 要整只拦下这只工具,请只写工具名',
+    'rules.nearMiss.sentence.one': '权限:有 1 条规则写的工具名拼法,本次运行里没有任何工具认,所以永远匹配不上 —— {list}',
+    'rules.nearMiss.sentence.other': '权限:有 {count} 条规则写的工具名拼法,本次运行里没有任何工具认,所以永远匹配不上 —— {list}',
+    'rules.nearMiss.reason': '请把名字写成「{mounted}」',
+    'config.agentsWire.refusedServer.sentence': 'agents wire:{who}:它的 tools 条目 {entry} 点名了 MCP 服务器 {server} 的工具,而该服务器{cause} —— 条目原样发出;只要那台服务器不在这一跑里,这一条就什么都给不了代理。{way}',
+    'config.agentsWire.refusedServer.cause.rejected': '已在本项目被拒用,所以不在这一跑里',
+    'config.agentsWire.refusedServer.cause.notApproved': '尚未在本项目获批,所以不在这一跑里',
+    'config.agentsWire.refusedServer.cause.disabled': '在 MCP 设置里被关掉了,所以不在这一跑里',
+    'config.agentsWire.refusedServer.cause.policyBlocked': '被托管策略名单拦下了,所以不在这一跑里',
+    'config.agentsWire.refusedServer.cause.pluginOnly': '被托管策略限定只许插件提供 MCP 服务器,所以不在这一跑里',
+    'config.agentsWire.refusedServer.cause.malformedConfig': '的配置引擎会拒收,所以不在这一跑里',
+    'config.agentsWire.refusedServer.cause.unknown': '不在这一跑里',
+    'config.agentsWire.refusedServer.way.rejected': '要让代理拿到这些工具,请在本项目重新批准该服务器;否则请从代理定义里删掉这一条。',
+    'config.agentsWire.refusedServer.way.notApproved': '要让代理拿到这些工具,请在本项目批准该服务器;否则请从代理定义里删掉这一条。',
+    'config.agentsWire.refusedServer.way.disabled': '要让代理拿到这些工具,请把该服务器重新打开;否则请从代理定义里删掉这一条。',
+    'config.agentsWire.refusedServer.way.policyBlocked': '请让管理策略名单的人放行该服务器;否则请从代理定义里删掉这一条。',
+    'config.agentsWire.refusedServer.way.pluginOnly': '请让管理策略的人放行该服务器,或改由插件提供;否则请从代理定义里删掉这一条。',
+    'config.agentsWire.refusedServer.way.malformedConfig': '请修正该服务器的配置;否则请从代理定义里删掉这一条。',
+    'config.agentsWire.toolEntry.sentence': 'agents wire:{who}:它的 tools 条目 {phrase} —— 条目原样发出;这一条由引擎按它自己的工具名册来判:会拒这类条目的引擎整跑不起(码 config.agent.unknown_tool),会收的引擎不给代理这一条对应的工具,除非这一跑恰有同名工具。请在代理定义里改掉这一条。',
+    'config.agentsWire.refusedServer.way.unknown': '请查一下该服务器为什么没上这一跑;否则请从代理定义里删掉这一条。',
     'config.hooks.valueShape.nothing': '没有值',
     'config.hooks.valueShape.null': '空值 null',
     'config.hooks.valueShape.array': '一个数组',
@@ -512,6 +624,13 @@ const ZH = {
     '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.hooks.salvage.managedPartial': '{layer}:{what}。这些是托管 hooks,在管理员修好托管设置之前,这一回合的请求不会发出。',
+    'config.hooks.httpPolicy.urlNotListed': 'HTTP hook 被拦下:{url} 不匹配 allowedHttpHookUrls({layer})里的任何模式(模式里的 * 只在 URL 的一个组成部分内匹配)—— 这个 {event} hook 不会运行。',
+    'config.hooks.httpPolicy.urlListEmpty': 'HTTP hook 被拦下:allowedHttpHookUrls({layer})是空的,所以任何 HTTP hook 都不运行 —— {url} 的 {event} hook 不会运行。',
+    'config.hooks.httpPolicy.urlListMalformed': 'HTTP hook 被拦下:allowedHttpHookUrls({layer})不是字符串列表,按空列表读,所以任何 HTTP hook 都不运行 —— {url} 的 {event} hook 不会运行。',
+    'config.hooks.httpPolicy.envListMalformed': 'HTTP hook {url}({event})在没有环境变量的情况下运行:httpHookAllowedEnvVars({layer})不是字符串列表,按空列表读。',
+    'config.hooks.httpPolicy.layerUnreadable': 'HTTP hook 被拦下:读不出 {layer} 的设置,无法核对它的 allowedHttpHookUrls,所以任何 HTTP hook 都不运行 —— {url} 的 {event} hook 不会运行。',
+    'config.hooks.layerWithheld.trust': '{layer}:其中的 hooks 不会运行 —— 这个客户端没有工作区信任步骤,而仓库可控的设置里的 hooks 只有在工作区被信任之后才允许。用户设置、flag 设置和托管设置里的 hooks 不受影响。',
     'config.taskRequest.memoryOff.settingsSectionNotObject': 'memoryOffDeclared: settings 的 memory 段必须是对象 —— 收到 {shape}。',
     'config.taskRequest.memoryOff.enabledNotBoolean': 'memoryOffDeclared: settings memory.enabled 在场时必须是布尔 —— 收到 {shape}。',
     'config.taskRequest.inputKeysUnreadable': 'buildTaskRequest: 入参的键集 / 属性描述符读不出(代理 trap 抛)—— 无法安全快照声明,拒绝装配。错误文本只报形状,不回显值。',
@@ -523,6 +642,7 @@ const ZH = {
     '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.taskRequest.submissionIdentityMalformed': 'buildTaskRequest: 车道实参只接受车道词({lanes})或提交身份 {surface, origin, tools} —— 三位都须是自有数据位、取值在各自的闭集里(surface:{surfaces};origin:{origins};tools:{tools})—— 收到 {shape}。坏形的身份推不出车道也推不出出身,猜一个(回落到交互车道,或回落成「用户所写」)就是替提交方发一份它没描述过的请求,所以在读入参之前就拒。错误文本只报形状,不回显值。',
     'config.assembly.thrownDuringAssembly': '{who}: 装配时出错,拒绝装配(原抛出物见 cause)。',
     'session.steerRefusal.notRunning.happened': '那个 run 现在不接收消息 —— 它刚刚结束,或正在另一台服务器上运行,或不是它所在会话的活动 run',
     'session.steerRefusal.notRunning.nextStep': '先看一下它当前的状态,再把消息发给处于活动状态的 run',
@@ -590,6 +710,17 @@ const ZH = {
     'notice.capability.hands.unknownRosterUnreadable': '这次 run 有没有文件与 shell 工具,目前不知道 —— 工具名册不是这个读口认识的形状,读不出来',
     'notice.capability.hands.unknownMountConditionAbsent': '这次 run 有没有文件与 shell 工具,目前不知道 —— 这台引擎不报每个工具是由哪个条件挂载的,所以这里数出一个空的计数,说的是读口的事,不是这次 run 的事',
     'rules.sessionPolicy.tighten.written': '会话规则已保存(版本 {rev})—— 记录现在包含它原有的全部内容加上这里送来的条目,并从这个会话的下一道工具门起生效;已经在跑的那一步不会被打断。',
+    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.counts': '仍在运行,而且可能是在这个会话的第一条规则之前启动的:{list}。凡是在那第一条规则之前启动的,都会不带这条规则继续运行 —— 要让它立即生效,请停掉它们。',
+    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.unreadable': '本客户端读不出现在有哪些后台子代或工作流在运行。凡是在这个会话的第一条规则之前启动的,都会不带这条规则继续运行 —— 不该继续运行的请停掉。',
+    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.unseen': '起跑还没报到本客户端的工作,可能也读不到这条规则。',
+    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.agents.one': '{n} 个后台子代',
+    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.agents.many': '{n} 个后台子代',
+    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.workflows.one': '{n} 个工作流',
+    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.workflows.many': '{n} 个工作流',
+    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.untracked.one': '{n} 个本客户端已不再跟踪的后台项',
+    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.untracked.many': '{n} 个本客户端已不再跟踪的后台项',
+    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.list.two': '{a}和 {b}',
+    'rules.sessionPolicy.tighten.writtenBeforeFirstRule.list.three': '{a}、{b}和 {c}',
     'rules.sessionPolicy.tighten.conflict': '写入这次收紧的过程中,会话规则被别人改了,连续两次 —— 什么都没写。请重新读一遍当前的规则再试,或者先让另一个写入方写完。',
     'rules.sessionPolicy.tighten.loosenForbidden': '引擎拒绝了这次写入,因为它会放宽会话规则:这里送来的条目里至少有一条是放宽允许范围而不是收窄。这条路上只接受增加限制的条目。',
     'rules.sessionPolicy.tighten.capabilityAbsent': '这个部署不保存会话级的工具规则,所以这里没有什么可收紧的。',
@@ -648,6 +779,7 @@ const ZH = {
     'rules.match.namePrefix': '技能名前缀匹配',
     'rules.match.host': '网站域名匹配(单个主机)',
     'rules.match.subdomain': '网站域名匹配(该域名下的每个主机)',
+    'rules.match.pattern': '命令模式匹配(命令里带星号)',
     'rules.match.unreported': '没有报告匹配形式',
     'rules.match.unknown': '这个版本不认识的匹配形式',
     'model.tier.blurb.ultra': '预留在 max 之上 —— 等更强的模型出现时再绑定',
@@ -656,11 +788,14 @@ const ZH = {
     'model.tier.blurb.flash': '又快又省 —— 标题、回顾、批量活儿',
     'model.tier.blurb.lite': '最省 —— 批量分类、简单查询',
     'model.catalog.candidateRejected': '部署拒绝了最近一次配置改动{which},仍在使用它之前的那份配置 —— 那次改动里新增的模型或设置没有生效',
+    'model.notServed.withDefault': '模型 {model} 在这台引擎的模型目录里不可用,所以本次会话改用引擎的缺省模型 {default}',
+    'model.notServed.noDefault': '模型 {model} 在这台引擎的模型目录里不可用,所以本次会话把模型的选择交给引擎',
     '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.headline.causeUnreadable': '这次失败的原因读不出(错误对象有一部分不可读)—— 不知道引擎是否收到了你的消息。重新发送之前,请先查看这次 run 的状态,或者重新接上它。',
     'notice.failure.quota.fiveHour': '你的 5 小时额度已用完',
     'notice.failure.quota.weekly': '你的每周额度已用完',
     'notice.failure.quota.budgetPersonal': '你的个人预算已用完',
@@ -697,13 +832,197 @@ const ZH = {
     'notice.failure.settings.riskJoin': '、',
     'notice.failure.wait.one': '服务器要求在 1 秒后重试(Retry-After)。',
     'notice.failure.wait.other': '服务器要求在 {seconds} 秒后重试(Retry-After)。',
+    'rules.issue.emptyTool': '这条规则无效:它没有指明任何工具',
+    'rules.issue.paren': '这条规则无效:它的括号解析不了(要写字面括号请转义成 \\( 或 \\))',
+    'rules.issue.toolName': "这条规则无效:它的工具名写法不是合法的工具名(规则两侧有空白、名字里或括号前有不可见或不允许的字符、以 '-' 起头,或是不指向任何工具的通配 '*'),所以它要么碰不到任何工具,要么碰到错的工具",
+    'rules.issue.paramSplit': '这条规则无效:它的括号里没有写成 name:pattern 的参数规则',
+    'rules.issue.primaryField': '这条规则无效:它对工具的主字段写了匹配模式,而主字段匹配的是去掉首尾空白后的整串,不是前缀',
+    'rules.issue.capExceeded': '这套规则无效:它超过了部署的某一项上限(规则条数、规则长度、模式长度或星号个数);仅凭这个码,本客户端分不出是哪一项',
+    'rules.issue.behavior': '这条规则无效:它的行为既不是 deny 也不是 ask,所以永远不会触发',
+    'rules.issue.commandRule': '这条规则无效:命令模式被命令规则校验器拒绝了',
+    'rules.issue.entryType': '这份 allow 列表无效:它必须是规则字符串的列表,而它本身或其中某一项不是字符串',
+    'rules.issue.nameAmbiguous': '这条规则无效:它写的名字同时对上了这个工具提供的多个取值,这些取值只在大小写、空格或标点上不同,分不出它指的是哪一个 —— 请写成确切的那一个',
+    'rules.issue.allowRule': '只写 deny 或 ask 的规则集里不支持 allow 规则 —— 常驻批准应放在 allow 列表里',
+    'rules.issue.paramUnknown': '这条参数规则不支持:这个工具没有这样的参数,所以它永远匹配不上',
+    'rules.issue.paramNonScalar': '这条参数规则不支持:该参数是对象或数组,所以它永远匹配不上',
+    'rules.issue.toolUnknown': '这条规则在这条链路上不支持:它所用的解析器不认识这个工具,所以无法核对规则的面',
+    'rules.issue.pathBase': '这条路径规则按现在的写法不支持:它所相对的基目录缺失,或不是可用的绝对路径,所以它什么也碰不到,会被拒绝而不是编译',
+    'rules.issue.mcpParen': 'MCP 工具名上不支持带括号的参数规则',
+    'rules.issue.coveringParen': '覆盖型协议名上不支持带括号的参数规则 —— 参数文法是按精确工具名索引的,所以任何已挂载的工具都不可能带它',
+    'rules.issue.paramSplitWithColon': '这条规则无效:参数规则要写成 name:pattern,而冒号前的名字或冒号后的模式是空的',
+    'rules.issue.paramSplitNoColon': '这条规则无效:括号里没有冒号,所以这不是参数规则(参数规则要写成 name:pattern)',
+    'rules.issue.newerCode': '这条规则被拒绝,码为 {code},这个码比本客户端新',
+    'model.probe.verdict.ok': '模型已回答',
+    'model.probe.verdict.okWaited': '模型已回答 —— {time} 后收到首个 token',
+    'model.probe.verdict.auth': '模型服务拒绝了这个 API 密钥{http}',
+    'model.probe.verdict.unreachable': '连不上模型服务',
+    'model.probe.verdict.unreachableWaited': '连不上模型服务 —— {time} 内没有响应',
+    'model.probe.verdict.model': '模型服务不认识这个模型 id{http}',
+    'model.probe.verdict.shape': '这个地址没有提供预期的接口{http} —— 请检查 API 形态',
+    'model.probe.verdict.busy': '模型服务此刻很忙{http} —— 请稍后重试或换个模型',
+    'model.probe.verdict.noToken': '模型服务有响应,但它可能过载了:没有发出任何 token',
+    'model.probe.verdict.noTokenWaited': '模型服务有响应,但它可能过载了:{time} 内没有发出任何 token',
+    'model.probe.verdict.other': '模型服务给出了意料之外的响应{http}',
+    'session.humanTurn.imageUnknownVision.one': '随这条消息发出了一张图片,但引擎的模型列表没有说明这条消息所用的模型是否接受图片输入 —— 如果不接受,图片可能被丢弃,或这条消息可能被拒绝',
+    'session.humanTurn.imageUnknownVision.other': '随这条消息发出了 {count} 张图片,但引擎的模型列表没有说明这条消息所用的模型是否接受图片输入 —— 如果不接受,图片可能被丢弃,或这条消息可能被拒绝',
+    'session.humanTurn.modelFragment': '({model})',
+    'session.humanTurn.refused.empty': '没有发送:一条消息需要有它自己的文字 —— 图片或附件不能单独发送',
+    'session.humanTurn.refused.malformedInput': '没有发送:客户端读不懂要发送的这条消息 —— 这是客户端的问题,不是你的消息有问题',
+    'session.humanTurn.refused.malformedItem': '没有发送:这条消息里有一项读不懂 —— 这是客户端的问题,不是你的消息有问题',
+    'session.humanTurn.refused.duplicateUuid': '没有发送:这一批里有两项带着同一个编号 —— 这是客户端的问题,不是你的消息有问题',
+    'session.humanTurn.refused.riderCollidesPrimary': '没有发送:某一项随行内容的编号与另一项本身的编号相同 —— 这是客户端的问题,不是你的消息有问题',
+    'session.humanTurn.refused.oversize': '没有发送:这条消息太大,即使把每个附件都缩成引用形也发不出去 —— 请缩短消息或少附一些内容',
+    'session.humanTurn.held.noText': '这条消息已留队,等当前这一轮结束后作为新消息发出:它没有可以并进进行中这一轮的文字',
+    'session.humanTurn.held.reminderTag': '这条消息已留队,等当前这一轮结束后作为新消息发出:它的文字里含有保留标签,不能并进进行中的这一轮',
+    'session.humanTurn.held.controlChar': '这条消息已留队,等当前这一轮结束后作为新消息发出:它的文字里含有控制字符,不能并进进行中的这一轮',
+    'session.humanTurn.held.tooLong': '这条消息已留队,等当前这一轮结束后作为新消息发出:它的文字比并进进行中这一轮的补话所允许的更长',
+    'session.humanTurn.degraded.visionNo.one': '有 1 张图片没有发送:这只模型{model}不能看图',
+    'session.humanTurn.degraded.visionNo.other': '有 {count} 张图片没有发送:这只模型{model}不能看图',
+    'session.humanTurn.degraded.imageTooLarge.one': '有 1 张图片没有发送:它超过了引擎接受的单张图片大小',
+    'session.humanTurn.degraded.imageTooLarge.other': '有 {count} 张图片没有发送:每张都超过了引擎接受的单张图片大小',
+    'session.humanTurn.degraded.seatCount.one': '有 1 张图片没有发送:一条消息能带的图片数量有限',
+    'session.humanTurn.degraded.seatCount.other': '有 {count} 张图片没有发送:一条消息能带的图片数量有限',
+    'session.humanTurn.degraded.seatTotal.one': '有 1 张图片没有发送:这条消息里的图片合起来太大',
+    'session.humanTurn.degraded.seatTotal.other': '有 {count} 张图片没有发送:这条消息里的图片合起来太大',
+    'session.humanTurn.degraded.bodyBudget.one': '有 1 项附带内容发出时没有带上内容:这条消息太大,无法完整发送',
+    'session.humanTurn.degraded.bodyBudget.other': '有 {count} 项附带内容发出时没有带上内容:这条消息太大,无法完整发送',
+    'session.humanTurn.degraded.steerAdmission.one': '有 1 项附带内容只以引用形发出:它的内容不能并进进行中的这一轮',
+    'session.humanTurn.degraded.steerAdmission.other': '有 {count} 项附带内容只以引用形发出:它们的内容不能并进进行中的这一轮',
+    'session.humanTurn.degraded.noImageSeat.one': '有 1 张图片没有发送:进行中的这一轮不能再加图片 —— 请在这一轮结束后作为新消息发送',
+    'session.humanTurn.degraded.noImageSeat.other': '有 {count} 张图片没有发送:进行中的这一轮不能再加图片 —— 请在这一轮结束后作为新消息发送',
+    'session.humanTurn.degraded.noAttachmentIdSeat.one': '有 1 个上传文件没有附上:进行中的这一轮不能再加文件 —— 请在这一轮结束后作为新消息发送',
+    'session.humanTurn.degraded.noAttachmentIdSeat.other': '有 {count} 个上传文件没有附上:进行中的这一轮不能再加文件 —— 请在这一轮结束后作为新消息发送',
+    'session.humanTurn.printVision.no': '这只模型{model}不能看图,所以这条提示里的图片没有发送',
+    'session.humanTurn.printVision.unknown': '引擎的模型列表没有说明这只模型{model}是否接受图片输入 —— 这条提示里的图片仍然发出了;如果它不接受,图片可能被丢弃,或这一发可能被拒绝',
+    'config.scenarioRefusal.source.ruling': ',由配置中心指派给你,',
+    'config.scenarioRefusal.source.deployment': ',这个部署的缺省场景,',
+    'config.scenarioRefusal.dangling': '这个部署解析不了你的场景:场景{name}{from}在这里不存在,所以凡是依赖你场景的一切它都拒绝 —— 没有指明场景的新运行,以及本会话的 MCP 服务器名单 · 请让运维这台引擎的人修复场景指派',
+    'config.scenarioRefusal.generic': '这个部署的场景检查拒绝解析你的场景{tail},所以凡是依赖你场景的一切都不可用 —— 本会话的 MCP 服务器名单未知',
+    'notice.wireRefusal.cancel.approvalSettled': '取消没有生效:这个任务正在等待的审批已经在别处被决定或已过期 · 先查看那个决定对该任务做了什么,再做别的',
+    'notice.wireRefusal.cancel.runNotRunning': '无法设置取消:引擎尝试期间,任务一直在运行与等待之间来回切换 · 没有任何改动 —— 请再发一次取消',
+    'notice.wireRefusal.cancel.unrecognized': '引擎以一个没有说明原因的冲突拒绝了这次取消 · 该任务可能刚刚在别处被决定,或在取消途中改变了状态 —— 请查看它当前的状态,如果它仍然活跃再取消一次',
+    'notice.wireRefusal.sendAgainAbout': '大约 {wait} 后重新发送',
+    'notice.wireRefusal.usageWindow.head': '部署的用量窗已耗尽,所以引擎没有受理这个请求 · 请求本身没有任何问题',
+    'notice.wireRefusal.usageWindow.unknownWait': '引擎没有说明窗口还需要多久 —— 请稍后再发送',
+    'notice.wireRefusal.fleetLease.head': '这个部署无法向它的额度服务确认你的用量预算,而在无法检查期间它拒绝计费的工作,所以引擎没有受理这个请求 · 请求本身没有任何问题',
+    'notice.wireRefusal.fleetLease.authRejected': '额度服务拒绝了这台引擎的凭据 —— 如果持续出现,需要由运维这台引擎的人去修复它们',
+    'notice.wireRefusal.fleetLease.unreachable': '引擎连不上额度服务',
+    'notice.wireRefusal.fleetLease.unknownWait': '引擎没有说明要等多久 —— 请稍后再发送',
+    'notice.wireRefusal.denyAttribution.notInProof': '引擎在判断之前就拒绝了这次拒绝:这个部署会给它接受的决定签名,而说明是谁结算了这次决定的那条备注不在被签名的内容里 · 没有做出任何决定,审批仍在等待 —— 请去掉那条备注后,把同一个决定再发一次',
+    'notice.wireRefusal.denyAttribution.decisionConflict': '引擎在判断之前就拒绝了这个决定:请求体既说它由策略结算,又要求放行这次调用,而放行只能由人来做 · 没有做出任何决定,审批仍在等待 —— 请让决定与备注一致后再发一次',
+    'notice.wireRefusal.denyAttribution.retiredKey': '引擎在判断之前就拒绝了这个决定:说明是谁结算它的那条备注用的名字,这台引擎已不再接受 · 没有做出任何决定,审批仍在等待 —— 请改用引擎现在取而代之的名字来写明是谁做出的,再发一次决定',
+    'notice.wireRefusal.denyAttribution.attributionRejected': '引擎不接受这个决定携带的结算信息,所以在判断之前就拒绝了这个决定。{named} · 没有做出任何决定,审批仍在原来的位置等待 —— 请检查那一部分带的是什么(本客户端只设置其中一项:说明是谁结算了这次拒绝的备注),然后再决定一次',
+    'notice.wireRefusal.denyAttribution.named': '它点名 {field} 为它不接受的那一部分。',
+    'notice.wireRefusal.sessionDelete.unrecognized': '引擎以一个没有说明原因的冲突拒绝删除这个会话 · 请确认会话是否仍在列表里、其中是否还有东西在运行,然后再试一次删除',
+    'notice.wireRefusal.sessionDelete.childrenAlive': '这个会话没有被删除:它启动的后台代理仍在这台引擎停不掉它们的地方运行{which} · 没有删除任何东西 —— 等它们结束后再删,或先到它们运行的地方把它们停掉',
+    'notice.wireRefusal.sessionDelete.which': '({ids})',
+    'notice.wireRefusal.sessionDelete.whichMore': '({ids},另有 {count} 个)',
+    'notice.wireRefusal.sessionDelete.activeRun': '这个会话没有被删除:它还有一个运行正在进行{run} · 没有删除任何东西 —— 请取消那个运行或等它结束,然后再删除会话',
+    'notice.wireRefusal.sessionDelete.runId': '(运行 {id})',
+    'notice.wireRefusal.bucket.unknown': '引擎拒绝了这个请求设置里的权限规则,认为条数过多或格式有误 · 没有任何内容被裁剪或丢弃 —— 请修正规则列表,然后重新发送请求',
+    'notice.wireRefusal.bucket.subject.stored': '引擎拒绝继续这件停驻的工作:在为它保存的请求里,',
+    'notice.wireRefusal.bucket.subject.fresh': '引擎拒绝了这个请求:',
+    'notice.wireRefusal.bucket.list': '权限设置里的 {bucket} 规则列表(permissions.{bucket})',
+    'notice.wireRefusal.bucket.what.overCap.more': '{list}有 {count} 条,比引擎接受的 {cap} 条多了 {excess} 条',
+    'notice.wireRefusal.bucket.what.overCap.atMost': '{list}有 {count} 条,而引擎最多接受 {cap} 条',
+    'notice.wireRefusal.bucket.what.overCap.unknown': '{list}的条数超过了引擎接受的数量',
+    'notice.wireRefusal.bucket.what.badEntry.at': '{list}的第 {position} 条是空的或不是文本',
+    'notice.wireRefusal.bucket.what.badEntry.notList': '{list}不是一个规则列表',
+    'notice.wireRefusal.bucket.fix.merge': '把规则合并成更宽的模式,或删掉一些',
+    'notice.wireRefusal.bucket.fix.entry': '修正或删除那一条,让每一条都是非空的规则',
+    'notice.wireRefusal.bucket.fix.list': '把它改成非空规则的列表',
+    'notice.wireRefusal.bucket.next.stored': '它无法按保存的样子继续,而引擎宁可拒绝这份列表也不静默丢规则 —— {fix},然后把这件工作作为新请求重新提交',
+    'notice.wireRefusal.bucket.next.fresh': '没有任何内容被裁剪或丢弃,因为引擎宁可拒绝这份列表也不静默丢规则 —— {fix},然后重新发送请求',
+    'notice.wireRefusal.toolDeclaration': '引擎因为这个请求声明的某个工具而拒绝启动这次运行;引擎自己的消息会说明是哪个工具、出了什么问题 · 这是请求本身的问题,不是暂时的故障 —— 原样再发同一个请求会被同样拒绝;请修正或删掉那个工具声明,再发送',
+    'notice.wireRefusal.hostPosture.notLocal': '这不是你本地设置的问题,也不是本客户端能授予的 —— 由运行这台引擎的人决定',
+    'notice.wireRefusal.hostPosture.wholeEnv': '引擎在任何东西运行之前就拒绝了这个请求:这个部署服务于多个用户,所以请求不能把这台机器的整份环境交给 shell · {notLocal};请去掉整份环境设置(或使用缺省)后重新发送,shell 会拿到缺省环境,其中疑似凭据的变量已被移除',
+    'notice.wireRefusal.hostPosture.writeFace': '引擎在任何东西运行之前就拒绝了这个请求:这个部署不允许请求用 bypassPermissions 抬高写入边界 · {notLocal};请换另一种权限模式后重新发送',
+    'notice.wireRefusal.hostPosture.both': '引擎在任何东西运行之前就拒绝了这个请求:请求既要求 shell 继承这台机器的整份环境,又要求 bypassPermissions,而这个部署至少拒绝了其中一项;拒绝并没有说明是哪一项 · {notLocal};请去掉其中一项或两项后重新发送(整份环境设置只在单用户部署上才被采纳)',
+    'notice.wireRefusal.hostPosture.unattributed': '引擎在任何东西运行之前就拒绝了这个请求:这个部署不接受请求里只有单用户部署才能使用的某项设置;引擎自己的消息会点名它 · {notLocal};请去掉那项设置后重新发送',
+    'notice.wireRefusal.autonomyLane': '引擎没有启动这次 leader 运行:这个部署运行在只做计划的自主档,而 leader 运行没有办法让它的计划被审阅,所以什么也没有启动 · 请改为作为普通运行提交这项工作,或请运维这台引擎的人更改它的自主设置',
+    'notice.wireRefusal.unsupportedRule': '引擎拒绝了这个请求,所以其中任何内容都没有生效:里面有一条规则是引擎不支持的写法 —— {detail} · 请删掉或改写那条规则(要整只拦下一个工具,请只写工具名),再重新发送',
+    'notice.wireRefusal.unsupportedRule.other': '引擎拒绝了这个请求,所以其中任何内容都没有生效:里面有 {count} 条规则是引擎不支持的写法 —— {detail} · 请删掉或改写这些规则(要整只拦下一个工具,请只写工具名),再重新发送',
+    'notice.wireRefusal.unsupportedRule.stored': '引擎拒绝继续这件工作:为它保存的请求里有一条规则是引擎不支持的写法 —— {detail} · 它无法按保存的样子继续。请删掉或改写那条规则(要整只拦下一个工具,请只写工具名);若这件工作仍停驻着,请先取消它,然后作为新请求重新提交',
+    'notice.wireRefusal.unsupportedRule.stored.other': '引擎拒绝继续这件工作:为它保存的请求里有 {count} 条规则是引擎不支持的写法 —— {detail} · 它无法按保存的样子继续。请删掉或改写这些规则(要整只拦下一个工具,请只写工具名);若这件工作仍停驻着,请先取消它,然后作为新请求重新提交',
+    'notice.prepareRefusal.draftKept': '你的草稿还保留着',
+    'notice.prepareRefusal.mcpServerNameCollision': '引擎在准备这一跑时拒绝了它:为它声明的两台 MCP 服务器分不出彼此 —— 同一个名字写了两次,或名字被引擎转成了同一个工具名前缀(例如“a.b”与“a_b”),工具名会撞在一起 · 引擎自己的报错文字会点名它们 · 同样的请求再发一次仍会被同样拒绝;请在配置这一跑 MCP 服务器的地方给其中一台改个名字,或移除其中一台(若是部署声明的,请找运维这台引擎的人),然后重新发送',
+    'notice.retry.source.unifiedHeader': '依据模型服务的额度响应头判定',
+    'notice.retry.source.providerCode': '依据模型服务的错误码判定',
+    'notice.retry.source.status': '仅依据 HTTP 状态码判定',
+    'session.toolResult.media.kind.image': '图像',
+    'session.toolResult.media.kind.document': '文档',
+    'session.toolResult.media.notDelivered.descriptor': '[{kind}未送达：{mimeType}，{bytes} 字节]',
+    'session.toolResult.media.notDelivered.descriptorNoMime': '[{kind}未送达：{bytes} 字节]',
+    'session.toolResult.media.notDelivered.omitted.one': '[{blocks} 个媒体块未送达：共 {bytes} 字节]',
+    'session.toolResult.media.notDelivered.omitted.other': '[{blocks} 个媒体块未送达：共 {bytes} 字节]',
+    'session.workflowResume.line': '续跑：{detail}',
+    'session.workflowResume.counts': '日志里 {journaled} 条结果，回放了 {replayed} 条',
+    'session.workflowResume.countsOnly': '回放了 {replayed} 条日志结果',
+    'session.workflowResume.noJournal': '没有找到日志条目 —— 什么也没回放，整个脚本重新实跑',
+    'session.workflowResume.stopAt': '回放停在第 {ordinal} 个 agent（{reason}）—— 这一步及之后的每一步都是重新实跑',
+    'session.workflowResume.stopAtNoReason': '回放停在第 {ordinal} 个 agent —— 这一步及之后的每一步都是重新实跑',
+    'session.workflowResume.stop': '回放中止（{reason}）—— 这一步及之后的每一步都是重新实跑',
+    'notice.providerRejection.quotaExhausted': '模型服务商拒绝了这次请求（HTTP {status}）：在有人处理或用量窗口重置之前，这个账号无法被该模型服务响应 —— 请检查服务商账号，或换一个模型。',
+    'notice.usageLimit.autoResume.fired': '用量额度已恢复 · 现在继续',
+    'notice.usageLimit.autoResume.reset': '用量额度已重置 · 按 enter 继续',
+    'notice.usageLimit.autoResume.breaker': '连续触及用量上限,已停止自动继续',
+    'notice.usageLimit.autoResume.superseded': '已跳过自动继续 · 你先发送了另一条消息',
+    'notice.usageLimit.autoResume.notReplayable': '此消息无法自动继续 · 它不能原样重发',
+    'notice.usageLimit.autoResume.contextChanged': '已跳过自动继续 · 开启时所在的上下文已变化(会话、工作目录、历史或权限模式)',
+    'notice.usageLimit.autoResume.escaped': '已取消自动继续 · 用 /rate-limit-options 可重新开启',
+    'notice.usageLimit.autoResume.horizon': '已触及用量上限 · 将在 24 小时以后重置 · 用 /rate-limit-options 可仍然等待',
+    'notice.usageLimit.autoResume.armed.at': '已触及用量上限 · 将于 {time} 自动继续 · 按 esc 取消',
+    'notice.usageLimit.autoResume.armed.shortly': '已触及用量上限 · 即将自动继续 · 按 esc 取消',
+    'notice.usageLimit.autoResume.option.cancel': '停止并等待额度重置',
+    'notice.usageLimit.autoResume.option.cancelAuto': '停止自动继续',
+    'notice.usageLimit.autoResume.option.auto': '重置后自动继续',
+    'notice.usageLimit.autoResume.option.autoHorizon': '重置后自动继续(额度将在 24 小时以后重置)',
+    'notice.usageLimit.autoResume.disabled.breaker': '连续触及用量上限后,自动继续已停止',
+    'notice.usageLimit.autoResume.disabled.notReplayable': '此消息不能原样重发(含附件或是一条命令)',
+    'notice.usageLimit.autoResume.disabled.contextChanged': '开启时所在的上下文已不存在',
+    'notice.usageLimit.autoResume.disabled.noResetInstant': '这个额度窗口没有预定的重置时间',
+    'notice.usageLimit.autoResume.disabled.nothingWaiting': '没有因用量上限而待发送的消息',
+    'session.selfHeal.row.interrupted.settled': '你中断的那一轮已在引擎上停稳(运行 {taskId}),sema 现在把你的消息作为新一轮发送。',
+    'session.selfHeal.row.interrupted.stillFinishing': '你中断的那一轮仍在引擎上收尾(运行 {taskId},已等 {waited}),你的消息没有发出。稍等片刻后再发一次。',
+    'session.rewind.conversationOnly.withCodeRoute': '只回退了对话 —— 这台引擎没有确认能在组合回退里恢复文件；要回退文件，请再运行 /rewind 并选择「Restore code」。',
+    'session.rewind.conversationOnly.noCodeRoute': '只回退了对话 —— 这台引擎没有确认能在组合回退里恢复文件，所以文件没有回退。',
+    'config.hooks.matcher.unjudged.eventOutOfScope': '本检查不对该事件的 matcher 求值',
+    'config.hooks.matcher.unjudged.notAString': '它不是字符串',
+    'config.hooks.matcher.unjudged.oversize': '它太长，没法检查',
+    'config.hooks.matcher.unjudged.patternUnsupported': '它用了本检查不求值的正则特性',
+    'config.hooks.matcher.unjudged.overBudget': '它是一条代价过高、本检查不去求值的正则',
+    'config.hooks.matcher.unjudged.unknown': '本检查读不出它',
+    'doctor.wiring.fleetTranscripts.full': '后台子代对话留存：full —— 这个部署会让后台子代句柄活过引擎重启',
+    'doctor.wiring.fleetTranscripts.noPromise': '后台子代对话留存：{tier} —— 这个部署不承诺后台子代句柄能活过引擎重启',
+    'doctor.wiring.fleetTranscripts.unknownTier': '后台子代对话留存：未知档位（“{tier}”）—— 按「不承诺后台子代句柄能活过引擎重启」读',
+    'config.attachments.refusal.credentialShapedWord': '看起来是一把凭据而不是附件清单，所以没有使用、也不在这里显示 —— 凭据不该放进这个设置。',
+    'session.subagent.delegatedPrompt.absence.notOwnedAfterRestart': '这个子代的 prompt 显示不了：本进程没有记录它的对话存在哪里（这份记录只在内存里，重启后、或从别的壳续的 run 里都是空的）。',
+    'session.subagent.delegatedPrompt.absence.notInStore': '这个子代的 prompt 显示不了：引擎的会话店里没有它的会话。',
+    'session.subagent.delegatedPrompt.absence.forbidden': '这个子代的 prompt 显示不了：引擎不允许读取它的对话。',
+    'session.subagent.delegatedPrompt.absence.promptAbsent': '读到了这个子代的对话，但里面没有可显示的委派 prompt。',
+    'session.subagent.delegatedPrompt.absence.unknown': '这个子代的 prompt 这次读取不到。',
+    'rules.sessionPolicy.tighten.unknown.sessionOwnerless.noIdentity': '这个会话没有属主，为它写的规则之后永远读不回来；没有写入任何内容。',
+    'rules.sessionPolicy.tighten.unknown.storeCorrupt.noOperator': '引擎确认不了这个会话的规则当前在哪一版，拒绝盖新版本，所以没有写入任何内容。送去的条目没有问题 —— 这台部署没有运维方可以查看规则库，要由运行它的人处理。',
+    'rules.sessionPolicy.deployment.noOperator.readStoreCorrupt': '引擎确认不了这个会话的规则当前在哪一版，所以没有交出这份记录。这台部署没有运维方可以查看规则库，要由运行它的人处理。',
+    'rules.sessionPolicy.deployment.noOperator.removeLoosenForbidden': '引擎拒绝把这些条目从这个会话的规则记录里拿掉：这台引擎上只有运维方能从里面删条目，而这台部署没有运维方，所以记录没有变。请在新会话里继续。',
+    'rules.sessionPolicy.deployment.noOperator.removeReadStoreCorrupt': '引擎确认不了这个会话的规则当前在哪一版，所以没有改动任何内容。这台部署没有运维方可以查看规则库，要由运行它的人处理。',
+    'rules.sessionPolicy.deployment.noOperator.removeWriteStoreCorrupt': '引擎确认不了这个会话的规则当前在哪一版，拒绝盖新版本，所以没有改动任何内容。这台部署没有运维方可以查看规则库，要由运行它的人处理。',
+    'config.hooks.plan.reason.compactionLocalFallback': '这一次压缩的摘要因引擎会话不可用而在本客户端本地生成，引擎不会替它运行这只 hook，所以由本客户端自己运行',
+    'session.hooks.compactTransition.disclosure.engineOutcomeUnknown': '摘要改走本客户端时，压缩请求已经发给了引擎，所以引擎有没有运行压缩 hook 这里判不了，本客户端也没有再运行一遍。',
+    'session.hooks.compactTransition.disclosure.neitherRan': '这一次压缩 hook 没有运行：引擎没有在这里压缩，本客户端的本地摘要也没能启动。引擎之后若仍会压缩，到时会运行它们。',
 };
 export const ZH_MESSAGES = Object.freeze(ZH);
 export const TERM_SLOTS = Object.freeze({
     'config.mcp.toolAxesInvalid': ['toolAxes'],
+    'config.mcp.toolFacesInvalid': ['toolFaces'],
     'config.mcp.cloudToolAxesInvalid': ['toolAxes'],
+    'config.mcp.cloudToolFacesInvalid': ['toolFaces'],
     'config.mcp.elicitationInvalid': ['elicitation'],
     'config.mcp.cloudElicitationInvalid': ['elicitation'],
+    'config.skills.cloudToolListInvalid': ['allowedTools', 'disallowedTools'],
+    'config.mcp.allowToolsInvalid': ['allowTools'],
+    'config.mcp.cloudAllowToolsInvalid': ['allowTools'],
+    'config.mcp.identityHeadersBothSet': ['principalHeader', 'assertionHeader'],
     'approval.settle.cause.runCancelled': ['run'],
     'approval.settle.cause.runExited': ['run'],
     'approval.settle.cause.ttlExpired': ['approval window'],
@@ -745,6 +1064,8 @@ export const TERM_SLOTS = Object.freeze({
     'resume.refusal.park.interactiveBusy': ['parked', 'run'],
     'resume.refusal.park.blockedPrint': ['run'],
     'resume.refusal.park.blockedInteractive': ['run'],
+    'approval.askPark.autoReopenBlocked.policyInteractive': ['run'],
+    'approval.askPark.autoReopenBlocked.policyPrint': ['run'],
     'session.selfHeal.handle.run': ['run'],
     'session.selfHeal.decidePathClause': ['run'],
     'session.selfHeal.lastActivity': ['run'],
@@ -803,6 +1124,10 @@ export const TERM_SLOTS = Object.freeze({
     'session.selfHeal.row.notParked.parkedOn': ['run'],
     'session.selfHeal.row.notParked.inFlight': ['run', 'turn'],
     'session.selfHeal.row.stateUnknown': ['run', 'turn'],
+    'session.selfHeal.endRun.engine': ['run'],
+    'session.selfHeal.endRun.engineInteractive': ['run'],
+    'session.selfHeal.endRun.engineInteractive.noId': ['run'],
+    'session.selfHeal.row.steerFailed.runEnded': ['run', 'turn'],
     'session.selfHeal.headless.decide': ['parked', 'run'],
     'session.selfHeal.headless.statusOnly': ['run'],
     'session.selfHeal.headless.neverReleased': ['run'],
@@ -833,5 +1158,8 @@ export const TERM_SLOTS = Object.freeze({
     'notice.failure.headline.timeout': ['run'],
     'notice.failure.headline.parked': ['parked', 'run', 'turn'],
     'notice.failure.headline.internal': ['turn'],
+    'notice.failure.headline.causeUnreadable': ['run'],
     'notice.failure.settings.safety': ['turn'],
+    'notice.wireRefusal.hostPosture.writeFace': ['bypassPermissions'],
+    'notice.wireRefusal.hostPosture.both': ['bypassPermissions'],
 });