@sakanano-moe/agenthelm 6.7.0 → 6.11.0-rc.1

package/runtime/plugins/opinion-manager/runtime/lifecycle.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from typing import Any
 
 import versioned
+from i18n_opinion import _  # noqa: E402
 
 
 DEFAULT_ROOTS = ("tasks", "cases", "reviews", "projects", "journal")
@@ -33,9 +34,9 @@ def fail(message: str) -> None:
 def confined(root: Path, relative: str | Path) -> Path:
     path = root / relative
     if Path(relative).is_absolute() or ".." in Path(relative).parts:
-        fail("路径必须是项目内的相对路径")
+        fail(_("路径必须是项目内的相对路径"))
     if any(item.is_symlink() for item in (path, *path.parents) if item != root.parent):
-        fail("拒绝使用符号链接")
+        fail(_("拒绝使用符号链接"))
     path.resolve().relative_to(root.resolve())
     return path
 
@@ -44,14 +45,14 @@ def current_lock(root: Path) -> dict[str, Any]:
     try:
         versioned.verify_project(root)
     except (versioned.OpinionVersionError, OSError, json.JSONDecodeError) as exc:
-        raise LifecycleError(f"当前 Opinion 必须先通过 verify：{exc}") from exc
+        raise LifecycleError(_("当前 Opinion 必须先通过 verify：{0}").format(exc)) from exc
     return versioned.read_object(root / "opinion.lock.json")
 
 
 def occurrence(path: str, roots: tuple[str, ...]) -> str:
     parts = Path(path).parts
     if len(parts) < 2 or parts[0] not in roots:
-        fail(f"occurrence 必须指向项目内的工作记录，根目录为：{'、'.join(roots)}")
+        fail(_("occurrence 必须指向项目内的工作记录，根目录为：{0}").format(_('、').join(roots)))
     return "/".join(parts[:2])
 
 
