@ai-agent-forge/agent-forge 0.86.7 → 0.87.0

package/dist/core/i18n/locales/zh-cn/core-contract-extensions.js

@@ -0,0 +1,582 @@
+/**
+ * core-contract-extensions 域词典（批次⑨a）：src/core/extensions/ 插件开发者
+ * 契约错误（D 类）。覆盖范围见 docs/design/国际化与本地化.md：lifecycle 事件
+ * envelope 校验、能力运行时、插件 manifest/注册校验、宿主能力门卫、引导插件
+ * 与投递队列。key 为英文原文（与调用点逐字一致），占位符 `{name}` 原样保留；
+ * 事件名（tool.call 等）与字段路径（data.revision.sessionId 等）按术语保留原文。
+ * 豁免未包装（行为依赖消息前缀匹配）：Capability API is revoked / Contribution
+ * point is not defined（capability-runtime-store.ts / agent-session-tools.ts 以
+ * startsWith 消费）。
+ */
+export const coreContractExtensions = {
+    // ---- lifecycle 事件 envelope 校验（lifecycle-catalog.ts） ----
+    "agent lifecycle data has unsupported fields": "agent lifecycle data 包含不支持的字段",
+    "agent lifecycle data must be a plain object": "agent lifecycle data 必须是普通对象",
+    "agent lifecycle data.version must be 1": "agent lifecycle data.version 必须为 1",
+    "agent.end data has unsupported fields": "agent.end data 包含不支持的字段",
+    "agent.end data must be a plain object": "agent.end data 必须是普通对象",
+    "agent.end data.messageCount must be a non-negative safe integer": "agent.end data.messageCount 必须是非负安全整数",
+    "agent.end data.version must be 1": "agent.end data.version 必须为 1",
+    "agent.task.settled data has unsupported fields: {unsupported}": "agent.task.settled data 包含不支持的字段：{unsupported}",
+    "agent.task.settled data is missing required field: {key}": "agent.task.settled data 缺少必需字段：{key}",
+    "agent.task.settled data must be a plain object": "agent.task.settled data 必须是普通对象",
+    "agent.task.settled data.status is invalid": "agent.task.settled data.status 无效",
+    "agent.task.settled data.version must be 1": "agent.task.settled data.version 必须为 1",
+    "before.agent.start data has unsupported fields": "before.agent.start data 包含不支持的字段",
+    "before.agent.start data has unsupported fields: {unsupported}": "before.agent.start data 包含不支持的字段：{unsupported}",
+    "before.agent.start data is missing required field: {key}": "before.agent.start data 缺少必需字段：{key}",
+    "before.agent.start data must be a plain object": "before.agent.start data 必须是普通对象", // 复用：lifecycle-catalog.ts
+    "before.agent.start data.hasImages must be a boolean": "before.agent.start data.hasImages 必须是布尔值",
+    "before.agent.start data.systemPrompt must be a string": "before.agent.start data.systemPrompt 必须是字符串",
+    "before.agent.start data.systemPromptOptions must be a plain object": "before.agent.start data.systemPromptOptions 必须是普通对象",
+    "before.agent.start data.version must be 1": "before.agent.start data.version 必须为 1",
+    "before.agent.start data.version must be 2": "before.agent.start data.version 必须为 2",
+    "capability.call data has unsupported fields: {unsupported}": "capability.call data 包含不支持的字段：{unsupported}",
+    "capability.call data is missing required field: {key}": "capability.call data 缺少必需字段：{key}",
+    "capability.call data must be a plain object": "capability.call data 必须是普通对象",
+    "capability.call data.capabilityKind is invalid": "capability.call data.capabilityKind 无效",
+    "capability.call data.capabilityVersion must be a positive safe integer": "capability.call data.capabilityVersion 必须是正安全整数",
+    "capability.call data.error has unsupported fields": "capability.call data.error 包含不支持的字段",
+    "capability.call data.error is missing required field: code": "capability.call data.error 缺少必需字段：code",
+    "capability.call data.error is missing required field: message": "capability.call data.error 缺少必需字段：message",
+    "capability.call data.error must be a plain object": "capability.call data.error 必须是普通对象",
+    "capability.call data.event is invalid": "capability.call data.event 无效",
+    "capability.call data.status is invalid": "capability.call data.status 无效",
+    "capability.call data.version must be 1": "capability.call data.version 必须为 1",
+    "capability.call end requires status": "capability.call 的 end 需要 status",
+    "capability.call start/cancel must not include error": "capability.call 的 start/cancel 不得包含 error",
+    "capability.call start/cancel must not include status": "capability.call 的 start/cancel 不得包含 status",
+    "capability.call succeeded end must not include error": "capability.call 成功的 end 不得包含 error",
+    "context.assembled data has unsupported fields": "context.assembled data 包含不支持的字段",
+    "context.assembled data must be a plain object": "context.assembled data 必须是普通对象",
+    "context.assembled data.messageCount must be a non-negative safe integer": "context.assembled data.messageCount 必须是非负安全整数",
+    "context.assembled data.version must be 1": "context.assembled data.version 必须为 1",
+    "input.gate.blocked data has unsupported fields: {unsupported}": "input.gate.blocked data 包含不支持的字段：{unsupported}",
+    "input.gate.blocked data is missing required field: {key}": "input.gate.blocked data 缺少必需字段：{key}",
+    "input.gate.blocked data must be a plain object": "input.gate.blocked data 必须是普通对象",
+    "input.gate.blocked data.textLength must be a non-negative integer": "input.gate.blocked data.textLength 必须是非负整数",
+    "input.gate.blocked data.version must be 1": "input.gate.blocked data.version 必须为 1",
+    "input.received data has unsupported fields": "input.received data 包含不支持的字段",
+    "input.received data must be a plain object": "input.received data 必须是普通对象",
+    "input.received data.textLength must be a non-negative safe integer": "input.received data.textLength 必须是非负安全整数",
+    "input.received data.version must be 1": "input.received data.version 必须为 1",
+    "message lifecycle data has unsupported fields": "message lifecycle data 包含不支持的字段",
+    "message lifecycle data must be a plain object": "message lifecycle data 必须是普通对象",
+    "message lifecycle data.version must be 1": "message lifecycle data.version 必须为 1",
+    "model.response data has unsupported fields: {unsupported}": "model.response data 包含不支持的字段：{unsupported}",
+    "model.response data is missing required field: {key}": "model.response data 缺少必需字段：{key}",
+    "model.response data must be a plain object": "model.response data 必须是普通对象",
+    "model.response data.message must be an assistant message object": "model.response data.message 必须是 assistant message 对象",
+    "model.response data.message.role must be assistant": "model.response data.message.role 必须是 assistant",
+    "model.response data.revision has unsupported fields": "model.response data.revision 包含不支持的字段",
+    "model.response data.revision must be a plain object": "model.response data.revision 必须是普通对象",
+    "model.response data.revision.sequence must be a non-negative safe integer": "model.response data.revision.sequence 必须是非负安全整数",
+    "model.response data.revision.sessionId must match sessionId": "model.response data.revision.sessionId 必须与 sessionId 一致",
+    "model.response data.revision.version must be 1": "model.response data.revision.version 必须为 1",
+    "model.response data.stopReason is invalid": "model.response data.stopReason 无效",
+    "model.response data.version must be 1": "model.response data.version 必须为 1",
+    "model.select data has unsupported fields": "model.select data 包含不支持的字段",
+    "model.select data must be a plain object": "model.select data 必须是普通对象",
+    "model.select data.source is invalid": "model.select data.source 无效",
+    "model.select data.version must be 1": "model.select data.version 必须为 1",
+    "model.stream committed phase only permits terminal events": "model.stream 的 committed phase 只允许终止事件",
+    "model.stream data has unsupported fields: {unsupported}": "model.stream data 包含不支持的字段：{unsupported}",
+    "model.stream data is missing required field: {key}": "model.stream data 缺少必需字段：{key}",
+    "model.stream data must be a plain object": "model.stream data 必须是普通对象",
+    "model.stream data.event is invalid": "model.stream data.event 无效",
+    "model.stream data.phase is invalid": "model.stream data.phase 无效",
+    "model.stream data.sequence must be a positive safe integer": "model.stream data.sequence 必须是正安全整数",
+    "model.stream data.terminal does not match event": "model.stream data.terminal 与 event 不一致",
+    "model.stream data.version must be 1": "model.stream data.version 必须为 1",
+    "model.stream done event cannot contain error": "model.stream 的 done 事件不能包含 error",
+    "model.stream error event requires error object": "model.stream 的 error 事件需要 error 对象",
+    "model.stream error has unsupported fields": "model.stream error 包含不支持的字段",
+    "model.stream non-terminal event cannot contain error": "model.stream 的非终止事件不能包含 error",
+    "operation.cancel data has unsupported fields": "operation.cancel data 包含不支持的字段",
+    "operation.cancel data must be a plain object": "operation.cancel data 必须是普通对象",
+    "operation.cancel data.version must be 1": "operation.cancel data.version 必须为 1",
+    "operation.end data has unsupported fields: {unsupported}": "operation.end data 包含不支持的字段：{unsupported}",
+    "operation.end data is missing required field: {key}": "operation.end data 缺少必需字段：{key}",
+    "operation.end data must be a plain object": "operation.end data 必须是普通对象",
+    "operation.end data.status is invalid": "operation.end data.status 无效",
+    "operation.end data.version must be 1": "operation.end data.version 必须为 1",
+    "operation.start data has unsupported fields": "operation.start data 包含不支持的字段",
+    "operation.start data must be a plain object": "operation.start data 必须是普通对象",
+    "operation.start data.version must be 1": "operation.start data.version 必须为 1",
+    "operation.step data has unsupported fields": "operation.step data 包含不支持的字段",
+    "operation.step data must be a plain object": "operation.step data 必须是普通对象",
+    "operation.step data.step must be a positive safe integer": "operation.step data.step 必须是正安全整数",
+    "operation.step data.version must be 1": "operation.step data.version 必须为 1",
+    "plugin.dispose data has unsupported fields": "plugin.dispose data 包含不支持的字段",
+    "plugin.dispose data must be a plain object": "plugin.dispose data 必须是普通对象",
+    "plugin.dispose data.status is invalid": "plugin.dispose data.status 无效",
+    "plugin.dispose data.version must be 1": "plugin.dispose data.version 必须为 1",
+    "plugin.ready data has unsupported fields": "plugin.ready data 包含不支持的字段",
+    "plugin.ready data must be a plain object": "plugin.ready data 必须是普通对象",
+    "plugin.ready data.version must be 1": "plugin.ready data.version 必须为 1",
+    "plugin.rejected data has unsupported fields": "plugin.rejected data 包含不支持的字段",
+    "plugin.rejected data must be a plain object": "plugin.rejected data 必须是普通对象",
+    "plugin.rejected data.code is invalid": "plugin.rejected data.code 无效",
+    "plugin.rejected data.pluginId must be a string when present": "plugin.rejected data.pluginId 存在时必须是字符串",
+    "plugin.rejected data.version must be 1": "plugin.rejected data.version 必须为 1",
+    "provider.failover.probe.failed data has unsupported fields: {unsupported}": "provider.failover.probe.failed data 包含不支持的字段：{unsupported}",
+    "provider.failover.probe.failed data is missing required field: {key}": "provider.failover.probe.failed data 缺少必需字段：{key}",
+    "provider.failover.probe.failed data must be a plain object": "provider.failover.probe.failed data 必须是普通对象",
+    "provider.failover.probe.failed data.version must be 1": "provider.failover.probe.failed data.version 必须为 1",
+    "provider.failover.recovered data has unsupported fields": "provider.failover.recovered data 包含不支持的字段",
+    "provider.failover.recovered data must be a plain object": "provider.failover.recovered data 必须是普通对象",
+    "provider.failover.recovered data.version must be 1": "provider.failover.recovered data.version 必须为 1",
+    "provider.failover.switched data has unsupported fields: {unsupported}": "provider.failover.switched data 包含不支持的字段：{unsupported}",
+    "provider.failover.switched data is missing required field: {key}": "provider.failover.switched data 缺少必需字段：{key}",
+    "provider.failover.switched data must be a plain object": "provider.failover.switched data 必须是普通对象",
+    "provider.failover.switched data.version must be 1": "provider.failover.switched data.version 必须为 1",
+    "resources.discover data has unsupported fields": "resources.discover data 包含不支持的字段",
+    "resources.discover data has unsupported fields: {unsupported}": "resources.discover data 包含不支持的字段：{unsupported}",
+    "resources.discover data is missing required field: {key}": "resources.discover data 缺少必需字段：{key}",
+    "resources.discover data must be a plain object": "resources.discover data 必须是普通对象", // 复用：lifecycle-catalog.ts
+    "resources.discover data.reason is invalid": "resources.discover data.reason 无效", // 复用：lifecycle-catalog.ts
+    "resources.discover data.version must be 1": "resources.discover data.version 必须为 1",
+    "resources.discover data.version must be 2": "resources.discover data.version 必须为 2",
+    "session.auto.retry data has unsupported fields: {unsupported}": "session.auto.retry data 包含不支持的字段：{unsupported}",
+    "session.auto.retry data is missing required field: {key}": "session.auto.retry data 缺少必需字段：{key}",
+    "session.auto.retry data must be a plain object": "session.auto.retry data 必须是普通对象",
+    "session.auto.retry data.version must be 1": "session.auto.retry data.version 必须为 1",
+    "session.compaction.decision data has unsupported fields: {unsupported}": "session.compaction.decision data 包含不支持的字段：{unsupported}",
+    "session.compaction.decision data is missing required field: {key}": "session.compaction.decision data 缺少必需字段：{key}",
+    "session.compaction.decision data must be a plain object": "session.compaction.decision data 必须是普通对象",
+    "session.compaction.decision data.compact must be a boolean": "session.compaction.decision data.compact 必须是布尔值",
+    "session.compaction.decision data.reason is invalid": "session.compaction.decision data.reason 无效",
+    "session.compaction.decision data.version must be 1": "session.compaction.decision data.version 必须为 1",
+    "session.compaction.decision data.willRetry must be a boolean": "session.compaction.decision data.willRetry 必须是布尔值",
+    "session.compaction.failed data has unsupported fields: {unsupported}": "session.compaction.failed data 包含不支持的字段：{unsupported}",
+    "session.compaction.failed data is missing required field: {key}": "session.compaction.failed data 缺少必需字段：{key}",
+    "session.compaction.failed data must be a plain object": "session.compaction.failed data 必须是普通对象",
+    "session.compaction.failed data.reason is invalid": "session.compaction.failed data.reason 无效",
+    "session.compaction.failed data.version must be 1": "session.compaction.failed data.version 必须为 1",
+    "session.context.replaced data has unsupported fields: {unsupported}": "session.context.replaced data 包含不支持的字段：{unsupported}",
+    "session.context.replaced data is missing required field: {key}": "session.context.replaced data 缺少必需字段：{key}",
+    "session.context.replaced data must be a plain object": "session.context.replaced data 必须是普通对象",
+    "session.context.replaced data.messageCount must be a non-negative safe integer": "session.context.replaced data.messageCount 必须是非负安全整数",
+    "session.context.replaced data.reason is invalid": "session.context.replaced data.reason 无效",
+    "session.context.replaced data.version must be 1": "session.context.replaced data.version 必须为 1",
+    "session.end data has unsupported fields": "session.end data 包含不支持的字段",
+    "session.end data must be a plain object": "session.end data 必须是普通对象",
+    "session.end data.version must be 1": "session.end data.version 必须为 1",
+    "session.entry.appended data has unsupported fields": "session.entry.appended data 包含不支持的字段",
+    "session.entry.appended data must be a plain object": "session.entry.appended data 必须是普通对象",
+    "session.entry.appended data.version must be 1": "session.entry.appended data.version 必须为 1",
+    "session.info.changed data has unsupported fields": "session.info.changed data 包含不支持的字段",
+    "session.info.changed data must be a plain object": "session.info.changed data 必须是普通对象",
+    "session.info.changed data.version must be 1": "session.info.changed data.version 必须为 1",
+    "session.reload data has unsupported fields": "session.reload data 包含不支持的字段",
+    "session.reload data must be a plain object": "session.reload data 必须是普通对象",
+    "session.reload data.generation must be a positive safe integer": "session.reload data.generation 必须是正安全整数",
+    "session.reload data.reason is invalid": "session.reload data.reason 无效",
+    "session.reload data.version must be 1": "session.reload data.version 必须为 1",
+    "session.start data has unsupported fields": "session.start data 包含不支持的字段",
+    "session.start data must be a plain object": "session.start data 必须是普通对象",
+    "session.start data.reason is invalid": "session.start data.reason 无效",
+    "session.start data.version must be 1": "session.start data.version 必须为 1",
+    "thinking_level.select data has unsupported fields": "thinking_level.select data 包含不支持的字段",
+    "thinking_level.select data must be a plain object": "thinking_level.select data 必须是普通对象",
+    "thinking_level.select data.version must be 1": "thinking_level.select data.version 必须为 1",
+    "tool.call data has unsupported fields: {unsupported}": "tool.call data 包含不支持的字段：{unsupported}",
+    "tool.call data is missing required field: {key}": "tool.call data 缺少必需字段：{key}",
+    "tool.call data must be a plain object": "tool.call data 必须是普通对象",
+    "tool.call data.revision has unsupported fields": "tool.call data.revision 包含不支持的字段",
+    "tool.call data.revision must be a plain object": "tool.call data.revision 必须是普通对象",
+    "tool.call data.revision.sequence must be a non-negative safe integer": "tool.call data.revision.sequence 必须是非负安全整数",
+    "tool.call data.revision.sessionId must match sessionId": "tool.call data.revision.sessionId 必须与 sessionId 一致",
+    "tool.call data.revision.version must be 1": "tool.call data.revision.version 必须为 1",
+    "tool.call data.version must be 1": "tool.call data.version 必须为 1",
+    "tool.commit data has unsupported fields: {unsupported}": "tool.commit data 包含不支持的字段：{unsupported}",
+    "tool.commit data is missing required field: {key}": "tool.commit data 缺少必需字段：{key}",
+    "tool.commit data must be a plain object": "tool.commit data 必须是普通对象",
+    "tool.commit data.isError must be boolean": "tool.commit data.isError 必须是布尔值",
+    "tool.commit data.revision has unsupported fields": "tool.commit data.revision 包含不支持的字段",
+    "tool.commit data.revision must be a plain object": "tool.commit data.revision 必须是普通对象",
+    "tool.commit data.revision.sequence must be a non-negative safe integer": "tool.commit data.revision.sequence 必须是非负安全整数",
+    "tool.commit data.revision.sessionId must match sessionId": "tool.commit data.revision.sessionId 必须与 sessionId 一致",
+    "tool.commit data.revision.version must be 1": "tool.commit data.revision.version 必须为 1",
+    "tool.commit data.version must be 1": "tool.commit data.version 必须为 1",
+    "tool.execute data has unsupported fields: {unsupported}": "tool.execute data 包含不支持的字段：{unsupported}",
+    "tool.execute data is missing required field: {key}": "tool.execute data 缺少必需字段：{key}",
+    "tool.execute data must be a plain object": "tool.execute data 必须是普通对象",
+    "tool.execute data.isError must be boolean": "tool.execute data.isError 必须是布尔值",
+    "tool.execute data.version must be 1": "tool.execute data.version 必须为 1",
+    "tool.execution.start data has unsupported fields": "tool.execution.start data 包含不支持的字段",
+    "tool.execution.start data must be a plain object": "tool.execution.start data 必须是普通对象",
+    "tool.execution.start data.version must be 1": "tool.execution.start data.version 必须为 1",
+    "tool.gate.blocked data has unsupported fields: {unsupported}": "tool.gate.blocked data 包含不支持的字段：{unsupported}",
+    "tool.gate.blocked data is missing required field: {key}": "tool.gate.blocked data 缺少必需字段：{key}",
+    "tool.gate.blocked data must be a plain object": "tool.gate.blocked data 必须是普通对象",
+    "tool.gate.blocked data.version must be 1": "tool.gate.blocked data.version 必须为 1",
+    "tool.result data has unsupported fields: {unsupported}": "tool.result data 包含不支持的字段：{unsupported}",
+    "tool.result data is missing required field: {key}": "tool.result data 缺少必需字段：{key}",
+    "tool.result data must be a plain object": "tool.result data 必须是普通对象",
+    "tool.result data.isError must be boolean": "tool.result data.isError 必须是布尔值",
+    "tool.result data.message must be a tool result message object": "tool.result data.message 必须是 tool result message 对象",
+    "tool.result data.message.content must be an array": "tool.result data.message.content 必须是数组",
+    "tool.result data.message.isError must be boolean": "tool.result data.message.isError 必须是布尔值",
+    "tool.result data.message.isError must match isError": "tool.result data.message.isError 必须与 isError 一致",
+    "tool.result data.message.role must be toolResult": "tool.result data.message.role 必须是 toolResult",
+    "tool.result data.message.toolCallId must match toolCallId": "tool.result data.message.toolCallId 必须与 toolCallId 一致",
+    "tool.result data.message.toolName must match toolName": "tool.result data.message.toolName 必须与 toolName 一致",
+    "tool.result data.revision has unsupported fields": "tool.result data.revision 包含不支持的字段",
+    "tool.result data.revision must be a plain object": "tool.result data.revision 必须是普通对象",
+    "tool.result data.revision.sequence must be a non-negative safe integer": "tool.result data.revision.sequence 必须是非负安全整数",
+    "tool.result data.revision.sessionId must match sessionId": "tool.result data.revision.sessionId 必须与 sessionId 一致",
+    "tool.result data.revision.version must be 1": "tool.result data.revision.version 必须为 1",
+    "tool.result data.version must be 1": "tool.result data.version 必须为 1",
+    "tool.result.raw data has unsupported fields: {unsupported}": "tool.result.raw data 包含不支持的字段：{unsupported}",
+    "tool.result.raw data is missing required field: {key}": "tool.result.raw data 缺少必需字段：{key}",
+    "tool.result.raw data must be a plain object": "tool.result.raw data 必须是普通对象",
+    "tool.result.raw data.content must be an array": "tool.result.raw data.content 必须是数组",
+    "tool.result.raw data.content[{index}] has unsupported image fields": "tool.result.raw data.content[{index}] 包含不支持的图像字段",
+    "tool.result.raw data.content[{index}] has unsupported text fields": "tool.result.raw data.content[{index}] 包含不支持的文本字段",
+    "tool.result.raw data.content[{index}] must be a plain object": "tool.result.raw data.content[{index}] 必须是普通对象",
+    "tool.result.raw data.content[{index}].type is invalid": "tool.result.raw data.content[{index}].type 无效",
+    "tool.result.raw data.isError must be boolean": "tool.result.raw data.isError 必须是布尔值",
+    "tool.result.raw data.revision has unsupported fields": "tool.result.raw data.revision 包含不支持的字段",
+    "tool.result.raw data.revision must be a plain object": "tool.result.raw data.revision 必须是普通对象",
+    "tool.result.raw data.revision.sequence must be a non-negative safe integer": "tool.result.raw data.revision.sequence 必须是非负安全整数",
+    "tool.result.raw data.revision.sessionId must match sessionId": "tool.result.raw data.revision.sessionId 必须与 sessionId 一致",
+    "tool.result.raw data.revision.version must be 1": "tool.result.raw data.revision.version 必须为 1",
+    "tool.result.raw data.version must be 1": "tool.result.raw data.version 必须为 1",
+    "tool.result.transform data has unsupported fields: {unsupported}": "tool.result.transform data 包含不支持的字段：{unsupported}",
+    "tool.result.transform data is missing required field: {key}": "tool.result.transform data 缺少必需字段：{key}",
+    "tool.result.transform data must be a plain object": "tool.result.transform data 必须是普通对象",
+    "tool.result.transform data.content must be an array": "tool.result.transform data.content 必须是数组",
+    "tool.result.transform data.content[{index}] has unsupported image fields": "tool.result.transform data.content[{index}] 包含不支持的图像字段",
+    "tool.result.transform data.content[{index}] has unsupported text fields": "tool.result.transform data.content[{index}] 包含不支持的文本字段",
+    "tool.result.transform data.content[{index}] must be a plain object": "tool.result.transform data.content[{index}] 必须是普通对象",
+    "tool.result.transform data.content[{index}].type is invalid": "tool.result.transform data.content[{index}].type 无效",
+    "tool.result.transform data.isError must be boolean": "tool.result.transform data.isError 必须是布尔值",
+    "tool.result.transform data.revision has unsupported fields": "tool.result.transform data.revision 包含不支持的字段",
+    "tool.result.transform data.revision must be a plain object": "tool.result.transform data.revision 必须是普通对象",
+    "tool.result.transform data.revision.sequence must be a non-negative safe integer": "tool.result.transform data.revision.sequence 必须是非负安全整数",
+    "tool.result.transform data.revision.sessionId must match sessionId": "tool.result.transform data.revision.sessionId 必须与 sessionId 一致",
+    "tool.result.transform data.revision.version must be 1": "tool.result.transform data.revision.version 必须为 1",
+    "tool.result.transform data.version must be 1": "tool.result.transform data.version 必须为 1",
+    "turn.end data has unsupported fields": "turn.end data 包含不支持的字段",
+    "turn.end data must be a plain object": "turn.end data 必须是普通对象",
+    "turn.end data.messageCount must be a non-negative safe integer": "turn.end data.messageCount 必须是非负安全整数",
+    "turn.end data.outcome is invalid": "turn.end data.outcome 无效",
+    "turn.end data.turnIndex must be a non-negative safe integer": "turn.end data.turnIndex 必须是非负安全整数",
+    "turn.end data.version must be 1": "turn.end data.version 必须为 1",
+    "turn.start data has unsupported fields": "turn.start data 包含不支持的字段",
+    "turn.start data must be a plain object": "turn.start data 必须是普通对象",
+    "turn.start data.turnIndex must be a non-negative safe integer": "turn.start data.turnIndex 必须是非负安全整数",
+    "turn.start data.version must be 1": "turn.start data.version 必须为 1",
+    "ui.prompt lifecycle data has unsupported fields": "ui.prompt lifecycle data 包含不支持的字段",
+    "ui.prompt lifecycle data must be a plain object": "ui.prompt lifecycle data 必须是普通对象",
+    "ui.prompt lifecycle data.version must be 1": "ui.prompt lifecycle data.version 必须为 1",
+    "user.bash data has unsupported fields": "user.bash data 包含不支持的字段",
+    "user.bash data must be a plain object": "user.bash data 必须是普通对象",
+    "user.bash data.excludeFromContext must be a boolean": "user.bash data.excludeFromContext 必须是布尔值",
+    "user.bash data.version must be 1": "user.bash data.version 必须为 1",
+    "{label} must be JSON-safe": "{label} 必须是 JSON 安全值", // 复用：bootstrap-lifecycle.ts, lifecycle-catalog.ts
+    "{label} must be a non-empty string": "{label} 必须是非空字符串", // 复用：bootstrap-lifecycle.ts, capability-runtime-manifest.ts, capability-runtime-validation.ts, lifecycle-catalog.ts
+    "{label} must be a non-negative safe integer": "{label} 必须是非负安全整数", // 复用：capability-runtime-validation.ts, lifecycle-catalog.ts
+    "{label} must be a positive safe integer": "{label} 必须是正安全整数", // 复用：capability-runtime-manifest.ts, lifecycle-catalog.ts
+    "{label} must be a provider/modelId reference": "{label} 必须是 provider/modelId 引用",
+    "{label} must be an array": "{label} 必须是数组", // 复用：capability-runtime-manifest.ts, lifecycle-catalog.ts
+    "{label} must contain only JSON arrays and plain objects": "{label} 只能包含 JSON 数组和普通对象", // 复用：bootstrap-lifecycle.ts, lifecycle-catalog.ts
+    "{label} must contain only finite JSON numbers": "{label} 只能包含有限 JSON 数字", // 复用：bootstrap-lifecycle.ts, lifecycle-catalog.ts
+    "{label} must not contain cycles": "{label} 不得包含循环引用", // 复用：bootstrap-lifecycle.ts, lifecycle-catalog.ts
+    "{label}[{index}] has unsupported fields": "{label}[{index}] 包含不支持的字段",
+    "{label}[{index}] must be a plain object": "{label}[{index}] 必须是普通对象",
+    // ---- 能力运行时契约（capability-runtime.ts） ----
+    "Agent context operationId must match active operation: {operationId}": "Agent context 的 operationId 必须与活动操作一致：{operationId}",
+    "Agent loop hook position is invalid: {value}": "Agent loop hook position 无效：{value}",
+    "Agent loop hook requires a callable handler": "Agent loop hook 需要可调用的 handler",
+    "Agent model runtime is not available": "Agent 模型运行时不可用",
+    "Agent state operationId must match active operation: {operationId}": "Agent state 的 operationId 必须与活动操作一致：{operationId}", // 复用：capability-runtime.ts
+    "Agent task capability is not available from this host": "本宿主不提供 Agent task 能力",
+    "Agent tool is not registered: {name}": "Agent tool 未注册：{name}",
+    "Branch summary policy requires a non-empty name": "分支摘要策略需要非空 name",
+    "Branch summary policy requires a summarize function": "分支摘要策略需要 summarize 函数",
+    "Branch summary policy returned an invalid result: {name}": "分支摘要策略返回了无效结果：{name}",
+    "Capability plugin {id} has asynchronous cleanup; use the async loader": "能力插件 {id} 有异步清理；请使用异步加载器",
+    "Command is not registered: {name}": "命令未注册：{name}",
+    "Compaction policy does not support preparation: {name}": "压缩策略不支持 preparation：{name}",
+    "Compaction policy does not support summaries: {name}": "压缩策略不支持摘要：{name}",
+    "Compaction policy is not registered: {name}": "压缩策略未注册：{name}", // 复用：capability-runtime.ts
+    "Compaction policy requires a decide function": "压缩策略需要 decide 函数",
+    "Compaction policy requires a non-empty name": "压缩策略需要非空 name",
+    "Compaction policy returned an invalid decision: {name}": "压缩策略返回了无效的 decision：{name}",
+    "Compaction policy returned an invalid failureMessage: {name}": "压缩策略返回了无效的 failureMessage：{name}",
+    "Compaction policy returned an invalid retry value: {name}": "压缩策略返回了无效的 retry 值：{name}",
+    "Compaction policy returned an invalid summary: {name}": "压缩策略返回了无效的摘要：{name}",
+    "Context strategy does not support replacement: {name}": "上下文策略不支持替换：{name}",
+    "Context strategy does not support restore: {name}": "上下文策略不支持恢复：{name}",
+    "Context strategy does not support snapshots: {name}": "上下文策略不支持快照：{name}",
+    "Context strategy is not registered: {name}": "上下文策略未注册：{name}", // 复用：capability-runtime.ts
+    "Context strategy requires a non-empty name": "上下文策略需要非空 name",
+    "Contribution can only be removed by its owner: {pointId}@{version}:{id}": "Contribution 只能由其 owner 移除：{pointId}@{version}:{id}",
+    "Contribution is already registered: {pointId}@{version}:{id}": "Contribution 已注册：{pointId}@{version}:{id}",
+    "Contribution is not registered: {pointId}@{version}:{id}": "Contribution 未注册：{pointId}@{version}:{id}",
+    "Contribution point is already defined: {key}": "Contribution point 已定义：{key}",
+    "Contribution requires a non-empty id: {pointId}": "Contribution 需要非空 id：{pointId}",
+    "Contribution subscriber must be callable: {pointId}": "Contribution 订阅者必须可调用：{pointId}",
+    "Diagnostic annotations must be a plain object": "Diagnostic 的 annotations 必须是普通对象",
+    "Diagnostic attributes must be serializable": "Diagnostic 的 attributes 必须可序列化",
+    "Diagnostic parentSpanId must be non-empty": "Diagnostic 的 parentSpanId 必须非空",
+    "Diagnostic span is already ended: {spanId}": "Diagnostic span 已结束：{spanId}", // 复用：capability-runtime.ts
+    "Diagnostic span is not available: {spanId}": "Diagnostic span 不可用：{spanId}", // 复用：capability-runtime.ts
+    "Diagnostic span name must be non-empty": "Diagnostic span 的 name 必须非空",
+    "Diagnostic span result must be serializable": "Diagnostic span 的 result 必须可序列化",
+    "Diagnostic span status is invalid": "Diagnostic span 的 status 无效",
+    "Entry projection requires a callable project": "Entry projection 需要可调用的 project",
+    "Entry projection requires a non-empty customType": "Entry projection 需要非空 customType",
+    "Entry projections require a host with entry projection support": "Entry projections 需要宿主支持条目投影",
+    "Event type requires a non-empty name": "事件类型需要非空 name",
+    "Host declares agent-result-replay-v1 capability without an agentResults option": "宿主声明 agent-result-replay-v1 能力但缺少 agentResults 选项",
+    "Host declares agents capability without a parent SessionAPI": "宿主声明 agents 能力但缺少父级 SessionAPI",
+    "Host declares agents capability without an AgentTaskAdapter or a session reader/lister": "宿主声明 agents 能力但缺少 AgentTaskAdapter 或会话读取/列举器",
+    "Host declares credentials capability without a CredentialAPI": "宿主声明 credentials 能力但缺少 CredentialAPI",
+    "Host declares interaction capability without an InteractionHostV1": "宿主声明 interaction 能力但缺少 InteractionHostV1",
+    "Host declares session capability without a SessionAPI": "宿主声明 session 能力但缺少 SessionAPI",
+    "Host declares session-export capability without SessionAPI.exportArtifact": "宿主声明 session-export 能力但缺少 SessionAPI.exportArtifact",
+    "Host declares session-export capability without the session capability": "宿主声明 session-export 能力但未声明 session 能力",
+    "Host declares session-revision-v1 capability without SessionAPI.getRevision": "宿主声明 session-revision-v1 能力但缺少 SessionAPI.getRevision",
+    "Host declares session-revision-v1 capability without the session capability": "宿主声明 session-revision-v1 能力但未声明 session 能力",
+    "Host declares the agent-result-replay-v1 feature without the agents capability": "宿主声明 agent-result-replay-v1 特性但未声明 agents 能力",
+    "Host provides a CredentialAPI without the credentials capability": "宿主提供了 CredentialAPI 但未声明 credentials 能力",
+    "Host provides a SessionAPI without the session capability": "宿主提供了 SessionAPI 但未声明 session 能力",
+    "Host provides an AgentTaskAdapter without the agents capability": "宿主提供了 AgentTaskAdapter 但未声明 agents 能力",
+    "Host provides an InteractionHostV1 without the interaction capability": "宿主提供了 InteractionHostV1 但未声明 interaction 能力",
+    "Host provides an agentResults option without the agent-result-replay-v1 capability": "宿主提供了 agentResults 选项但未声明 agent-result-replay-v1 能力",
+    "Lifecycle after-commit requires a committed event: {id}": "Lifecycle after-commit 需要 committed 事件：{id}",
+    "Lifecycle delivery options are only supported for observation registrations: {id}": "Lifecycle delivery options 仅支持 observation 注册：{id}",
+    "Lifecycle event is already defined: {key}": "Lifecycle 事件已定义：{key}",
+    "Lifecycle event is not defined: {id}@{version}": "Lifecycle 事件未定义：{id}@{version}",
+    "Lifecycle event is not serializable": "Lifecycle 事件不可序列化",
+    "Lifecycle event reference requires a non-empty id": "Lifecycle 事件引用需要非空 id",
+    "Lifecycle event version must be a positive safe integer": "Lifecycle 事件的 version 必须是正安全整数", // 复用：capability-runtime-validation.ts, capability-runtime.ts
+    "Lifecycle event version must be provided as a positive safe integer": "Lifecycle 事件的 version 必须以正安全整数提供",
+    "Lifecycle execute requires a committed event: {id}": "Lifecycle execute 需要 committed 事件：{id}",
+    "Lifecycle transform requires a candidate event: {id}": "Lifecycle transform 需要 candidate 事件：{id}",
+    "Lifecycle {kind} registration is not allowed: {id}": "不允许 {kind} 注册该 Lifecycle 事件：{id}",
+    "Lifecycle {kind} registration requires a callable handler": "Lifecycle {kind} 注册需要可调用的 handler",
+    "Logger fields must be serializable": "Logger 的 fields 必须可序列化",
+    "Logger message must be non-empty": "Logger 的 message 必须非空",
+    "Operation is not registered: {operation}": "操作未注册：{operation}",
+    "Operation requires a non-empty name": "操作需要非空 name",
+    "Overflow policy is not registered: {name}": "溢出策略未注册：{name}",
+    "Overflow policy requires a decide function": "溢出策略需要 decide 函数",
+    "Overflow policy requires a non-empty name": "溢出策略需要非空 name",
+    "Overflow policy returned an invalid decision: {name}": "溢出策略返回了无效的 decision：{name}",
+    "Plugin capability is already provided: {id}@{version}": "插件能力已被提供：{id}@{version}",
+    "Plugin capability is not available: {id}@{version}": "插件能力不可用：{id}@{version}",
+    "Plugin capability must be declared by its manifest: {id}@{version} ({owner})": "插件能力必须由其 manifest 声明：{id}@{version}（{owner}）",
+    "Plugin capability provider requires a callable handler": "插件能力提供者需要可调用的 handler",
+    "Provider header transform requires a callable transform": "Provider header transform 需要可调用的 transform",
+    "Provider header transform requires a non-empty name": "Provider header transform 需要非空 name",
+    "RPC method is not registered: {name}": "RPC 方法未注册：{name}",
+    "RPC method requires a non-empty name": "RPC 方法需要非空 name",
+    "Retry policy does not support classification: {name}": "重试策略不支持分类：{name}",
+    "Retry policy is not registered: {name}": "重试策略未注册：{name}", // 复用：capability-runtime.ts
+    "Retry policy requires a decide function": "重试策略需要 decide 函数",
+    "Retry policy requires a non-empty name": "重试策略需要非空 name",
+    "Retry policy returned an invalid classification: {name}": "重试策略返回了无效的分类：{name}",
+    "Retry policy returned an invalid decision: {name}": "重试策略返回了无效的 decision：{name}",
+    "Retry policy returned an invalid delayMs: {name}": "重试策略返回了无效的 delayMs：{name}",
+    "Run loop strategy is not registered: {name}": "运行循环策略未注册：{name}",
+    "Run loop strategy requires a decideNextCycle function": "运行循环策略需要 decideNextCycle 函数",
+    "Run loop strategy requires a non-empty name": "运行循环策略需要非空 name",
+    "Run loop strategy returned an invalid decision: {name}": "运行循环策略返回了无效的 decision：{name}",
+    "Runtime idFactory must return a non-empty string for {kind}": "运行时 idFactory 为 {kind} 返回的必须是非空字符串",
+    "Skill definition requires a baseDir": "技能定义需要 baseDir",
+    "Skill definition requires a filePath": "技能定义需要 filePath",
+    "Skill definition requires a non-empty description": "技能定义需要非空 description",
+    "State expectedRevision must be a non-negative safe integer": "State 的 expectedRevision 必须是非负安全整数",
+    "State key must be a non-empty string": "State key 必须是非空字符串",
+    "State prefix must be a string": "State prefix 必须是字符串", // 复用：capability-runtime.ts
+    "State revision conflict: {conflictScope}/{key}": "State revision 冲突：{conflictScope}/{key}", // 复用：capability-runtime.ts
+    "State value must be serializable": "State value 必须可序列化",
+    "State watcher requires a handler": "State watcher 需要 handler",
+    "Stream function wrapper requires a callable wrapper": "Stream function wrapper 需要可调用的 wrapper",
+    "Stream function wrapper requires a non-empty name": "Stream function wrapper 需要非空 name",
+    "Tool is not registered: {name}": "工具未注册：{name}",
+    "{kind} is already registered: {name}": "{kind} 已注册：{name}",
+    // ---- 插件注册校验（capability-runtime-validation.ts） ----
+    "Agent task metadata must be an object": "Agent task metadata 必须是对象",
+    "Agent task requires a non-empty prompt": "Agent task 需要非空 prompt",
+    "Capability command returned an invalid message: {commandName}": "能力命令返回了无效的 message：{commandName}",
+    "Capability command returned an invalid result: {commandName}": "能力命令返回了无效结果：{commandName}",
+    "Capability command returned an invalid status: {commandName}": "能力命令返回了无效的 status：{commandName}",
+    "Capability command returned invalid links: {commandName}": "能力命令返回了无效的 links：{commandName}",
+    "Capability command returned non-serializable data: {commandName}": "能力命令返回了不可序列化的数据：{commandName}",
+    "Command definition argumentHint must be a string": "命令定义的 argumentHint 必须是字符串",
+    "Command definition requires a non-empty description": "命令定义需要非空 description",
+    "Command definition requires a non-empty name without slash or whitespace": "命令定义需要不含斜杠和空白的非空 name",
+    "Command definition requires an execute function": "命令定义需要 execute 函数",
+    "Command requires a definition": "命令需要定义",
+    "Contribution point definition is required": "缺少 contribution point 定义",
+    "Contribution point lifecycle is invalid: {value}": "Contribution point 的 lifecycle 无效：{value}",
+    "Contribution point requires a non-empty id": "Contribution point 需要非空 id",
+    "Contribution point requires a non-empty schema": "Contribution point 需要非空 schema",
+    "Contribution point requires a validate function": "Contribution point 需要 validate 函数",
+    "Contribution point version must be a positive safe integer": "Contribution point 的 version 必须是正安全整数",
+    "Credential minValidityMs must be a non-negative finite number": "Credential 的 minValidityMs 必须是非负有限数字",
+    "Credential resolution requires a non-empty providerId": "凭证解析需要非空 providerId",
+    "Execution facts.inputRevision.sessionId must match Execution facts.sessionId": "Execution facts.inputRevision.sessionId 必须与 Execution facts.sessionId 一致",
+    "Execution facts.phase is invalid": "Execution facts.phase 无效",
+    "Execution facts.version must be 1": "Execution facts.version 必须为 1",
+    "Host capabilities must be an object": "Host capabilities 必须是对象",
+    "Host features must be an array of non-empty strings": "Host features 必须是非空字符串数组",
+    "Host mode must be readonly or full-control": "Host mode 必须是 readonly 或 full-control",
+    "Host transports must be an array of supported transports": "Host transports 必须是受支持的传输数组",
+    "Interaction input defaultValue must be a string": "Interaction input 的 defaultValue 必须是字符串",
+    "Interaction input placeholder must be a string": "Interaction input 的 placeholder 必须是字符串",
+    "Interaction notify level must be info, warning, or error": "Interaction notify 的 level 必须是 info、warning 或 error",
+    "Interaction notify requires a non-empty message": "Interaction notify 需要非空 message",
+    "Interaction request must be an object with a known kind": "Interaction request 必须是带已知 kind 的对象",
+    "Interaction request requires a known kind: notify, confirm, select, or input": "Interaction request 需要已知的 kind：notify、confirm、select 或 input",
+    "Interaction select options must be non-empty strings": "Interaction select 的 options 必须是非空字符串",
+    "Interaction select requires a non-empty options array": "Interaction select 需要非空 options 数组",
+    "Interaction timeoutMs must be a positive integer": "Interaction 的 timeoutMs 必须是正整数",
+    "Lifecycle event allowedPhases must be a non-empty array of valid phases when provided": "Lifecycle 事件的 allowedPhases 提供时必须是非空的有效 phase 数组",
+    "Lifecycle event allowedPhases must include phase": "Lifecycle 事件的 allowedPhases 必须包含 phase",
+    "Lifecycle event allowedPhases must not contain duplicates": "Lifecycle 事件的 allowedPhases 不得包含重复项",
+    "Lifecycle event allowedRegistrationKinds contains an invalid registration kind": "Lifecycle 事件的 allowedRegistrationKinds 包含无效的注册类别",
+    "Lifecycle event allowedRegistrationKinds must be a non-empty array when provided": "Lifecycle 事件的 allowedRegistrationKinds 提供时必须是非空数组",
+    "Lifecycle event allowedRegistrationKinds must not contain duplicates": "Lifecycle 事件的 allowedRegistrationKinds 不得包含重复项",
+    "Lifecycle event definition is required": "缺少 lifecycle 事件定义",
+    "Lifecycle event phase is invalid: {value}": "Lifecycle 事件的 phase 无效：{value}",
+    "Lifecycle event requires a non-empty id": "Lifecycle 事件需要非空 id",
+    "Lifecycle event requires a non-empty schema": "Lifecycle 事件需要非空 schema",
+    "Lifecycle event requires a validate function": "Lifecycle 事件需要 validate 函数",
+    "Provider header transform returned invalid headers: {source}": "Provider header transform 返回了无效 headers：{source}", // 复用：capability-runtime-validation.ts
+    "Retry schedule.action must be retry or stop": "Retry schedule.action 必须是 retry 或 stop",
+    "Retry schedule.retry requires a one-based attempt": "Retry schedule.retry 需要从 1 开始的 attempt",
+    "Retry schedule.stop must have delayMs 0": "Retry schedule.stop 的 delayMs 必须为 0",
+    "Unsupported host API version: {apiVersion}": "不支持的宿主 API 版本：{apiVersion}",
+    "{kind} definition requires a non-empty name": "{kind} 定义需要非空 name",
+    "{kind} requires a callable handler": "{kind} 需要可调用的 handler",
+    "{label} has unsupported fields: {value}": "{label} 包含不支持的字段：{value}",
+    "{label} is missing required fields: {value}": "{label} 缺少必需字段：{value}",
+    "{label} must be a non-negative finite number": "{label} 必须是非负有限数字",
+    "{label} must be a plain object": "{label} 必须是普通对象",
+    "{label}.leafId must be a non-empty string or null": "{label}.leafId 必须是非空字符串或 null",
+    "{label}.leafId must be a string or null": "{label}.leafId 必须是字符串或 null",
+    "{label}.version must be 1": "{label}.version 必须为 1",
+    // ---- 插件 manifest 校验与解析（capability-runtime-manifest.ts） ----
+    "Host is missing required capabilities: {value}": "宿主缺少必需能力：{value}",
+    "Plugin capability dependency cycle: {value}": "插件能力依赖存在循环：{value}",
+    "Plugin capability is provided more than once: {id}@{version} ({priorId}, {manifestId})": "插件能力被提供多次：{id}@{version}（{priorId}、{manifestId}）",
+    "Plugin manifest config must be a JSON object": "Plugin manifest 的 config 必须是 JSON 对象",
+    "Plugin manifest optionalCapabilities must be a string array": "Plugin manifest 的 optionalCapabilities 必须是字符串数组",
+    "Plugin manifest optionalCapabilities must be an array": "Plugin manifest 的 optionalCapabilities 必须是数组",
+    "Plugin manifest requiredCapabilities must be a string array": "Plugin manifest 的 requiredCapabilities 必须是字符串数组",
+    "Plugin manifest requiredCapabilities must be an array": "Plugin manifest 的 requiredCapabilities 必须是数组",
+    "Plugin manifest requires id, version, and entry": "Plugin manifest 需要 id、version 和 entry",
+    "Unsupported plugin API version: {apiVersion}": "不支持的插件 API 版本：{apiVersion}",
+    "{label} declares capability more than once: {id}@{version}": "{label} 多次声明同一能力：{id}@{version}",
+    "{label} has an invalid declaration": "{label} 包含无效声明",
+    "{label} has an invalid requirement": "{label} 包含无效的依赖声明",
+    "{label} requires capability more than once: {id}@{version}": "{label} 多次依赖同一能力：{id}@{version}",
+    "{label}.agents declares definition more than once: {id}@{version}": "{label}.agents 多次声明同一定义：{id}@{version}",
+    "{label}.agents has an invalid declaration": "{label}.agents 包含无效声明",
+    "{label}.agents must be an array": "{label}.agents 必须是数组",
+    "{label}.agents.entry must be a non-empty string": "{label}.agents.entry 必须是非空字符串",
+    "{label}.agents.role is invalid": "{label}.agents.role 无效",
+    "{label}.agents.role is not declared in roles": "{label}.agents.role 未在 roles 中声明",
+    "{label}.kind is invalid": "{label}.kind 无效",
+    "{label}.optional must be a boolean": "{label}.optional 必须是布尔值",
+    "{label}.roles contains an invalid role": "{label}.roles 包含无效 role",
+    "{label}.roles declares role more than once: {role}": "{label}.roles 多次声明同一 role：{role}",
+    "{label}.roles must be an array": "{label}.roles 必须是数组",
+    // ---- 宿主能力门卫（capability-runtime-guards.ts） ----
+    "Agent composition runtime does not support owner-scoped host primitives": "Agent 组合运行时不支持 owner 作用域的宿主原语",
+    "Agent definition must be declared by plugin manifest: {id}@{version}": "Agent 定义必须由 plugin manifest 声明：{id}@{version}",
+    "Agent definition owner must match plugin manifest: {id}": "Agent definition owner 必须与 plugin manifest 一致：{id}",
+    "Agent task can only run once: {id}": "Agent task 只能运行一次：{id}",
+    "Agent task failed and its result could not be persisted": "Agent task 失败且其结果无法持久化",
+    "Agent task handle is disposed: {id}": "Agent task 句柄已销毁：{id}",
+    "Agent task has not been started: {id}": "Agent task 尚未启动：{id}",
+    "Agent task was cancelled and its result could not be persisted": "Agent task 已取消且其结果无法持久化",
+    "Interaction prompt outcome answered requires a boolean or string value": "Interaction prompt outcome 的 answered 需要布尔或字符串值",
+    "Interaction prompt outcome delivered is only valid for notify requests": "Interaction prompt outcome 的 delivered 仅对 notify 请求有效",
+    "Interaction prompt outcome has an unknown status: {value}": "Interaction prompt outcome 的 status 未知：{value}",
+    "Interaction prompt outcome has unsupported fields: {value}": "Interaction prompt outcome 包含不支持的字段：{value}",
+    "Interaction prompt outcome must be an object": "Interaction prompt outcome 必须是对象",
+    "Interaction prompt outcome timeout can only be produced by options.timeoutMs, never by the host": "Interaction prompt outcome 的 timeout 只能由 options.timeoutMs 产生，宿主不得产生",
+    "Parent Agent instance must belong to plugin manifest: {parentInstanceId}": "父 Agent 实例必须属于该 plugin manifest：{parentInstanceId}",
+    // ---- lifecycle 分发（capability-runtime-events.ts） ----
+    "Lifecycle causationId must be non-empty": "Lifecycle 的 causationId 必须非空",
+    "Lifecycle correlationId must be non-empty": "Lifecycle 的 correlationId 必须非空",
+    "Lifecycle dispatch phase does not match event definition: {type}@{version}": "Lifecycle 分发 phase 与事件定义不一致：{type}@{version}",
+    "Lifecycle dispatch phase is invalid: {phase}": "Lifecycle 分发 phase 无效：{phase}",
+    "Lifecycle dispatch request is required": "缺少 Lifecycle 分发请求",
+    "Lifecycle dispatch requires a non-empty type": "Lifecycle 分发需要非空 type",
+    "Lifecycle dispatch version must be a positive safe integer": "Lifecycle 分发的 version 必须是正安全整数",
+    "Lifecycle event is not defined: {type}@{version}": "Lifecycle 事件未定义：{type}@{version}",
+    "Lifecycle operationId must be non-empty": "Lifecycle 的 operationId 必须非空",
+    "Lifecycle source must be non-empty": "Lifecycle 的 source 必须非空",
+    "Operation progress data must be serializable": "操作进度数据必须可序列化",
+    "Operation progress message must be a non-empty string": "操作进度 message 必须是非空字符串",
+    "Operation progress must be an object": "操作进度必须是对象",
+    // ---- Agent 组合运行时（agent-composition.ts） ----
+    "Agent controller lease is not valid for instance: {id}": "Agent controller lease 对该实例无效：{id}",
+    "Agent definition already registered: {id}@{version}": "Agent 定义已注册：{id}@{version}",
+    "Agent definition is required": "缺少 Agent 定义",
+    "Agent definition or reference is required": "缺少 Agent 定义或引用",
+    "Agent definition owner must be a non-empty string when provided": "Agent definition owner 提供时必须是非空字符串",
+    "Agent definition requires a non-empty id": "Agent 定义需要非空 id",
+    "Agent definition requires a run function": "Agent 定义需要 run 函数",
+    "Agent definition role must be root-agent-controller or child-agent-controller": "Agent definition role 必须是 root-agent-controller 或 child-agent-controller",
+    "Agent definition version must be a positive safe integer": "Agent definition version 必须是正安全整数",
+    "Agent host operation does not match active operation: {id}": "Agent 宿主操作与活动操作不一致：{id}",
+    "Agent instance already has an active controller lease: {id}": "Agent 实例已有活动的 controller lease：{id}",
+    "Agent instance cannot run from status {statusValue}: {id}": "Agent 实例无法从状态 {statusValue} 启动：{id}",
+    "Agent instance id already exists: {id}": "Agent 实例 id 已存在：{id}", // 复用：agent-composition.ts
+    "Agent instance is disposed: {id}": "Agent 实例已销毁：{id}",
+    "Agent instance requires an active controller lease: {id}": "Agent 实例需要活动的 controller lease：{id}",
+    "Unknown Agent definition: {id}@{version}": "未知 Agent 定义：{id}@{version}",
+    "Unknown parent Agent instance: {parentInstanceId}": "未知父 Agent 实例：{parentInstanceId}",
+    "Unsupported Agent host primitives version": "不支持的 Agent 宿主原语版本",
+    // ---- 引导：lifecycle 插件（bootstrap-lifecycle.ts） ----
+    "session.compaction.commit data has unsupported fields: {unsupported}": "session.compaction.commit data 包含不支持的字段：{unsupported}",
+    "session.compaction.commit data is missing required field: {key}": "session.compaction.commit data 缺少必需字段：{key}",
+    "session.compaction.commit data must be a plain object": "session.compaction.commit data 必须是普通对象",
+    "session.compaction.commit data.fromHook must be boolean": "session.compaction.commit data.fromHook 必须是布尔值",
+    "session.compaction.commit data.reason is invalid": "session.compaction.commit data.reason 无效",
+    "session.compaction.commit data.status is invalid": "session.compaction.commit data.status 无效",
+    "session.compaction.commit data.tokensBefore must be a non-negative finite number": "session.compaction.commit data.tokensBefore 必须是非负有限数字",
+    "session.compaction.commit data.version must be 1": "session.compaction.commit data.version 必须为 1",
+    "session.compaction.commit.revision has unsupported fields": "session.compaction.commit.revision 包含不支持的字段",
+    "session.compaction.commit.revision must be a plain object": "session.compaction.commit.revision 必须是普通对象",
+    "session.compaction.commit.revision.sequence must be a non-negative safe integer": "session.compaction.commit.revision.sequence 必须是非负安全整数",
+    "session.compaction.commit.revision.version must be 1": "session.compaction.commit.revision.version 必须为 1",
+    // ---- 引导：主循环（bootstrap-agent-loop.ts） ----
+    "tool.call transform cannot change call identity or revision": "tool.call transform 不得更改调用标识或 revision",
+    "tool.result.transform transform cannot change result identity or revision": "tool.result.transform transform 不得更改结果标识或 revision",
+    // ---- 引导：技能（bootstrap-skills.ts） ----
+    "Bootstrap skills plugin is already installed": "引导技能插件已安装",
+    "Bootstrap skills plugin is not installed": "引导技能插件未安装",
+    "Skill conflicts in contribution point: {name}": "技能与 contribution point 冲突：{name}", // 复用：bootstrap-skills.ts
+    "SkillDefinitionV1 validation failed": "SkillDefinitionV1 校验失败", // 复用：bootstrap-skills.ts
+    // ---- 引导：溢出策略（bootstrap-overflow-policy.ts） ----
+    "Overflow policy requires an assistant message object": "溢出策略需要 assistant message 对象",
+    // ---- 引导：重试策略（bootstrap-retry-policy.ts） ----
+    "Retry classification requires an assistant message object": "重试分类需要 assistant message 对象",
+    // ---- 引导：基础工具（bootstrap-tools.ts） ----
+    "Readonly mode does not allow base tool overrides": "readonly 模式不允许覆盖基础工具",
+    // ---- 能力插件装载（capability-plugin.ts） ----
+    "Capability plugin entry must default-export a factory function: {entryPath}": "能力插件入口必须 default 导出工厂函数：{entryPath}",
+    "Capability plugin factory must return void or an instance with dispose(): {id}": "能力插件工厂必须返回 void 或带 dispose() 的实例：{id}",
+    "Capability plugin is already loaded: {id}": "能力插件已加载：{id}", // 复用：capability-plugin.ts
+    "Synchronous capability plugin factory must return void or an instance with dispose(): {id}": "同步能力插件工厂必须返回 void 或带 dispose() 的实例：{id}",
+    // ---- 压缩内存失败模式（compaction-memory-failure-mode.ts） ----
+    "Compaction memory failure mode declaration requires a profileId": "压缩内存失败模式声明需要 profileId",
+    "Invalid compaction memory failure mode: {value}": "无效的压缩内存失败模式：{value}",
+    // ---- 上下文策略绑定（context-strategy-binding.ts） ----
+    "Context strategy must return an AgentMessage array: {strategyName}": "上下文策略必须返回 AgentMessage 数组：{strategyName}",
+    "Context strategy returned a non-cloneable request context: {name}": "上下文策略返回了不可克隆的请求上下文：{name}",
+    // ---- lifecycle 投递队列（lifecycle-delivery-queue.ts） ----
+    "Lifecycle delivery queue overflowCode must be non-empty": "Lifecycle 投递队列的 overflowCode 必须非空",
+    "Lifecycle delivery queue {label} must be a positive safe integer": "Lifecycle 投递队列的 {label} 必须是正安全整数",
+};
+//# sourceMappingURL=core-contract-extensions.js.map