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

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

@@ -11,6 +11,7 @@ from pathlib import Path
 from typing import Any
 
 from constants import KNOWN_PLACEHOLDERS
+from i18n_opinion import _  # noqa: E402
 
 
 PUBLIC_CATALOG = Path(__file__).resolve().parents[1] / "catalog"
@@ -53,74 +54,74 @@ def safe_path(path: Path) -> Path:
     path = Path(os.path.abspath(path.expanduser()))
     for component in (path, *path.parents):
         if component.is_symlink():
-            fail(f"拒绝使用符号链接：{component}")
+            fail(_("拒绝使用符号链接：{0}").format(component))
     return path
 
 
 def read_text(path: Path) -> str:
     path = safe_path(path)
     if not stat.S_ISREG(path.lstat().st_mode):
-        fail(f"必须使用普通文件：{path}")
+        fail(_("必须使用普通文件：{0}").format(path))
     return path.read_text(encoding="utf-8")
 
 
 def read_object(path: Path) -> dict[str, Any]:
     value = json.loads(read_text(path))
     if not isinstance(value, dict):
-        fail(f"JSON 根节点必须是对象：{path}")
+        fail(_("JSON 根节点必须是对象：{0}").format(path))
     return value
 
 
 def fields(value: Any, expected: set[str], label: str) -> None:
     if not isinstance(value, dict) or set(value) != expected:
-        fail(f"{label} 字段必须为：{sorted(expected)}")
+        fail(_("{0} 字段必须为：{1}").format(label, sorted(expected)))
 
 
 def string(value: Any, label: str) -> None:
     if not isinstance(value, str) or not value.strip():
-        fail(f"{label} 必须是非空字符串")
+        fail(_("{0} 必须是非空字符串").format(label))
 
 
 def identifier(value: Any) -> None:
     if not isinstance(value, str) or not IDENTIFIER.fullmatch(value):
-        fail(f"编号无效：{value!r}")
+        fail(_("编号无效：{0!r}").format(value))
 
 
 def version(value: Any) -> tuple[int, int, int]:
     if not isinstance(value, str) or not VERSION.fullmatch(value):
-        fail(f"版本必须是无前导零的三段数字：{value!r}")
+        fail(_("版本必须是无前导零的三段数字：{0!r}").format(value))
     return tuple(int(part) for part in value.split("."))
 
 
 def strings(value: Any, label: str, *, empty: bool = False) -> None:
     if not isinstance(value, list) or (not empty and not value):
-        fail(f"{label} 必须是字符串数组")
+        fail(_("{0} 必须是字符串数组").format(label))
     for item in value:
         string(item, label)
     if len(value) != len(set(value)):
-        fail(f"{label} 包含重复项")
+        fail(_("{0} 包含重复项").format(label))
 
 
 def parse_ref(ref: str, kind: str) -> tuple[str, str]:
     if not isinstance(ref, str) or ref.count("@") != 1:
-        fail(f"{kind} 必须精确指定 @VERSION：{ref!r}")
+        fail(_("{0} 必须精确指定 @VERSION：{1!r}").format(kind, ref))
     identity, release = ref.split("@")
     version(release)
     parts = identity.split("/")
     if len(parts) != (2 if kind == "templates" else 1):
-        fail(f"{kind} 引用格式无效：{ref}")
+        fail(_("{0} 引用格式无效：{1}").format(kind, ref))
     for part in parts:
         identifier(part)
     return identity, release
 
 
 def validate_edit(value: Any) -> None:
-    fields(value, EDITABLE, "规则内容")
+    fields(value, EDITABLE, _("规则内容"))
     string(value["title"], "title")
     string(value["text"], "text")
     strings(value["scopes"], "scopes")
     if value["level"] not in ("required", "preferred"):
-        fail("level 必须为 required 或 preferred")
+        fail(_("level 必须为 required 或 preferred"))
 
 
 def release_ref(value: dict[str, Any], kind: str) -> str:
@@ -130,9 +131,9 @@ def release_ref(value: dict[str, Any], kind: str) -> str:
 
 def validate_release(value: Any) -> str:
     if not isinstance(value, dict):
-        fail("发布内容必须是对象")
+        fail(_("发布内容必须是对象"))
     kind = "rules" if "id" in value else "templates"
-    fields(value, RULE_FIELDS if kind == "rules" else TEMPLATE_FIELDS, "发布内容")
+    fields(value, RULE_FIELDS if kind == "rules" else TEMPLATE_FIELDS, _("发布内容"))
     version(value["version"])
     if kind == "rules":
         identifier(value["id"])
@@ -158,7 +159,7 @@ def release_path(root: Path, value: dict[str, Any], kind: str) -> Path:
 def load_catalog(root: Path) -> dict[str, dict[str, Any]]:
     root = safe_path(root)
     if not root.is_dir():
-        fail(f"目录不存在：{root}")
+        fail(_("目录不存在：{0}").format(root))
     catalog: dict[str, dict[str, Any]] = {"templates": {}, "rules": {}}
     for path in sorted(root.rglob("*")):
         safe_path(path)