@@ -88,28 +89,28 @@ def record_use(event: dict[str, Any], lock: dict[str, Any], roots: tuple[str, ..
     profile = lock["profile"]
     known = {source["ref"] for source in profile["sources"]["rules"]}
     if not event.get("rules") or not set(event["rules"]) <= known:
-        fail("use 必须记录适用规则的精确引用")
+        fail(_("use 必须记录适用规则的精确引用"))
     use = {key: event[key] for key in ("evidence", "evidence_sha256", "rules", "passed", "user_changed")}
     if type(use["passed"]) is not bool or type(use["user_changed"]) is not bool:
-        fail("passed 与 user_changed 必须是明确的布尔值")
+        fail(_("passed 与 user_changed 必须是明确的布尔值"))
     results = event.get("results")
     if results is not None:
         if not isinstance(results, dict) or set(results) != set(event["rules"]) or not set(results.values()) <= set(RESULTS):
-            fail(f"results 必须为每条规则给出结果：{'、'.join(RESULTS)}")
+            fail(_("results 必须为每条规则给出结果：{0}").format(_('、').join(RESULTS)))
         if use["passed"] and "violated" in results.values():
-            fail("存在违反的规则时 passed 不能为 true")
+            fail(_("存在违反的规则时 passed 不能为 true"))
         use["results"] = results
     bundles = {bundle["family"] for bundle in profile["loading"]["bundles"]} if "loading" in profile else None
     for key in ("loaded_bundles", "routing_miss"):
         if key in event:
             if bundles is None:
-                fail(f"当前 Profile 未声明分层加载，不能记录 {key}")
+                fail(_("当前 Profile 未声明分层加载，不能记录 {0}").format(key))
             if not isinstance(event[key], list) or not set(event[key]) <= bundles or len(event[key]) != len(set(event[key])):
-                fail(f"{key} 必须是已声明规则束的不重复列表")
+                fail(_("{0} 必须是已声明规则束的不重复列表").format(key))
             use[key] = event[key]
     if "date" in event:
         if not isinstance(event["date"], str) or not DATE.fullmatch(event["date"]):
-            fail("date 必须为 YYYY-MM-DD")
+            fail(_("date 必须为 YYYY-MM-DD"))
         use["date"] = event["date"]
     use.update(occurrence=occurrence(event["occurrence"], roots), fixture=bool(event.get("fixture")))
     return use
@@ -124,16 +125,16 @@ def reduce(state: dict[str, Any], event: dict[str, Any], lock: dict[str, Any] |
     kind = event["kind"]
     receipt = {key: event[key] for key in ("evidence", "evidence_sha256", "evidence_origin") if key in event}
     if "fixture" in event and type(event["fixture"]) is not bool:
-        fail("fixture 必须是明确的布尔值")
+        fail(_("fixture 必须是明确的布尔值"))
     if kind == "capture":
         identity, content = event["id"], event["content"]
         if not all(isinstance(content.get(key), str) and content[key].strip() for key in ("title", "text")):
-            fail("候选需要完整的 title 与 text")
+            fail(_("候选需要完整的 title 与 text"))
         if not content.get("scopes") or not all(isinstance(item, str) and item.strip() for item in content["scopes"]):
-            fail("候选需要明确的 scopes")
+            fail(_("候选需要明确的 scopes"))
         if identity in result["candidates"]:
             if result["candidates"][identity]["content"] != content:
-                fail("候选内容变化时必须使用新的候选编号")
+                fail(_("候选内容变化时必须使用新的候选编号"))
         else:
             result["candidates"][identity] = {"id": identity, "content": content, "capture_evidence": receipt,
                                               "evidence": [], "presentations": [], "credit": 0.0, "decision": None}
@@ -143,7 +144,7 @@ def reduce(state: dict[str, Any], event: dict[str, Any], lock: dict[str, Any] |
         before = {item["occurrence"] for item in candidate["evidence"] if not item.get("fixture")}
         evidence = {key: event[key] for key in ("evidence", "evidence_sha256", "validation")}
         if evidence["validation"] not in ("pending", "passed", "failed"):
-            fail("validation 必须为 pending、passed 或 failed")
+            fail(_("validation 必须为 pending、passed 或 failed"))
         evidence.update(occurrence=group, fixture=bool(event.get("fixture")))
         candidate["evidence"].append(evidence)
         if not evidence["fixture"] and group not in before:
@@ -152,15 +153,15 @@ def reduce(state: dict[str, Any], event: dict[str, Any], lock: dict[str, Any] |
     elif kind == "presented":
         candidate = result["candidates"][event["id"]]
         if event["content_sha256"] != versioned.digest(candidate["content"]):
-            fail("展示的内容与候选不一致")
+            fail(_("展示的内容与候选不一致"))
         candidate["credit"] = max(0.0, candidate["credit"] - 1)
         candidate.setdefault("presentations", []).append(receipt)
     elif kind == "decision":
         candidate = result["candidates"][event["id"]]
         if event["content_sha256"] != versioned.digest(candidate["content"]):
-            fail("人工裁决指向的候选内容不一致")
+            fail(_("人工裁决指向的候选内容不一致"))
         if event["decision"] not in ("accepted", "rejected", "held") or event.get("human_confirmed") is not True:
-            fail("需要明确的人工裁决")
+            fail(_("需要明确的人工裁决"))
         candidate["decision"] = event["decision"]
         candidate["decision_evidence"] = event["evidence"]
         candidate["decision_receipt"] = receipt
@@ -168,16 +169,16 @@ def reduce(state: dict[str, Any], event: dict[str, Any], lock: dict[str, Any] |
     elif kind == "adopt":
         ref = profile_ref(lock["profile"])
         if event.get("human_confirmed") is not True or event["profile_sha256"] != lock["profile_sha256"]:
-            fail("采用需要人工批准当前精确的 Profile")
+            fail(_("采用需要人工批准当前精确的 Profile"))
         if ref in result["rollouts"] and result["rollouts"][ref]["profile_sha256"] != lock["profile_sha256"]:
-            fail("不可变的 Profile 身份发生了变化")
+            fail(_("不可变的 Profile 身份发生了变化"))
         result["rollouts"].setdefault(ref, {"state": "gray", "profile_sha256": lock["profile_sha256"],
                                            "opinion_sha256": lock["opinion_sha256"], "approval_evidence": event["evidence"],
                                            "approval_receipt": receipt, "uses": [], "blockers": []})
     elif kind == "use":
         rollout = result["rollouts"][profile_ref(lock["profile"])]
         if rollout["profile_sha256"] != lock["profile_sha256"] or rollout["opinion_sha256"] != lock["opinion_sha256"]:
-            fail("use 指向的 Opinion 内容已经变化")
+            fail(_("use 指向的 Opinion 内容已经变化"))
         use = record_use(event, lock, roots)
         rollout["uses"].append(use)
         if not use["fixture"] and (not use["passed"] or use["user_changed"] or use.get("routing_miss")):
@@ -185,16 +186,16 @@ def reduce(state: dict[str, Any], event: dict[str, Any], lock: dict[str, Any] |
     elif kind == "formalize":
         rollout = result["rollouts"][profile_ref(lock["profile"])]
         if event.get("human_confirmed") is not True or event["profile_sha256"] != lock["profile_sha256"]:
-            fail("复盘必须确认未变化的当前 Profile")
+            fail(_("复盘必须确认未变化的当前 Profile"))
         if rollout["profile_sha256"] != lock["profile_sha256"] or rollout["opinion_sha256"] != lock["opinion_sha256"]:
-            fail("灰度内容已经变化；请采用新的已核验版本")
+            fail(_("灰度内容已经变化；请采用新的已核验版本"))
         if rollout["blockers"]:
-            fail("转正式前先在新版本中解决灰度失败")
+            fail(_("转正式前先在新版本中解决灰度失败"))
         rollout["state"] = "formal"
         rollout["review_evidence"] = event["evidence"]
         rollout["review_receipt"] = receipt
     else:
-        fail("未知的生命周期事件")
+        fail(_("未知的生命周期事件"))
     result["events"].append(event_hash)
     return result
 
@@ -210,7 +211,7 @@ def evidence_valid(root: Path, state: dict[str, Any]) -> None:
         receipts.extend(rollout[key] for key in ("approval_receipt", "review_receipt") if rollout.get(key))
     for item in receipts:
         if hashlib.sha256(confined(root, item["evidence"]).read_bytes()).hexdigest() != item["evidence_sha256"]:
-            fail("不可变的生命周期证据发生变化；修改状态前先重新核验")
+            fail(_("不可变的生命周期证据发生变化；修改状态前先重新核验"))
 
 
 def successful(use: dict[str, Any]) -> bool:
@@ -230,10 +231,10 @@ def carried_uses(state: dict[str, Any], profile: dict[str, Any], profiles_root:
         try:
             previous = versioned.load_profile(path)
         except (versioned.OpinionVersionError, OSError, json.JSONDecodeError):
-            skipped.append({"profile": ref, "reason": "找不到可核验的旧 Profile"})
+            skipped.append({"profile": ref, "reason": _("找不到可核验的旧 Profile")})
             continue
         if versioned.digest(previous) != rollout["profile_sha256"]:
-            skipped.append({"profile": ref, "reason": "旧 Profile 与灰度记录的指纹不一致"})
+            skipped.append({"profile": ref, "reason": _("旧 Profile 与灰度记录的指纹不一致")})
             continue
         before = rule_fingerprints(previous)
         for use in rollout["uses"]:
@@ -301,16 +302,16 @@ def status_view(state: dict[str, Any], root: Path, profiles_root: Path) -> dict[
 
 
 def add_command(subparsers: Any) -> None:
-    parser = subparsers.add_parser("lifecycle", help="项目私有的候选、灰度与使用记录；不发布规则")
+    parser = subparsers.add_parser("lifecycle", help=_("项目私有的候选、灰度与使用记录；不发布规则"))
     parser.add_argument("action", choices=("queue", "status", "event"))
     parser.add_argument("--project", type=Path, required=True)
-    parser.add_argument("--store", required=True, help="项目内保存状态与证据快照的相对目录")
-    parser.add_argument("--file", type=Path, help="event 的事件 JSON，必须位于项目内")
-    parser.add_argument("--profiles-root", help="保存历史 Profile 的项目内相对目录，默认 .opinion/profiles")
-    parser.add_argument("--occurrence-root", action="append", default=[], help="允许作为独立发生场景的顶层目录，可重复")
-    parser.add_argument("--titles", action="store_true", help="queue 只输出未裁决候选的标题与适用范围")
+    parser.add_argument("--store", required=True, help=_("项目内保存状态与证据快照的相对目录"))
+    parser.add_argument("--file", type=Path, help=_("event 的事件 JSON，必须位于项目内"))
+    parser.add_argument("--profiles-root", help=_("保存历史 Profile 的项目内相对目录，默认 .opinion/profiles"))
+    parser.add_argument("--occurrence-root", action="append", default=[], help=_("允许作为独立发生场景的顶层目录，可重复"))
+    parser.add_argument("--titles", action="store_true", help=_("queue 只输出未裁决候选的标题与适用范围"))
     parser.add_argument("--apply", action="store_true")
-    parser.add_argument("--confirm", help="预览返回的 confirmation_sha256")
+    parser.add_argument("--confirm", help=_("预览返回的 confirmation_sha256"))
     parser.add_argument("--output", choices=("json",), default="json")
 
 
@@ -325,7 +326,7 @@ def run(args: argparse.Namespace) -> dict[str, Any]:
     evidence_valid(root, state)
     if args.action in ("queue", "status"):
         if args.apply:
-            fail("只读命令不能使用 --apply")
+            fail(_("只读命令不能使用 --apply"))
         if args.action == "status":
             return status_view(state, root, profiles_root)
         views = sorted((candidate_view(item) for item in state["candidates"].values()), key=lambda item: (-item["priority"], item["id"]))
@@ -335,14 +336,14 @@ def run(args: argparse.Namespace) -> dict[str, Any]:
                      for item in views if item["status"] not in ("accepted", "rejected", "held")]
         return {"ok": True, "status": "read-only", "value": views}
     if not args.file:
-        fail("event 需要 --file")
+        fail(_("event 需要 --file"))
     event_path = confined(root, os.path.relpath(args.file.resolve(), root))
     event = json.loads(event_path.read_text(encoding="utf-8"))
     source = confined(root, event["evidence"])
     source_bytes = source.read_bytes()
     source_hash = hashlib.sha256(source_bytes).hexdigest()
     if event.get("evidence_sha256") and event["evidence_sha256"] != source_hash:
-        fail("事件证据已经变化")
+        fail(_("事件证据已经变化"))
     event["evidence_sha256"] = source_hash
     event["evidence_origin"] = event["evidence"]
     snapshot = store / "evidence" / f"{source_hash}.blob"
@@ -352,22 +353,22 @@ def run(args: argparse.Namespace) -> dict[str, Any]:
     fingerprint = versioned.digest({"before": state, "after": after, "event": event})
     if args.apply:
         if args.confirm != fingerprint:
-            fail("确认指纹不一致")
+            fail(_("确认指纹不一致"))
         store.mkdir(parents=True, exist_ok=True)
         with (store / ".lifecycle.lock").open("a") as guard:
             fcntl.flock(guard, fcntl.LOCK_EX)
             live = state_path.read_text(encoding="utf-8") if state_path.exists() else None
             if live != raw:
-                fail("状态已经变化；请重新生成预览")
+                fail(_("状态已经变化；请重新生成预览"))
             evidence_valid(root, state)
             if lock is not None and current_lock(root) != lock:
-                fail("Opinion 在写入期间发生变化；请重新生成预览")
+                fail(_("Opinion 在写入期间发生变化；请重新生成预览"))
             if hashlib.sha256(source.read_bytes()).hexdigest() != source_hash:
-                fail("证据在预览后发生变化")
+                fail(_("证据在预览后发生变化"))
             snapshot.parent.mkdir(parents=True, exist_ok=True)
             if snapshot.exists():
                 if snapshot.read_bytes() != source_bytes:
-                    fail("不可变的证据快照被改动")
+                    fail(_("不可变的证据快照被改动"))
             else:
                 with snapshot.open("xb") as handle:
                     handle.write(source_bytes)

package/runtime/plugins/opinion-manager/runtime/locale/en.json

@@ -0,0 +1,184 @@
+{
+ "拒绝使用符号链接：{0}": "Refusing to use a symbolic link: {0}",
+ "必须使用普通文件：{0}": "A regular file is required: {0}",
+ "JSON 根节点必须是对象：{0}": "The JSON root must be an object: {0}",
+ "{0} 字段必须为：{1}": "{0} must have exactly these fields: {1}",
+ "{0} 必须是非空字符串": "{0} must be a non-empty string",
+ "编号无效：{0!r}": "Invalid id: {0!r}",
+ "版本必须是无前导零的三段数字：{0!r}": "The version must be three numeric parts without leading zeros: {0!r}",
+ "{0} 必须是字符串数组": "{0} must be an array of strings",
+ "{0} 包含重复项": "{0} contains duplicates",
+ "{0} 必须精确指定 @VERSION：{1!r}": "{0} must name an exact @VERSION: {1!r}",
+ "{0} 引用格式无效：{1}": "{0} reference has an invalid format: {1}",
+ "规则内容": "rule content",
+ "level 必须为 required 或 preferred": "level must be required or preferred",
+ "发布内容必须是对象": "The published content must be an object",
+ "发布内容": "published content",
+ "目录不存在：{0}": "Directory does not exist: {0}",
+ "发布文件路径与身份不一致：{0}": "The published file path does not match its identity: {0}",
+ "同一模板系列只能选择一个变体和版本：{0}": "A template family can have only one variant and version selected: {0}",
+ "未知模板：{0}": "Unknown template: {0}",
+ "未知规则：{0}": "Unknown rule: {0}",
+ "规则选择了不同版本：{0}": "The rule was selected in different versions: {0}",
+ "规则 slot 冲突：{0}（{1}、{2}）": "Rule slot conflict: {0} ({1}, {2})",
+ "loading.signals 必须是非空对象": "loading.signals must be a non-empty object",
+ "loading.bundles 至少包含一个按需规则束": "loading.bundles needs at least one on-demand rule bundle",
+ "loading.core 引用了未选择的模板系列：{0}": "loading.core refers to a template family that is not selected: {0}",
+ "loading.bundles 项": "loading.bundles entry",
+ "loading.bundles 引用了未选择的模板系列：{0!r}": "loading.bundles refers to a template family that is not selected: {0!r}",
+ "模板系列在 loading 中重复出现：{0}": "The template family appears more than once in loading: {0}",
+ "规则束至少需要一条路由：{0}": "A rule bundle needs at least one route: {0}",
+ "路由必须是非空对象：{0}": "A route must be a non-empty object: {0}",
+ "路由使用了未声明的信号：{0}.{1}": "A route uses an undeclared signal: {0}.{1}",
+ "Profile schema_version 必须为 2.0 或 2.1": "Profile schema_version must be 2.0 or 2.1",
+ "sources 项必须是数组": "sources entries must be an array",
+ "source 类型不一致": "source types are inconsistent",
+ "source 指纹或引用不一致：{0}": "source fingerprint or reference is inconsistent: {0}",
+ "重复 source：{0}": "Duplicate source: {0}",
+ "Profile 引用与 sources 不一致": "The Profile references do not match sources",
+ "overrides 必须是对象": "overrides must be an object",
+ "override 必须使用匹配编号的完整规则": "An override must use a complete rule with the matching id",
+ "停用规则不存在：{0}": "The disabled rule does not exist: {0}",
+ "derived_from 指纹无效": "The derived_from fingerprint is invalid",
+ "Profile 至少需要一条有效规则或自定义内容": "A Profile needs at least one effective rule or custom content",
+ "同一次选择包含重复身份：{0}": "The same selection contains a duplicate identity: {0}",
+ "已经发布的版本不可修改：{0}": "A published version cannot be modified: {0}",
+ "写入后核对失败：{0}": "Verification after writing failed: {0}",
+ "请先审阅预览，再使用 --confirm {0} --apply": "Review the preview first, then use --confirm {0} --apply",
+ "项目目录不存在：{0}": "Project directory does not exist: {0}",
+ "修订 Profile 必须增加版本；私有派生必须使用独立编号": "A revised Profile must increase the version; a private derivation must use its own id",
+ "无法移除未选择的模板系列：{0}": "Cannot remove a template family that is not selected: {0}",
+ "无法移除未直接选择的规则：{0}": "Cannot remove a rule that was not selected directly: {0}",
+ "已经发布的来源内容发生变化：{0}": "The published source content has changed: {0}",
+ "--loading-file 与 --remove-loading 不能同时使用": "--loading-file and --remove-loading cannot be used together",
+ "resolutions 包含没有冲突的编号": "resolutions contains an id that has no conflict",
+ "冲突处理必须为 keep-local 或 use-upstream": "A conflict resolution must be keep-local or use-upstream",
+ "override 引用未知规则：{0}": "An override refers to an unknown rule: {0}",
+ "升级存在未确认的冲突：{0}": "The upgrade has unresolved conflicts: {0}",
+ "patch 版本只允许不改变行为的修改": "A patch version may only contain changes that do not alter behavior",
+ "patch 版本不能改变适用范围": "A patch version cannot change the scope",
+ "patch 版本不能改变有效规则": "A patch version cannot change the effective rules",
+ "公开内容需要用户批准完整文件，并使用 --public-approved": "Public content needs the user's approval of the complete file and --public-approved",
+ "锁定文件版本不受支持": "The lock file version is not supported",
+ "锁定文件指纹与内容不一致": "The lock file fingerprint does not match the content",
+ "--profile 必须独立使用；通过 profile 命令修改选择和自定义内容": "--profile must be used on its own; change selections and custom content through the profile command",
+ "已经锁定的 Profile 版本不可改变内容；请发布新的 Profile 版本": "The content of a locked Profile version cannot change; publish a new Profile version",
+ "正文缺失；请先使用原锁定 Profile 重建正文，再进行升级": "The body is missing; rebuild it from the originally locked Profile before upgrading",
+ "OPINION.md 已被人工修改；请读取并纳入新的 Profile，审阅后用 --accept-current 当前文件SHA256 确认": "OPINION.md was edited by hand; read it and fold it into the new Profile, then confirm with --accept-current <SHA-256 of the current file> after review",
+ "已有 OPINION.md 需要审阅并使用 --replace": "An existing OPINION.md must be reviewed and replaced with --replace",
+ "OPINION.md 与锁定文件不一致；请读取人工修改或检查中断的写入": "OPINION.md does not match the lock file; read the manual edits or check for an interrupted write",
+ "预览返回的完整内容 SHA-256": "SHA-256 of the full content returned by the preview",
+ "人工修改或写入中断后的当前 OPINION.md SHA-256；读取并保留内容后使用": "SHA-256 of the current OPINION.md after a manual edit or an interrupted write; use it after reading and keeping the content",
+ "预览、派生和发布不可变的个人 Profile": "Preview, derive and publish an immutable personal Profile",
+ "完整的分层加载声明 JSON；整体替换原声明": "Complete tiered-loading declaration JSON; replaces the existing declaration as a whole",
+ "移除分层加载声明，恢复为完整读取": "Remove the tiered-loading declaration and return to full reading",
+ "预览或发布规则、模板版本": "Preview or publish rule and template versions",
+ "只读检查同一变体的新版本": "Read-only check for newer versions of the same variant",
+ "查看两份 Profile 的差异和三方冲突": "Show the differences and three-way conflicts between two Profiles",
+ "核对正文、Profile 快照和锁定指纹": "Verify the body, the Profile snapshot and the lock fingerprints",
+ "拒绝读取非普通文件：{0}": "Refusing to read a non-regular file: {0}",
+ "模板 {0} 的 rules 项必须是对象": "The rules entry of template {0} must be an object",
+ "规则缺少字段 {0}：{1}": "The rule is missing fields {0}: {1}",
+ "规则包含未知字段 {0}：{1}": "The rule has unknown fields {0}: {1}",
+ "规则编号无效：{0!r}": "Invalid rule id: {0!r}",
+ "规则 level 无效：{0}": "Invalid rule level: {0}",
+ "规则标题为空：{0}": "The rule title is empty: {0}",
+ "规则正文为空：{0}": "The rule text is empty: {0}",
+ "规则 scopes 必须是非空字符串数组：{0}": "The rule scopes must be a non-empty array of strings: {0}",
+ "模板缺少字段 {0}：{1}": "The template is missing fields {0}: {1}",
+ "模板包含未知字段 {0}：{1}": "The template has unknown fields {0}: {1}",
+ "模板编号无效：{0!r}": "Invalid template id: {0!r}",
+ "模板文件名必须与编号一致：{0}": "The template file name must match its id: {0}",
+ "模板版本必须使用三段数字：{0}": "The template version must use three numeric parts: {0}",
+ "模板字段 {0} 不能为空：{1}": "Template field {0} must not be empty: {1}",
+ "模板 scopes 必须是非空数组：{0}": "The template scopes must be a non-empty array: {0}",
+ "模板 rules 必须是非空数组：{0}": "The template rules must be a non-empty array: {0}",
+ "模板内存在重复规则编号：{0}": "The template contains a duplicate rule id: {0}",
+ "模板 questions 必须是数组：{0}": "The template questions must be an array: {0}",
+ "模板问题结构无效：{0}": "Invalid template question structure: {0}",
+ "模板问题编号无效：{0}": "Invalid template question id: {0}",
+ "模板问题编号重复：{0}": "Duplicate template question id: {0}",
+ "模板问题正文为空：{0}": "The template question text is empty: {0}",
+ "模板问题至少需要两个选项：{0}": "A template question needs at least two options: {0}",
+ "模板问题选项结构无效：{0}": "Invalid template question option structure: {0}",
+ "模板问题选项标签为空：{0}": "A template question option label is empty: {0}",
+ "模板问题引用了未知规则：{0}": "A template question refers to an unknown rule: {0}",
+ "模板目录不可用：{0}": "The template directory is not available: {0}",
+ "模板编号重复：{0}": "Duplicate template id: {0}",
+ "相同规则编号的内容不一致：{0}": "Rules with the same id have different content: {0}",
+ "模板版本不匹配：{0}@{1}，当前版本为 {2}": "Template version mismatch: {0}@{1}; the current version is {2}",
+ "自定义规则必须来自普通文件：{0}": "Custom rules must come from a regular file: {0}",
+ "自定义规则文件为空": "The custom rules file is empty",
+ "拒绝写入符号链接：{0}": "Refusing to write to a symbolic link: {0}",
+ "目标路径不是普通文件：{0}": "The target path is not a regular file: {0}",
+ "OPINION.md 已包含内容；预览差异并明确使用 --replace": "OPINION.md already has content; preview the difference and use --replace explicitly",
+ "写入后核对 OPINION.md 失败": "Verification of OPINION.md after writing failed",
+ "# Opinion 模板目录": "# Opinion template catalog",
+ "当前没有已批准的公开模板。": "There are no approved public templates yet.",
+ "、": ", ",
+ "规则数量：{0}；适用场景：{1}。": "Rules: {0}; scenarios: {1}.",
+ "管理版本化 Opinion 模板并生成统一 OPINION.md": "Manage versioned Opinion templates and generate a single OPINION.md",
+ "查看模板、规则和引导问题": "Show templates, rules and guiding questions",
+ "组合模板、规则和自定义内容": "Compose templates, rules and custom content",
+ "项目已经使用版本锁定；请用 compose --profile 更新": "The project already uses version locking; update it with compose --profile",
+ "至少选择一个模板、一个规则或一份自定义规则文件": "Select at least one template, one rule or one custom rules file",
+ "错误：{0}\n": "Error: {0}\n",
+ "路径必须是项目内的相对路径": "The path must be a relative path inside the project",
+ "拒绝使用符号链接": "Refusing to use a symbolic link",
+ "当前 Opinion 必须先通过 verify：{0}": "The current Opinion must pass verify first: {0}",
+ "occurrence 必须指向项目内的工作记录，根目录为：{0}": "occurrence must point at a work record inside the project; the roots are: {0}",
+ "use 必须记录适用规则的精确引用": "use must record exact references of the rules that applied",
+ "passed 与 user_changed 必须是明确的布尔值": "passed and user_changed must be explicit booleans",
+ "results 必须为每条规则给出结果：{0}": "results must give a result for every rule: {0}",
+ "存在违反的规则时 passed 不能为 true": "passed cannot be true while a rule is violated",
+ "当前 Profile 未声明分层加载，不能记录 {0}": "The current Profile does not declare tiered loading, so {0} cannot be recorded",
+ "{0} 必须是已声明规则束的不重复列表": "{0} must be a duplicate-free list of declared rule bundles",
+ "date 必须为 YYYY-MM-DD": "date must be YYYY-MM-DD",
+ "fixture 必须是明确的布尔值": "fixture must be an explicit boolean",
+ "候选需要完整的 title 与 text": "A candidate needs a complete title and text",
+ "候选需要明确的 scopes": "A candidate needs explicit scopes",
+ "候选内容变化时必须使用新的候选编号": "A candidate whose content changed must use a new candidate id",
+ "validation 必须为 pending、passed 或 failed": "validation must be pending, passed or failed",
+ "展示的内容与候选不一致": "The presented content does not match the candidate",
+ "人工裁决指向的候选内容不一致": "The human decision points at a different candidate content",
+ "需要明确的人工裁决": "An explicit human decision is required",
+ "采用需要人工批准当前精确的 Profile": "Adoption needs a human to approve the exact current Profile",
+ "不可变的 Profile 身份发生了变化": "The immutable Profile identity has changed",
+ "use 指向的 Opinion 内容已经变化": "The Opinion content that use points at has changed",
+ "复盘必须确认未变化的当前 Profile": "A review must confirm the unchanged current Profile",
+ "灰度内容已经变化；请采用新的已核验版本": "The trial content has changed; adopt the new verified version",
+ "转正式前先在新版本中解决灰度失败": "Resolve the trial failures in a new version before making it formal",
+ "未知的生命周期事件": "Unknown lifecycle event",
+ "不可变的生命周期证据发生变化；修改状态前先重新核验": "The immutable lifecycle evidence has changed; verify again before changing state",
+ "找不到可核验的旧 Profile": "No verifiable earlier Profile found",
+ "旧 Profile 与灰度记录的指纹不一致": "The earlier Profile does not match the fingerprint of the trial record",
+ "项目私有的候选、灰度与使用记录；不发布规则": "Project-private candidate, trial and usage records; never publishes rules",
+ "项目内保存状态与证据快照的相对目录": "relative directory inside the project that holds state and evidence snapshots",
+ "event 的事件 JSON，必须位于项目内": "event JSON of the event; must be inside the project",
+ "保存历史 Profile 的项目内相对目录，默认 .opinion/profiles": "relative directory inside the project that holds historical Profiles; default .opinion/profiles",
+ "允许作为独立发生场景的顶层目录，可重复": "top-level directories allowed as independent occurrence scenes; repeatable",
+ "queue 只输出未裁决候选的标题与适用范围": "queue: print only the title and scope of undecided candidates",
+ "预览返回的 confirmation_sha256": "confirmation_sha256 returned by the preview",
+ "只读命令不能使用 --apply": "A read-only command cannot use --apply",
+ "event 需要 --file": "event needs --file",
+ "事件证据已经变化": "The event evidence has changed",
+ "确认指纹不一致": "The confirmation fingerprint does not match",
+ "状态已经变化；请重新生成预览": "The state has changed; generate the preview again",
+ "Opinion 在写入期间发生变化；请重新生成预览": "The Opinion changed during writing; generate the preview again",
+ "证据在预览后发生变化": "The evidence changed after the preview",
+ "不可变的证据快照被改动": "The immutable evidence snapshot was modified",
+ "完整读取项目根目录 OPINION.md": "Read the full OPINION.md in the project root",
+ "Project Profile 的 opinion.loading_mode 必须为 tiered 或 full：{0!r}": "The Project Profile's opinion.loading_mode must be tiered or full: {0!r}",
+ "context 需要 --project 或 --profile": "context needs --project or --profile",
+ "Project Profile 设为完整读取": "The Project Profile is set to full reading",
+ "当前 Profile 未声明分层加载": "The current Profile does not declare tiered loading",
+ "未知的按需规则束：{0}": "Unknown on-demand rule bundle: {0}",
+ "bundle 需要至少一个模板系列或精确模板引用": "bundle needs at least one template family or exact template reference",
+ "未声明的交付信号：{0}": "Undeclared delivery signal: {0}",
+ "check 至少需要一个 --signal": "check needs at least one --signal",
+ "按已确认的加载声明只读切分正文，并核对交付信号": "Split the body read-only by the confirmed loading declaration and verify delivery signals",
+ "bundle 的模板系列或精确模板引用": "template family or exact template reference of the bundle",
+ "用候选或已保存的 Profile 预览，不读取项目锁": "preview with a candidate or saved Profile, without reading the project lock",
+ "交付信号，格式为 键=值，可重复": "delivery signal as key=value; repeatable",
+ "本次已读取的规则束，可重复": "rule bundles read this time; repeatable"
+}