@@ -167,7 +168,7 @@ def load_catalog(root: Path) -> dict[str, dict[str, Any]]:
         value = read_object(path)
         kind = validate_release(value)
         if path != release_path(root, value, kind):
-            fail(f"发布文件路径与身份不一致：{path}")
+            fail(_("发布文件路径与身份不一致：{0}").format(path))
         ref = release_ref(value, kind)
         catalog[kind][ref] = value
     for template in catalog["templates"].values():
@@ -181,24 +182,24 @@ def resolve(catalog: dict[str, dict[str, Any]], templates: list[str], rules: lis
     sources: dict[str, list[Any]] = {"templates": [], "rules": []}
     references = list(rules)
     for ref in templates:
-        identity, _ = parse_ref(ref, "templates")
+        identity, _version = parse_ref(ref, "templates")
         family = identity.split("/")[0]
         if family in families:
-            fail(f"同一模板系列只能选择一个变体和版本：{family}")
+            fail(_("同一模板系列只能选择一个变体和版本：{0}").format(family))
         families.add(family)
         if ref not in catalog["templates"]:
-            fail(f"未知模板：{ref}")
+            fail(_("未知模板：{0}").format(ref))
         value = catalog["templates"][ref]
         sources["templates"].append({"ref": ref, "sha256": digest(value), "value": value})
         references.extend(value["rules"])
     selected: dict[str, Any] = {}
     for ref in references:
-        identity, _ = parse_ref(ref, "rules")
+        identity, _version = parse_ref(ref, "rules")
         if ref not in catalog["rules"]:
-            fail(f"未知规则：{ref}")
+            fail(_("未知规则：{0}").format(ref))
         value = catalog["rules"][ref]
         if identity in selected and selected[identity]["ref"] != ref:
-            fail(f"规则选择了不同版本：{identity}")
+            fail(_("规则选择了不同版本：{0}").format(identity))
         selected.setdefault(identity, {"ref": ref, "sha256": digest(value), "value": value})
     sources["rules"] = list(selected.values())
     return sources
@@ -219,7 +220,7 @@ def effective_rules(profile: dict[str, Any]) -> dict[str, Any]:
     for identity, rule in result.items():
         slot = rule["slot"]
         if slot in slots:
-            fail(f"规则 slot 冲突：{slot}（{slots[slot]}、{identity}）")
+            fail(_("规则 slot 冲突：{0}（{1}、{2}）").format(slot, slots[slot], identity))
         slots[slot] = identity
     return result
 
@@ -233,45 +234,45 @@ def validate_loading(profile: dict[str, Any]) -> None:
     fields(loading, LOADING_FIELDS, "loading")
     strings(loading["core"], "loading.core", empty=True)
     if not isinstance(loading["signals"], dict) or not loading["signals"]:
-        fail("loading.signals 必须是非空对象")
+        fail(_("loading.signals 必须是非空对象"))
     for key, values in loading["signals"].items():
         identifier(key)
         strings(values, f"loading.signals.{key}")
         for item in values:
             identifier(item)
     if not isinstance(loading["bundles"], list) or not loading["bundles"]:
-        fail("loading.bundles 至少包含一个按需规则束")
+        fail(_("loading.bundles 至少包含一个按需规则束"))
     families = set(selected_families(profile))
     seen = set(loading["core"])
     for family in loading["core"]:
         if family not in families:
-            fail(f"loading.core 引用了未选择的模板系列：{family}")
+            fail(_("loading.core 引用了未选择的模板系列：{0}").format(family))
     for bundle in loading["bundles"]:
-        fields(bundle, BUNDLE_FIELDS, "loading.bundles 项")
+        fields(bundle, BUNDLE_FIELDS, _("loading.bundles 项"))
         family = bundle["family"]
         if family not in families:
-            fail(f"loading.bundles 引用了未选择的模板系列：{family!r}")
+            fail(_("loading.bundles 引用了未选择的模板系列：{0!r}").format(family))
         if family in seen:
-            fail(f"模板系列在 loading 中重复出现：{family}")
+            fail(_("模板系列在 loading 中重复出现：{0}").format(family))
         seen.add(family)
         string(bundle["trigger"], "trigger")
         string(bundle["exclude"], "exclude")
         if not isinstance(bundle["routes"], list) or not bundle["routes"]:
-            fail(f"规则束至少需要一条路由：{family}")
+            fail(_("规则束至少需要一条路由：{0}").format(family))
         for route in bundle["routes"]:
             if not isinstance(route, dict) or not route:
-                fail(f"路由必须是非空对象：{family}")
+                fail(_("路由必须是非空对象：{0}").format(family))
             for key, values in route.items():
                 strings(values, f"routes.{key}")
                 if key not in loading["signals"] or not set(values) <= set(loading["signals"][key]):
-                    fail(f"路由使用了未声明的信号：{family}.{key}")
+                    fail(_("路由使用了未声明的信号：{0}.{1}").format(family, key))
 
 
 def validate_profile(value: Any) -> dict[str, Any]:
     tiered = isinstance(value, dict) and value.get("schema_version") == "2.1"
     fields(value, PROFILE_FIELDS | PROFILE_OPTIONAL_FIELDS if tiered else PROFILE_FIELDS, "Profile")
     if value["schema_version"] not in ("2.0", "2.1"):
-        fail("Profile schema_version 必须为 2.0 或 2.1")
+        fail(_("Profile schema_version 必须为 2.0 或 2.1"))
     identifier(value["id"])
     version(value["version"])
     strings(value["templates"], "templates", empty=True)
@@ -280,27 +281,27 @@ def validate_profile(value: Any) -> dict[str, Any]:
     catalog: dict[str, dict[str, Any]] = {"templates": {}, "rules": {}}
     for kind, sources in value["sources"].items():
         if not isinstance(sources, list):
-            fail("sources 项必须是数组")
+            fail(_("sources 项必须是数组"))
         for source in sources:
             fields(source, {"ref", "sha256", "value"}, "source")
             if validate_release(source["value"]) != kind:
-                fail("source 类型不一致")
+                fail(_("source 类型不一致"))
             if source["ref"] != release_ref(source["value"], kind) or source["sha256"] != digest(source["value"]):
-                fail(f"source 指纹或引用不一致：{source['ref']}")
+                fail(_("source 指纹或引用不一致：{0}").format(source['ref']))
             if source["ref"] in catalog[kind]:
-                fail(f"重复 source：{source['ref']}")
+                fail(_("重复 source：{0}").format(source['ref']))
             catalog[kind][source["ref"]] = source["value"]
     if resolve(catalog, value["templates"], value["rules"]) != value["sources"]:
-        fail("Profile 引用与 sources 不一致")
+        fail(_("Profile 引用与 sources 不一致"))
     if not isinstance(value["overrides"], dict):
-        fail("overrides 必须是对象")
+        fail(_("overrides 必须是对象"))
     for identity, override in value["overrides"].items():
         identifier(identity)
         if override is not None:
             if validate_release(override) != "rules" or override["id"] != identity:
-                fail("override 必须使用匹配编号的完整规则")
+                fail(_("override 必须使用匹配编号的完整规则"))
         elif identity not in base_rules(value):
-            fail(f"停用规则不存在：{identity}")
+            fail(_("停用规则不存在：{0}").format(identity))
     if value["custom"] is not None:
         string(value["custom"], "custom")
     if value["derived_from"] is not None:
@@ -308,9 +309,9 @@ def validate_profile(value: Any) -> dict[str, Any]:
         identifier(value["derived_from"]["id"])
         version(value["derived_from"]["version"])
         if not isinstance(value["derived_from"]["sha256"], str) or not re.fullmatch(r"[0-9a-f]{64}", value["derived_from"]["sha256"]):
-            fail("derived_from 指纹无效")
+            fail(_("derived_from 指纹无效"))
     if not effective_rules(value) and not value["custom"]:
-        fail("Profile 至少需要一条有效规则或自定义内容")
+        fail(_("Profile 至少需要一条有效规则或自定义内容"))
     if tiered:
         validate_loading(value)
     return value
@@ -324,10 +325,10 @@ def replace_refs(previous: list[str], incoming: list[str], kind: str) -> list[st
     result = list(previous)
     keys: set[str] = set()
     for ref in incoming:
-        identity, _ = parse_ref(ref, kind)
+        identity, _version = parse_ref(ref, kind)
         key = identity.split("/")[0] if kind == "templates" else identity
         if key in keys:
-            fail(f"同一次选择包含重复身份：{key}")
+            fail(_("同一次选择包含重复身份：{0}").format(key))
         keys.add(key)
         result = [item for item in result if (parse_ref(item, kind)[0].split("/")[0] if kind == "templates" else parse_ref(item, kind)[0]) != key]
         result.append(ref)
@@ -367,7 +368,7 @@ def immutable_write(path: Path, value: dict[str, Any]) -> str:
     if path.exists():
         if read_object(path) == value:
             return "unchanged"
-        fail(f"已经发布的版本不可修改：{path}")
+        fail(_("已经发布的版本不可修改：{0}").format(path))
     path.parent.mkdir(parents=True, exist_ok=True)
     descriptor, name = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
     temporary = Path(name)
@@ -381,35 +382,35 @@ def immutable_write(path: Path, value: dict[str, Any]) -> str:
     finally:
         temporary.unlink()
     if read_object(path) != value:
-        fail(f"写入后核对失败：{path}")
+        fail(_("写入后核对失败：{0}").format(path))
     return "written"
 
 
 def confirm(args: argparse.Namespace, fingerprint: str) -> None:
     if args.confirm != fingerprint:
-        fail(f"请先审阅预览，再使用 --confirm {fingerprint} --apply")
+        fail(_("请先审阅预览，再使用 --confirm {0} --apply").format(fingerprint))
 
 
 def profile_command(args: argparse.Namespace) -> dict[str, Any]:
     root = safe_path(args.project)
     if not root.is_dir():
-        fail(f"项目目录不存在：{root}")
+        fail(_("项目目录不存在：{0}").format(root))
     identifier(args.id)
     version(args.version)
     old = load_profile(args.from_profile) if args.from_profile else None
     if old and args.id == old["id"] and version(args.version) <= version(old["version"]):
-        fail("修订 Profile 必须增加版本；私有派生必须使用独立编号")
+        fail(_("修订 Profile 必须增加版本；私有派生必须使用独立编号"))
     templates = replace_refs(old["templates"] if old else [], args.template, "templates")
     rules = replace_refs(old["rules"] if old else [], args.rule, "rules")
     for family in args.remove_template:
         identifier(family)
         if not any(parse_ref(ref, "templates")[0].split("/")[0] == family for ref in templates):
-            fail(f"无法移除未选择的模板系列：{family}")
+            fail(_("无法移除未选择的模板系列：{0}").format(family))
         templates = [ref for ref in templates if parse_ref(ref, "templates")[0].split("/")[0] != family]
     for identity in args.remove_rule:
         identifier(identity)
         if not any(parse_ref(ref, "rules")[0] == identity for ref in rules):
-            fail(f"无法移除未直接选择的规则：{identity}")
+            fail(_("无法移除未直接选择的规则：{0}").format(identity))
         rules = [ref for ref in rules if parse_ref(ref, "rules")[0] != identity]
     catalog = load_catalog(args.catalog)
     if old:
@@ -417,11 +418,11 @@ def profile_command(args: argparse.Namespace) -> dict[str, Any]:
             for source in sources:
                 existing = catalog[kind].get(source["ref"])
                 if existing is not None and digest(existing) != source["sha256"]:
-                    fail(f"已经发布的来源内容发生变化：{source['ref']}")
+                    fail(_("已经发布的来源内容发生变化：{0}").format(source['ref']))
                 catalog[kind].setdefault(source["ref"], source["value"])
     custom = read_text(args.custom_file).strip() if args.custom_file else (old["custom"] if old else None)
     if args.loading_file and args.remove_loading:
-        fail("--loading-file 与 --remove-loading 不能同时使用")
+        fail(_("--loading-file 与 --remove-loading 不能同时使用"))
     # 加载声明整体替换；未提供时沿用原 Profile，保证未变更的声明不会在修订中丢失。
     loading = read_object(args.loading_file) if args.loading_file else (None if args.remove_loading or not old else old.get("loading"))
     value = {
@@ -436,17 +437,17 @@ def profile_command(args: argparse.Namespace) -> dict[str, Any]:
     resolutions = read_object(args.resolutions_file) if args.resolutions_file else {}
     conflict_ids = {item["id"] for item in changes["conflicts"]}
     if set(resolutions) - conflict_ids:
-        fail("resolutions 包含没有冲突的编号")
+        fail(_("resolutions 包含没有冲突的编号"))
     for identity, choice in resolutions.items():
         if choice == "use-upstream":
             value["overrides"].pop(identity, None)
         elif choice != "keep-local":
-            fail("冲突处理必须为 keep-local 或 use-upstream")
+            fail(_("冲突处理必须为 keep-local 或 use-upstream"))
     overrides = read_object(args.overrides_file) if args.overrides_file else {}
     for identity, override in overrides.items():
         identifier(identity)
         if identity not in base_rules(value):
-            fail(f"override 引用未知规则：{identity}")
+            fail(_("override 引用未知规则：{0}").format(identity))
         if override is None:
             value["overrides"][identity] = None
         else:
@@ -467,7 +468,7 @@ def profile_command(args: argparse.Namespace) -> dict[str, Any]:
     result = {"ok": True, "status": "preview", "path": str(path), "profile": value, "content": render(value), "effective_rules": list(effective_rules(value).values()), "changes": changes, "unresolved": sorted(unresolved), "confirmation_sha256": fingerprint}
     if args.apply:
         if unresolved:
-            fail(f"升级存在未确认的冲突：{sorted(unresolved)}")
+            fail(_("升级存在未确认的冲突：{0}").format(sorted(unresolved)))
         confirm(args, fingerprint)
         result["status"] = immutable_write(path, value)
     return result
@@ -480,22 +481,22 @@ def publish_command(args: argparse.Namespace) -> dict[str, Any]:
     ref = release_ref(value, kind)
     existing = catalog[kind].get(ref)
     if existing is not None and existing != value:
-        fail(f"已经发布的版本不可修改：{ref}")
+        fail(_("已经发布的版本不可修改：{0}").format(ref))
     identity, release = parse_ref(ref, kind)
     patch_peers = [item for key, item in catalog[kind].items() if parse_ref(key, kind)[0] == identity and version(item["version"])[:2] == version(release)[:2] and item["version"] != release]
     for latest in patch_peers:
         before, after = version(latest["version"]), version(release)
         if before[:2] == after[:2]:
             if kind == "rules" and behavior(latest) != behavior(value):
-                fail("patch 版本只允许不改变行为的修改")
+                fail(_("patch 版本只允许不改变行为的修改"))
             if kind == "templates":
                 if latest["scopes"] != value["scopes"]:
-                    fail("patch 版本不能改变适用范围")
+                    fail(_("patch 版本不能改变适用范围"))
                 a = resolve(catalog, [release_ref(latest, kind)], [])
                 prospective = {**catalog, "templates": {**catalog["templates"], ref: value}}
                 b = resolve(prospective, [ref], [])
                 if {s["value"]["id"]: behavior(s["value"]) for s in a["rules"]} != {s["value"]["id"]: behavior(s["value"]) for s in b["rules"]}:
-                    fail("patch 版本不能改变有效规则")
+                    fail(_("patch 版本不能改变有效规则"))
     catalog[kind][ref] = value
     if kind == "templates":
         sources = resolve(catalog, [ref], [])
@@ -507,7 +508,7 @@ def publish_command(args: argparse.Namespace) -> dict[str, Any]:
     if args.apply:
         confirm(args, fingerprint)
         if (root == PUBLIC_CATALOG or PUBLIC_CATALOG in root.parents) and not args.public_approved:
-            fail("公开内容需要用户批准完整文件，并使用 --public-approved")
+            fail(_("公开内容需要用户批准完整文件，并使用 --public-approved"))
         result["status"] = immutable_write(path, value)
     return result
 
@@ -540,10 +541,10 @@ def lock_value(profile: dict[str, Any], content: str) -> dict[str, Any]:
 def validate_lock(lock: Any) -> dict[str, Any]:
     fields(lock, {"schema_version", "renderer_version", "profile", "profile_sha256", "opinion_sha256"}, "lock")
     if lock["schema_version"] != "2.0" or lock["renderer_version"] != "2.0":
-        fail("锁定文件版本不受支持")
+        fail(_("锁定文件版本不受支持"))
     profile = validate_profile(lock["profile"])
     if lock != lock_value(profile, render(profile)):
-        fail("锁定文件指纹与内容不一致")
+        fail(_("锁定文件指纹与内容不一致"))
     return lock
 
 
@@ -565,11 +566,11 @@ def atomic_write(path: Path, content: str) -> None:
 
 def compose_command(args: argparse.Namespace) -> dict[str, Any]:
     if args.template or args.rule or args.custom_file:
-        fail("--profile 必须独立使用；通过 profile 命令修改选择和自定义内容")
+        fail(_("--profile 必须独立使用；通过 profile 命令修改选择和自定义内容"))
     profile = load_profile(args.profile)
     root = safe_path(args.project)
     if not root.is_dir():
-        fail(f"项目目录不存在：{root}")
+        fail(_("项目目录不存在：{0}").format(root))
     content = render(profile)
     lock = lock_value(profile, content)
     destination, lock_path = root / "OPINION.md", root / "opinion.lock.json"
@@ -579,17 +580,17 @@ def compose_command(args: argparse.Namespace) -> dict[str, Any]:
         previous = validate_lock(json.loads(current_lock))
         previous_profile = previous["profile"]
         if (previous_profile["id"], previous_profile["version"]) == (profile["id"], profile["version"]) and digest(previous_profile) != digest(profile):
-            fail("已经锁定的 Profile 版本不可改变内容；请发布新的 Profile 版本")
+            fail(_("已经锁定的 Profile 版本不可改变内容；请发布新的 Profile 版本"))
         if current is None:
             if previous != lock:
-                blocked = "正文缺失；请先使用原锁定 Profile 重建正文，再进行升级"
+                blocked = _("正文缺失；请先使用原锁定 Profile 重建正文，再进行升级")
         elif text_digest(current) != previous["opinion_sha256"]:
             if args.accept_current != text_digest(current):
-                blocked = "OPINION.md 已被人工修改；请读取并纳入新的 Profile，审阅后用 --accept-current 当前文件SHA256 确认"
+                blocked = _("OPINION.md 已被人工修改；请读取并纳入新的 Profile，审阅后用 --accept-current 当前文件SHA256 确认")
     elif current is not None and current != content and not args.replace:
         # 完整匹配初始化占位内容，任何追加内容均需要审阅。
         if current not in KNOWN_PLACEHOLDERS:
-            blocked = "已有 OPINION.md 需要审阅并使用 --replace"
+            blocked = _("已有 OPINION.md 需要审阅并使用 --replace")
     fingerprint = digest({"lock": lock, "before": {"opinion": current, "lock": current_lock}, "replace": args.replace, "accept_current": args.accept_current})
     result = {"ok": True, "status": "preview", "content": content, "lock": lock, "blocked": blocked, "confirmation_sha256": fingerprint, "path": str(destination)}
     if args.apply:
@@ -611,7 +612,7 @@ def verify_project(project: Path) -> dict[str, Any]:
     root = safe_path(project)
     lock = validate_lock(read_object(root / "opinion.lock.json"))
     if text_digest(read_text(root / "OPINION.md")) != lock["opinion_sha256"]:
-        fail("OPINION.md 与锁定文件不一致；请读取人工修改或检查中断的写入")
+        fail(_("OPINION.md 与锁定文件不一致；请读取人工修改或检查中断的写入"))
     return {"ok": True, "status": "verified", "profile": f"{lock['profile']['id']}@{lock['profile']['version']}", "profile_sha256": lock["profile_sha256"], "opinion_sha256": lock["opinion_sha256"]}
 
 
@@ -622,7 +623,7 @@ def updates_command(args: argparse.Namespace) -> dict[str, Any]:
         for source in sources:
             item = catalog[kind].get(source["ref"])
             if item is not None and digest(item) != source["sha256"]:
-                fail(f"已经发布的来源内容发生变化：{source['ref']}")
+                fail(_("已经发布的来源内容发生变化：{0}").format(source['ref']))
     updates = []
     for kind in ("templates", "rules"):
         for ref in profile[kind]:
@@ -639,15 +640,15 @@ def options(parser: argparse.ArgumentParser, *, catalog: bool = False, mutation:
         parser.add_argument("--catalog", type=Path, default=PUBLIC_CATALOG)
     if mutation:
         parser.add_argument("--apply", action="store_true")
-        parser.add_argument("--confirm", help="预览返回的完整内容 SHA-256")
+        parser.add_argument("--confirm", help=_("预览返回的完整内容 SHA-256"))
 
 
 def add_commands(subparsers: Any, compose: argparse.ArgumentParser, catalog: argparse.ArgumentParser) -> None:
     compose.add_argument("--profile", type=Path)
     compose.add_argument("--confirm")
-    compose.add_argument("--accept-current", help="人工修改或写入中断后的当前 OPINION.md SHA-256；读取并保留内容后使用")
+    compose.add_argument("--accept-current", help=_("人工修改或写入中断后的当前 OPINION.md SHA-256；读取并保留内容后使用"))
     catalog.add_argument("--catalog", type=Path)
-    profile = subparsers.add_parser("profile", help="预览、派生和发布不可变的个人 Profile")
+    profile = subparsers.add_parser("profile", help=_("预览、派生和发布不可变的个人 Profile"))
     options(profile, catalog=True, mutation=True)
     profile.add_argument("--project", required=True, type=Path)
     profile.add_argument("--id", required=True)
@@ -660,20 +661,20 @@ def add_commands(subparsers: Any, compose: argparse.ArgumentParser, catalog: arg
     profile.add_argument("--from-profile", type=Path)
     profile.add_argument("--overrides-file", type=Path)
     profile.add_argument("--resolutions-file", type=Path)
-    profile.add_argument("--loading-file", type=Path, help="完整的分层加载声明 JSON；整体替换原声明")
-    profile.add_argument("--remove-loading", action="store_true", help="移除分层加载声明，恢复为完整读取")
-    publish = subparsers.add_parser("publish", help="预览或发布规则、模板版本")
+    profile.add_argument("--loading-file", type=Path, help=_("完整的分层加载声明 JSON；整体替换原声明"))
+    profile.add_argument("--remove-loading", action="store_true", help=_("移除分层加载声明，恢复为完整读取"))
+    publish = subparsers.add_parser("publish", help=_("预览或发布规则、模板版本"))
     options(publish, catalog=True, mutation=True)
     publish.add_argument("--file", required=True, type=Path)
     publish.add_argument("--public-approved", action="store_true")
-    updates = subparsers.add_parser("updates", help="只读检查同一变体的新版本")
+    updates = subparsers.add_parser("updates", help=_("只读检查同一变体的新版本"))
     options(updates, catalog=True)
     updates.add_argument("--profile", required=True, type=Path)
-    compare = subparsers.add_parser("compare", help="查看两份 Profile 的差异和三方冲突")
+    compare = subparsers.add_parser("compare", help=_("查看两份 Profile 的差异和三方冲突"))
     options(compare)
     compare.add_argument("--from-profile", required=True, type=Path)
     compare.add_argument("--to-profile", required=True, type=Path)
-    verify = subparsers.add_parser("verify", help="核对正文、Profile 快照和锁定指纹")
+    verify = subparsers.add_parser("verify", help=_("核对正文、Profile 快照和锁定指纹"))
     options(verify)
     verify.add_argument("--project", required=True, type=Path)
 

package/runtime/plugins/opinion-manager/skills/opinion-manager/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: opinion-manager
-description: Generate, compose, review and maintain behavior rules between the user and the Agent. Use when the user asks to create or update OPINION.md, import existing instructions, apply a template directly, pick some of its items, start from blank, propose rule candidates from authorized memory, maintain a personal Profile, check upgrades and conflicts, or review a deliverable against the current Opinion. 中文：生成、组合、审查和维护用户与 Agent 之间的行为规则。用户要求创建或更新 OPINION.md、导入既有说明、直接用模板、选择部分条目、从空白开始、基于已授权记忆提出候选规则、维护个人 Profile、检查升级与冲突或按当前 Opinion 审查交付物时使用。
+description: Generate, compose, review and maintain behavior rules between the user and the Agent. Use when the user asks to create or update OPINION.md, import existing instructions, apply a template directly, pick some of its items, start from blank, propose rule candidates from authorized memory, maintain a personal Profile, check upgrades and conflicts, or review a deliverable against the current Opinion. Also use during ordinary work when the user states a lasting preference or a correction of your behavior (stash it as a candidate), at task completion to confirm new candidates, and when unconfirmed candidates have piled up. 中文：生成、组合、审查和维护用户与 Agent 之间的行为规则。用户要求创建或更新 OPINION.md、导入既有说明、直接用模板、选择部分条目、从空白开始、基于已授权记忆提出候选规则、维护个人 Profile、检查升级与冲突或按当前 Opinion 审查交付物时使用。工作中用户表达长期偏好或对你行为的纠正时暂存为候选，任务完成时集中请用户确认，候选堆积时协助逐条裁决。
 ---
 
 # Opinion Manager（Agent 行为规则管理）
@@ -49,10 +49,23 @@ description: Generate, compose, review and maintain behavior rules between the u
 
 ## 交付物审查与旧格式
 
-实施前完整读取当前项目 `OPINION.md`，按条件选择适用条款；交付前逐条检查并修正明确问题。Profile 声明了分层加载时，改为先运行 `context core` 读取核心规则与规则束索引，任务命中触发条件或判断不清时用 `context bundle` 读取对应规则束，交付前用 `context check` 核对；命令返回 `fallback` 时完整读取正文。维护规则本身时始终完整读取。冲突改变交付时集中请用户裁决。用户反馈只形成候选，经确认才能发布新版本。项目需要记录候选发生次数、灰度使用与规则覆盖时，使用 `lifecycle` 命令在项目私有目录记账：任务结束后提交 `use` 事件，如实记录适用规则、逐条结果、读取的规则束和漏读；测试与演示标为 `fixture`。工具只记账，不在后台学习，也不自动晋升候选或把灰度版本转为正式，这些裁决来自用户。
+实施前完整读取当前项目 `OPINION.md`，按条件选择适用条款；交付前逐条检查并修正明确问题。Profile 声明了分层加载时，改为先运行 `context core` 读取核心规则与规则束索引，任务命中触发条件或判断不清时用 `context bundle` 读取对应规则束，交付前用 `context check` 核对；命令返回 `fallback` 时完整读取正文。维护规则本身时始终完整读取。冲突改变交付时集中请用户裁决。用户反馈只形成候选，经确认才能发布新版本。项目需要记录候选发生次数、灰度使用与规则覆盖时，使用 `lifecycle` 命令在项目私有目录记账：任务结束后提交 `use` 事件，如实记录适用规则、逐条结果、读取的规则束和漏读；测试与演示标为 `fixture`。工具只记账，不在后台学习，也不自动晋升候选或把灰度版本转为正式，这些裁决来自用户。工作中的低成本暂存使用 `inbox`（见下文），`lifecycle` 保留给带证据的灰度与覆盖记账。
 
 旧格式 `templates/*.json`、`compose --template`、`compose --rule` 与 `compose --custom-file` 保持兼容。有锁项目必须使用版本化 Profile 流程，禁止用旧格式写入绕过核验；新项目优先使用版本化 catalog。
 
+## 候选收件箱与自动采集
+
+收件箱让用户在工作中顺手沉淀观点：先低成本暂存，再由用户集中裁决。agent-pack 的 hook（`agenthelm nudge`）会在会话开始注入下面的协议并提示未决事项；没有 hook 的客户端按本节手动执行。命令与数据格式见 [候选收件箱](../../references/inbox.md)，hook 与阈值见 agent-pack 的 `references/nudge.md`。
+
+- **暂存**：用户在工作中表达长期偏好、对你行为的纠正或规则（“以后都……”“不要再……”“记住……”）时，立即用 `inbox add` 暂存标题、完整规则、适用范围和用户原话。不打断当前任务，不需要确认。一次性的任务要求、项目事实和命令不是候选。宁可多暂存，裁决环节会过滤。
+- **匹配**：实施前读取 OPINION.md；用户已同意试行的候选（`inbox list --status trial`，hook 会随协议注入）同样遵循，交付时说明是否适用。
+- **确认**：任务完成或即将完成时，把本次会话新增的候选用编号列表一次性交给用户：正式采纳 / 项目内试行 / 暂缓 / 丢弃。用户明确表态后用 `inbox decide … --confirmed` 记录；每个会话集中确认一次，不逐条追问。
+- **转正式**：`formal` 只记录用户意愿。写入 OPINION.md 仍走上文的完整预览与确认流程，候选正文作为个人规则输入。
+- **边界**：`inbox` 不写 OPINION.md、Profile 或锁；重复出现不等于确认。试行超过设定天数未转正会回到待确认。
+- **隐私**：收件箱 `.opinion/inbox.json` 保存用户原话，可能含敏感信息，建议项目保持私有。`inbox add` 返回 `notice` 时如实转告用户；是否公开仓库、是否排除 `.opinion/` 由用户决定，不要替用户决定，也不要自行修改 `.gitignore`。
+- **语言**：提示与协议有中文、英文两种，命令带 `--lang zh|en`；向用户转告和确认时使用用户正在使用的语言。候选内容是用户自己的话，不翻译。
+- **未决汇总**：开新会话时 agent-pack 按阈值提示待确认数量与久未处理的天数；用户可在 Project Profile 的 `opinion.nudge` 或 `~/.config/agenthelm/config.json` 的 `nudge` 调整，或用 `AGENTHELM_NO_NUDGE=1` 关闭。
+
 ## 完成条件
 
 - 选择从空白开始时，已有规则保持不变，不创建空规则版本；

package/runtime/plugins/project-orchestrator/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "project-orchestrator",
-  "version": "1.8.1",
+  "version": "1.11.1",
   "description": "Portable project lifecycle orchestration for configured workspaces.",
   "author": {
     "name": "lc4t"

package/runtime/plugins/project-orchestrator/content.json

@@ -3,10 +3,10 @@
   "packs": [
     {
       "id": "project-orchestrator/case-template",
-      "version": "1.0.0",
+      "version": "1.1.0",
       "kind": "sample",
       "title": "默认 Case 模板与 Schema",
-      "description": "runtime/case.py 新建 Case 时使用的 CASE.md 正文模板与默认 Frontmatter Schema；只影响之后新建的 Case，已有 Case 不会被改写。",
+      "description": "runtime/case.py 新建 CASE.md 时使用的正文模板（中文 CASE.md、英文 CASE.en.md，按 Project Profile 的 language 选择）与默认 Frontmatter Schema；只影响之后新建的 Case，已有 Case 不会被改写。（1.1.0：Schema 增加可选字段 sop，记录这个 Case 是哪个 SOP 的一次执行。1.2.0：新增 CASE.en.md。）",
       "sources": [
         "templates",
         "references/case.schema.json"
@@ -14,7 +14,8 @@
       "materializes": [],
       "project_lock": "none",
       "files": {
-        "references/case.schema.json": "7e56e407926a3e49434102ca87bcd5e48174357f527afd8952ab9af993732205",
+        "references/case.schema.json": "ecb37f084b901786bdc878cdc7f1e5d74c2eb31722d6a10fe24f6d88768bcbde",
+        "templates/CASE.en.md": "4aec0fab19c83bb5c2b72a31bbedb3425c82efb13e5d436f5cee35496d6eab74",
         "templates/CASE.md": "a33ffcec5c239cbcf4c0828f08336c578d6d184363b01db1419f74fcdc9e1086"
       }
     },
@@ -32,6 +33,32 @@
       "files": {
         "references/asset-synonyms.example.json": "a3338b98addd2b0fa386829850e0dd2667dff593ac7aa7f8e70b91372b3439c9"
       }
+    },
+    {
+      "id": "project-orchestrator/sop-samples",
+      "version": "1.0.0",
+      "kind": "sample",
+      "title": "SOP 样例",
+      "description": "runtime/sop.py new --template 使用的 SOP 样例：blank（空白，带填写说明）、video-to-transcript（视频转文字稿，展示工具清单、条件性前置、替代方案与中间产物）、weekly-review（周期性复盘，展示先确定复盘范围）、knowledge-digest（知识整理，展示可共享的流程与规则候选的交接）。每个样例有中文（SOP.md）和英文（SOP.en.md）两套，按项目文件语言选用；样例只含流程结构，不含任何个人进度或数据；创建的都是草稿，需要与用户谈清各项约定后才能启用；已创建的 SOP 不会被改写。",
+      "sources": [
+        "sop-templates"
+      ],
+      "materializes": [],
+      "project_lock": "none",
+      "files": {
+        "sop-templates/blank/SOP.en.md": "f7929e5840f1a4ea7cb832d949237be43328c662c690fcc2e204bb36233940fa",
+        "sop-templates/blank/SOP.md": "efec23ad29102590bdd16268c79222eb6f14fa8a1352deb27a5e55d35c413704",
+        "sop-templates/knowledge-digest/SOP.en.md": "e30bb6fb0282f23e326e70404ac66e4419c99a53a2e3eb2cabfdffa5c2754e55",
+        "sop-templates/knowledge-digest/SOP.md": "eaa8d7eb2338fe71b7a05fec662230a7e0b2e36f4727657558f2b51ed0a98027",
+        "sop-templates/knowledge-digest/templates/digest.en.md": "9461e971a40307434d5460b12cf0938038ab6af2b2c98ce5a02260d816bc9d7a",
+        "sop-templates/knowledge-digest/templates/digest.md": "0741e5a8008119528c5fc71cc9c3c8064dc1173d61465643e8dc5745883ccb9a",
+        "sop-templates/video-to-transcript/SOP.en.md": "5c5797eed4fdadaec4089b43843bc43287d68cc6699e9fafd1803aa8e8e253a4",
+        "sop-templates/video-to-transcript/SOP.md": "b8dfb1ecb0e2cf2a13d4acad78ee759f6c402776443cf5a70e2d6390a120ba4e",
+        "sop-templates/weekly-review/SOP.en.md": "fd9734078467066463c8005c459a9c3885236545e622b1219c52cf5633045de8",
+        "sop-templates/weekly-review/SOP.md": "9dee7bcbf351e395a66e042929eede0bb425a92a88db14944b4348f2de656b1b",
+        "sop-templates/weekly-review/templates/review.en.md": "ba727876879208caad46c6ce9c51411e1f451e72003572ccd18de9ef6f55811e",
+        "sop-templates/weekly-review/templates/review.md": "cf8321a1739cecf6286d591e88a6af86831b01c12e77834a873ea497a5db127c"
+      }
     }
   ]
 }