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

package/runtime/plugins/project-orchestrator/runtime/case.py

@@ -18,10 +18,16 @@ import tempfile
 from datetime import datetime
 from pathlib import Path
 from typing import Any
+import case_structure as structure  # noqa: E402
+from i18n_orchestrator import _  # noqa: E402
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import private_paths  # noqa: E402
+from i18n_orchestrator import _  # noqa: E402
 
 PLUGIN_ROOT = Path(__file__).resolve().parents[1]
 DEFAULT_SCHEMA = PLUGIN_ROOT / "references" / "case.schema.json"
-TEMPLATE = PLUGIN_ROOT / "templates" / "CASE.md"
+TEMPLATES = {"zh": PLUGIN_ROOT / "templates" / "CASE.md", "en": PLUGIN_ROOT / "templates" / "CASE.en.md"}
 PROFILE = Path(".agents/moe.sakanano.agent-pack/project.json")
 CASE_DIR_RE = re.compile(r"^CASE-([0-9]{8})-([0-9]{3})-([a-z0-9]+(?:-[a-z0-9]+)*)$")
 SLUG_RE = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
@@ -30,7 +36,7 @@ CREDENTIAL_RE = re.compile(r"(credential|secret|token|password|passwd|private-?k
 STATUS_ORDER = {"active": 0, "waiting": 1, "captured": 2, "suspended": 3, "done": 4, "abandoned": 5}
 CLOSED = {"done", "abandoned"}
 FIELD_ORDER = ("schema_version", "id", "title", "status", "sensitivity", "source", "goal", "done_when",
-               "current_state", "next_action", "waiting_for", "resume_when", "artifact_mode")
+               "current_state", "next_action", "waiting_for", "resume_when", "artifact_mode", "sop")
 LIST_FIELDS = ("aliases", "legacy_ids", "tags", "deliverables", "evidence")
 MAX_CASE_BYTES = 2 * 1024 * 1024
 
@@ -52,12 +58,12 @@ def _scalar(value: str, key: str) -> Any:
         try:
             parsed = json.loads(value)
         except ValueError as exc:
-            raise CaseError(f"{key}: 字符串必须是 JSON 双引号格式", "frontmatter") from exc
+            raise CaseError(_("{0}: 字符串必须是 JSON 双引号格式").format(key), "frontmatter") from exc
         if not isinstance(parsed, str):
-            raise CaseError(f"{key}: 只支持字符串", "frontmatter")
+            raise CaseError(_("{0}: 只支持字符串").format(key), "frontmatter")
         return parsed
     if value[:1] in ("[", "{", "|", ">", "'", "&", "*", "!"):
-        raise CaseError(f"{key}: 不支持该 YAML 写法", "frontmatter")
+        raise CaseError(_("{0}: 不支持该 YAML 写法").format(key), "frontmatter")
     return value
 
 
@@ -67,10 +73,10 @@ def parse_frontmatter(text: str) -> dict:
     while index < len(lines):
         line = lines[index]
         if not line or line[0].isspace() or ":" not in line:
-            raise CaseError(f"frontmatter 第 {index + 1} 行格式不支持", "frontmatter")
+            raise CaseError(_("frontmatter 第 {0} 行格式不支持").format(index + 1), "frontmatter")
         key, value = line.split(":", 1)
         if not KEY_RE.fullmatch(key) or key in data:
-            raise CaseError(f"frontmatter 键无效或重复：{key}", "frontmatter")
+            raise CaseError(_("frontmatter 键无效或重复：{0}").format(key), "frontmatter")
         if value.strip():
             data[key] = _scalar(value.strip(), key)
             index += 1
@@ -85,16 +91,16 @@ def parse_frontmatter(text: str) -> dict:
 
 def read_case(path: Path) -> tuple[dict, str]:
     if path.is_symlink():
-        raise CaseError(f"拒绝符号链接：{path.name}", "symlink")
+        raise CaseError(_("拒绝符号链接：{0}").format(path.name), "symlink")
     raw = path.read_bytes()
     if len(raw) > MAX_CASE_BYTES:
-        raise CaseError("CASE.md 超过 2 MiB", "oversize")
+        raise CaseError(_("CASE.md 超过 2 MiB"), "oversize")
     text = raw.decode("utf-8")
     if not text.startswith("---\n"):
-        raise CaseError("CASE.md 必须以 --- 开头", "frontmatter")
+        raise CaseError(_("CASE.md 必须以 --- 开头"), "frontmatter")
     end = text.find("\n---\n", 3)
     if end < 0:
-        raise CaseError("CASE.md 缺少 frontmatter 结束标记", "frontmatter")
+        raise CaseError(_("CASE.md 缺少 frontmatter 结束标记"), "frontmatter")
     return parse_frontmatter(text[4:end]), text[end + 5:]
 
 
@@ -119,13 +125,13 @@ def render_frontmatter(data: dict) -> str:
 
 def validate_schema(data: dict, schema: dict) -> list[str]:
     """The keyword subset the default schema uses: const, enum, type, pattern, minLength, items, uniqueItems."""
-    errors = [f"缺少字段：{key}" for key in schema.get("required", []) if key not in data]
+    errors = [_("缺少字段：{0}").format(key) for key in schema.get("required", []) if key not in data]
     properties = schema.get("properties", {})
     for key, value in data.items():
         rule = properties.get(key)
         if rule is None:
             if schema.get("additionalProperties") is False:
-                errors.append(f"未知字段：{key}")
+                errors.append(_("未知字段：{0}").format(key))
             continue
         errors.extend(f"{key}: {problem}" for problem in _check(value, rule))
     return errors
@@ -134,24 +140,24 @@ def validate_schema(data: dict, schema: dict) -> list[str]:
 def _check(value: Any, rule: dict) -> list[str]:
     problems = []
     if "const" in rule and value != rule["const"]:
-        problems.append(f"必须为 {rule['const']!r}")
+        problems.append(_("必须为 {0!r}").format(rule['const']))
     if "enum" in rule and value not in rule["enum"]:
-        problems.append("取值必须是 " + "、".join(map(str, rule["enum"])))
+        problems.append(_("取值必须是 ") + _("、").join(map(str, rule["enum"])))
     kind = rule.get("type")
     if kind == "string" and not isinstance(value, str):
-        problems.append("必须是字符串")
+        problems.append(_("必须是字符串"))
     if kind == "array":
         if not isinstance(value, list):
-            return problems + ["必须是列表"]
+            return problems + [_("必须是列表")]
         if rule.get("uniqueItems") and len(value) != len(set(map(str, value))):
-            problems.append("列表有重复项")
+            problems.append(_("列表有重复项"))
         for item in value:
             problems.extend(_check(item, rule.get("items", {})))
     if isinstance(value, str):
         if len(value) < rule.get("minLength", 0):
-            problems.append("不能为空")
+            problems.append(_("不能为空"))
         if "pattern" in rule and not re.search(rule["pattern"], value):
-            problems.append("格式不符合")
+            problems.append(_("格式不符合"))
     return problems
 
 
@@ -164,12 +170,13 @@ class Project:
         try:
             profile = json.loads(profile_path.read_text(encoding="utf-8"))
         except FileNotFoundError as exc:
-            raise CaseError(f"缺少 Project Profile：{PROFILE}", "profile-missing") from exc
+            raise CaseError(_("缺少 Project Profile：{0}").format(PROFILE), "profile-missing") from exc
         except (OSError, ValueError) as exc:
-            raise CaseError(f"Project Profile 无法解析：{exc}", "profile-invalid") from exc
+            raise CaseError(_("Project Profile 无法解析：{0}").format(exc), "profile-invalid") from exc
+        self.language = structure.language_of(profile)  # the language the project's files are written in
         work = profile.get("work") or {}
         if work.get("mode") != "case-workspace":
-            raise CaseError("项目未启用 case-workspace（Profile work.mode）", "mode")
+            raise CaseError(_("项目未启用 case-workspace（Profile work.mode）"), "mode")
         case = work.get("case") or {}
         self.case_root = self._inside(case.get("root") or "cases", "work.case.root")
         self.project_command = case.get("command")
@@ -180,17 +187,17 @@ class Project:
     def _inside(self, value: str, label: str) -> Path:
         relative = Path(value)
         if relative.is_absolute() or ".." in relative.parts or not relative.parts:
-            raise CaseError(f"{label} 必须是项目内相对路径", "profile-invalid")
+            raise CaseError(_("{0} 必须是项目内相对路径").format(label), "profile-invalid")
         current = self.root
         for part in relative.parts:
             current = current / part
             if current.is_symlink():
-                raise CaseError(f"{label} 不能经过符号链接", "symlink")
+                raise CaseError(_("{0} 不能经过符号链接").format(label), "symlink")
         return self.root / relative
 
     def require_writable(self) -> None:
         if self.project_command:
-            raise CaseError(f"项目声明了自己的 Case 工具（{self.project_command}），请用它修改 Case", "project-tool")
+            raise CaseError(_("项目声明了自己的 Case 工具（{0}），请用它修改 Case").format(self.project_command), "project-tool")
 
     def case_dirs(self) -> list[Path]:
         if not self.case_root.is_dir():
@@ -204,7 +211,7 @@ class Project:
             lowered = term.lower()
             matches = [path for path in self.case_dirs() if lowered in path.name.lower()]
         if len(matches) != 1:
-            raise CaseError(f"找到 {len(matches)} 个匹配 {term!r} 的 Case", "not-found" if not matches else "ambiguous")
+            raise CaseError(_("找到 {0} 个匹配 {1!r} 的 Case").format(len(matches), term), "not-found" if not matches else "ambiguous")
         return matches[0]
 
     def relative(self, path: Path) -> str:
@@ -228,9 +235,9 @@ def write_atomic(path: Path, content: str) -> None:
 def clean(value: str | None, label: str, *, required: bool = False) -> str:
     value = (value or "").strip()
     if any(character in value for character in "\r\n\x00"):
-        raise CaseError(f"{label} 只能是单行文本")
+        raise CaseError(_("{0} 只能是单行文本").format(label))
     if required and not value:
-        raise CaseError(f"{label} 不能为空")
+        raise CaseError(_("{0} 不能为空").format(label))
     return value
 
 
@@ -239,7 +246,7 @@ def clean(value: str | None, label: str, *, required: bool = False) -> str:
 def _new_case_fields(project: Project, args: argparse.Namespace) -> tuple[str, dict]:
     slug = clean(args.slug, "--slug", required=True)
     if not SLUG_RE.fullmatch(slug) or CREDENTIAL_RE.search(slug):
-        raise CaseError("--slug 只能用小写字母、数字和连字符，且不能含凭据类词语")
+        raise CaseError(_("--slug 只能用小写字母、数字和连字符，且不能含凭据类词语"))
     status = args.status
     fields = {
         "title": clean(args.title, "--title", required=True),
@@ -247,7 +254,7 @@ def _new_case_fields(project: Project, args: argparse.Namespace) -> tuple[str, d
         "next_action": clean(args.next_action, "--next-action", required=status == "active"),
         "done_when": clean(args.done_when, "--done-when"),
         "source": clean(args.source, "--source"),
-        "current_state": clean(args.current_state, "--current-state") or "刚创建",
+        "current_state": clean(args.current_state, "--current-state") or structure.text("just_created", project.language),
     }
     return slug, fields
 
@@ -255,18 +262,21 @@ def _new_case_fields(project: Project, args: argparse.Namespace) -> tuple[str, d
 def _render_new_case(project: Project, args: argparse.Namespace, fields: dict, case_id: str,
                      stamp: str) -> str:
     data = {"schema_version": "1.0", "id": case_id, "title": fields["title"], "status": args.status,
-            "sensitivity": "shared", "source": fields["source"], "goal": fields["goal"],
+            "sensitivity": (getattr(args, "sensitivity", None) or "shared"), "source": fields["source"], "goal": fields["goal"],
             "done_when": fields["done_when"], "current_state": fields["current_state"],
             "next_action": fields["next_action"], "artifact_mode": "case-local",
+            "sop": (getattr(args, "sop", None) or ""),
             "aliases": [], "legacy_ids": [], "tags": sorted(set(args.tag)), "deliverables": [], "evidence": [],
             "created_at": stamp, "updated_at": stamp}
     data = {key: value for key, value in data.items() if key in project.schema.get("properties", data)}
+    if not data.get("sop"):
+        data.pop("sop", None)
     errors = validate_schema(data, project.schema)
     if errors:
-        raise CaseError("新 Case 不符合 Schema：" + "；".join(errors), "schema")
-    body = TEMPLATE.read_text(encoding="utf-8")
+        raise CaseError(_("新 Case 不符合 Schema：") + _("；").join(errors), "schema")
+    body = TEMPLATES[project.language].read_text(encoding="utf-8")
     for key, value in {**fields, "created_at": stamp}.items():
-        body = body.replace("{{" + key + "}}", value or "待明确")
+        body = body.replace("{{" + key + "}}", value or structure.text("to_define", project.language))
     return render_frontmatter(data) + "\n" + body
 
 
@@ -304,18 +314,31 @@ def create(project: Project, args: argparse.Namespace) -> dict:
         except FileExistsError:
             continue
     else:
-        raise CaseError("今天的 Case 序号已用完", "sequence-exhausted")
+        raise CaseError(_("今天的 Case 序号已用完"), "sequence-exhausted")
     try:
         text = _render_new_case(project, args, fields, case_id, now())
     except CaseError:
         directory.rmdir()
         raise
     write_atomic(directory / "CASE.md", text)
-    return {"ok": True, "id": case_id, "path": project.relative(directory / "CASE.md"), "status": args.status}
+    result = {"ok": True, "id": case_id, "path": project.relative(directory / "CASE.md"), "status": args.status}
+    hints = sop_hints(project, "case.created", read_case(directory / "CASE.md")[0])
+    if hints:
+        result["sop_events"] = hints
+    return result
+
+
+def sop_hints(project: Project, event: str, data: dict) -> list[dict]:
+    """哪些已启用的 SOP 在监听这个事件；尽力而为，SOP 目录有问题时不能让 Case 的写入失败。"""
+    try:
+        import sop as sop_tool  # noqa: PLC0415 - sop.py 反过来依赖本模块，延迟导入避免循环
+        return sop_tool.event_hints(project.root, event, data)
+    except Exception:  # noqa: BLE001
+        return []
 
 
 def summary(project: Project, directory: Path) -> dict:
-    data, _ = read_case(directory / "CASE.md")
+    data, _body = read_case(directory / "CASE.md")
     return {"id": data.get("id", directory.name), "title": data.get("title", ""), "status": data.get("status", ""),
             "next_action": data.get("next_action", ""), "updated_at": data.get("updated_at", ""),
             "path": project.relative(directory / "CASE.md")}
@@ -339,9 +362,11 @@ def list_cases(project: Project, args: argparse.Namespace) -> dict:
     return {"ok": True, "cases": cases, "invalid": invalid}
 
 
-def append_section(body: str, heading: str, line: str) -> str:
-    """Append a bullet under ``## heading``, replacing the template's placeholder text."""
-    marker = f"## {heading}\n"
+def append_section(body: str, heading: str, line: str, language: str = "zh") -> str:
+    """Append a bullet under the section ``heading`` (either language's name, or a logical key), replacing the placeholder text.
+
+    The file's own spelling of the heading wins; a missing section is created in ``language``."""
+    marker = f"## {structure.resolve(body, heading, language)}\n"
     start = body.find(marker)
     if start < 0:
         return body.rstrip("\n") + f"\n\n{marker}\n- {line}\n"
@@ -349,7 +374,7 @@ def append_section(body: str, heading: str, line: str) -> str:
     next_heading = body.find("\n## ", section_start)
     end = len(body) if next_heading < 0 else next_heading + 1
     section = body[section_start:end].strip("\n")
-    if section in ("暂无。", "无。", "待执行。"):
+    if section in structure.PLACEHOLDERS:
         section = ""
     section = (section + "\n" if section else "") + f"- {line}"
     return body[:section_start] + "\n" + section + "\n\n" + body[end:].lstrip("\n")
@@ -364,9 +389,9 @@ def plan_update(project: Project, args: argparse.Namespace) -> tuple[Path, str,
     current = path.read_text(encoding="utf-8")
     expected_digest = getattr(args, "expect_sha256", None)
     if expected_digest and hashlib.sha256(current.encode("utf-8")).hexdigest() != expected_digest:
-        raise CaseError("Case 在预览之后被修改过（内容摘要不一致），请重新读取", "conflict")
+        raise CaseError(_("Case 在预览之后被修改过（内容摘要不一致），请重新读取"), "conflict")
     if args.expect_updated_at and data.get("updated_at") != args.expect_updated_at:
-        raise CaseError("Case 已被其他人修改（updated_at 不一致），请重新读取", "conflict")
+        raise CaseError(_("Case 已被其他人修改（updated_at 不一致），请重新读取"), "conflict")
     stamp = now()
     changed = []
     for flag, key in (("status", "status"), ("next_action", "next_action"), ("current_state", "current_state"),
@@ -382,45 +407,71 @@ def plan_update(project: Project, args: argparse.Namespace) -> tuple[Path, str,
             if item not in data.setdefault(key, []):
                 data[key].append(item)
                 changed.append(key)
+    if getattr(args, "sensitivity", None):
+        if data.get("sensitivity", "shared") != args.sensitivity:
+            data["sensitivity"] = args.sensitivity
+            changed.append("sensitivity")
+    elif data.get("sensitivity") != "private" and _touches_private(project, directory, args):
+        data["sensitivity"] = "private"  # 用到了私有目录里的内容：默认标为 private（要改回去用 --sensitivity shared）
+        changed.append("sensitivity")
     if data.get("status") == "active" and not data.get("next_action"):
-        raise CaseError("active 的 Case 需要 next_action")
+        raise CaseError(_("active 的 Case 需要 next_action"))
     if data.get("status") == "waiting" and not data.get("waiting_for"):
-        raise CaseError("waiting 的 Case 需要 waiting_for")
+        raise CaseError(_("waiting 的 Case 需要 waiting_for"))
+    language = project.language
     if "current_state" in changed:
-        body = _replace_section(body, "当前可信状态", data["current_state"])
+        body = _replace_section(body, "current_state", data["current_state"], language)
     if "next_action" in changed:
-        body = _replace_section(body, "下一动作", data["next_action"] or "待明确")
+        body = _replace_section(body, "next_action", data["next_action"] or structure.text("to_define", language), language)
     if args.log:
-        body = append_section(body, "工作记录", f"{stamp} {clean(args.log, '--log', required=True)}")
-        changed.append("工作记录")
+        changed.append(structure.resolve(body, "work_log", language))
+        body = append_section(body, "work_log", f"{stamp} {clean(args.log, '--log', required=True)}", language)
     if args.decision:
-        body = append_section(body, "决策记录", f"{stamp} {clean(args.decision, '--decision', required=True)}")
-        changed.append("决策记录")
+        changed.append(structure.resolve(body, "decisions", language))
+        body = append_section(body, "decisions", f"{stamp} {clean(args.decision, '--decision', required=True)}", language)
     if args.result:
-        body = _replace_section(body, "结果", clean(args.result, "--result", required=True))
-        changed.append("结果")
+        changed.append(structure.resolve(body, "result", language))
+        body = _replace_section(body, "result", clean(args.result, "--result", required=True), language)
     if not changed:
-        raise CaseError("没有要更新的内容")
+        raise CaseError(_("没有要更新的内容"))
     data["updated_at"] = stamp
     errors = validate_schema(data, project.schema)
     if errors:
-        raise CaseError("更新后不符合 Schema：" + "；".join(errors), "schema")
+        raise CaseError(_("更新后不符合 Schema：") + _("；").join(errors), "schema")
     return path, current, render_frontmatter(data) + body, {
         "ok": True, "id": data["id"], "changed": sorted(set(changed)), "updated_at": stamp,
         "path": project.relative(path)}
 
 
+def _touches_private(project: Project, directory: Path, args: argparse.Namespace) -> bool:
+    """这次登记的交付物或证据是否在私有目录里（路径可以相对项目根，也可以相对 Case 目录）。"""
+    dirs = private_paths.declared(project.root)
+    if not dirs:
+        return False
+    for value in [*getattr(args, "add_deliverable", []), *getattr(args, "add_evidence", [])]:
+        for candidate in (value, str(directory / value)):
+            if private_paths.is_private(project.root, candidate, dirs):
+                return True
+    return False
+
+
 def update(project: Project, args: argparse.Namespace) -> dict:
     path, current, text, result = plan_update(project, args)
     # Re-read right before replacing: a write that landed after planning must not be lost.
     if path.read_text(encoding="utf-8") != current:
-        raise CaseError("Case 刚被其他人修改，请重新读取", "conflict")
+        raise CaseError(_("Case 刚被其他人修改，请重新读取"), "conflict")
+    was_closed = read_case(path)[0].get("status") in CLOSED
     write_atomic(path, text)
+    data, _unused = read_case(path)
+    if data.get("status") in CLOSED and not was_closed:
+        hints = sop_hints(project, "case.closed", data)
+        if hints:
+            result["sop_events"] = hints
     return result
 
 
-def _replace_section(body: str, heading: str, text: str) -> str:
-    marker = f"## {heading}\n"
+def _replace_section(body: str, heading: str, text: str, language: str = "zh") -> str:
+    marker = f"## {structure.resolve(body, heading, language)}\n"
     start = body.find(marker)
     if start < 0:
         return body.rstrip("\n") + f"\n\n{marker}\n{text}\n"
@@ -440,12 +491,12 @@ def validate(project: Project, args: argparse.Namespace) -> dict:
             data, body = read_case(path)
             errors = validate_schema(data, project.schema)
             if data.get("id") != directory.name:
-                errors.append("id 与目录名不一致")
+                errors.append(_("id 与目录名不一致"))
             if data.get("status") == "active" and not data.get("next_action"):
-                errors.append("active 的 Case 需要 next_action")
+                errors.append(_("active 的 Case 需要 next_action"))
             seen.setdefault(data.get("id"), []).append(project.relative(path))
         except FileNotFoundError:
-            errors = ["缺少 CASE.md"]
+            errors = [_("缺少 CASE.md")]
         except (CaseError, OSError, UnicodeDecodeError) as exc:
             errors = [str(exc)]
         results.append({"path": project.relative(path), "valid": not errors, "errors": errors})
@@ -454,12 +505,12 @@ def validate(project: Project, args: argparse.Namespace) -> dict:
             for result in results:
                 if result["path"] in paths:
                     result["valid"] = False
-                    result["errors"].append(f"重复的 id：{case_id}")
+                    result["errors"].append(_("重复的 id：{0}").format(case_id))
     return {"ok": all(result["valid"] for result in results), "results": results}
 
 
 def parser() -> argparse.ArgumentParser:
-    result = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    result = argparse.ArgumentParser(description=_("默认 Case 工具：在 case-workspace 项目里新建、列出、查看、更新与校验 Case。"))
     result.add_argument("--project", type=Path, default=Path.cwd())
     result.add_argument("--output", choices=("text", "json"), default="text")
     # The same options are accepted after the subcommand, where people tend to type them.
@@ -471,9 +522,9 @@ def parser() -> argparse.ArgumentParser:
     def command(name: str, help_text: str) -> argparse.ArgumentParser:
         return sub.add_parser(name, parents=[shared], help=help_text)
 
-    new = command("new", "新建 Case 目录与 CASE.md")
+    new = command("new", _("新建 Case 目录与 CASE.md"))
     new.add_argument("--title", required=True)
-    new.add_argument("--slug", required=True, help="目录名后缀：小写字母、数字与连字符")
+    new.add_argument("--slug", required=True, help=_("目录名后缀：小写字母、数字与连字符"))
     new.add_argument("--goal", required=True)
     new.add_argument("--next-action")
     new.add_argument("--status", choices=("active", "captured"), default="active")
@@ -481,12 +532,15 @@ def parser() -> argparse.ArgumentParser:
     new.add_argument("--source")
     new.add_argument("--current-state")
     new.add_argument("--tag", action="append", default=[])
-    listing = command("list", "列出 Case（默认不含已关闭）")
+    new.add_argument("--sensitivity", choices=("shared", "private"), default="shared",
+                     help=_("用到私有目录（privacy.forbidden_default_reads，缺省 private/）里内容的 Case 用 private"))
+    new.add_argument("--sop", help=_("这个 Case 是 SOP 的一次执行：<sop-id>@<版本>（通常由 sop.py run 填写）"))
+    listing = command("list", _("列出 Case（默认不含已关闭）"))
     listing.add_argument("--status", choices=tuple(STATUS_ORDER))
     listing.add_argument("--all", action="store_true")
-    show = command("show", "查看一个 Case 的字段与正文")
+    show = command("show", _("查看一个 Case 的字段与正文"))
     show.add_argument("case")
-    change = command("update", "更新状态、下一动作，追加工作记录、决策、交付物与证据")
+    change = command("update", _("更新状态、下一动作，追加工作记录、决策、交付物与证据"))
     change.add_argument("case")
     change.add_argument("--status", choices=tuple(STATUS_ORDER))
     change.add_argument("--title")
@@ -494,34 +548,39 @@ def parser() -> argparse.ArgumentParser:
     change.add_argument("--current-state")
     change.add_argument("--waiting-for")
     change.add_argument("--resume-when")
-    change.add_argument("--result", help="替换「结果」段")
-    change.add_argument("--log", help="向「工作记录」追加一条")
-    change.add_argument("--decision", help="向「决策记录」追加一条")
+    change.add_argument("--result", help=_("替换「结果」段"))
+    change.add_argument("--log", help=_("向「工作记录」追加一条"))
+    change.add_argument("--decision", help=_("向「决策记录」追加一条"))
     change.add_argument("--add-deliverable", action="append", default=[])
     change.add_argument("--add-evidence", action="append", default=[])
+    change.add_argument("--sensitivity", choices=("shared", "private"),
+                        help=_("改 Case 的敏感度；登记私有目录里的交付物或证据时会自动改为 private"))
     change.add_argument("--add-tag", action="append", default=[])
     change.add_argument("--add-alias", action="append", default=[])
-    change.add_argument("--expect-updated-at", help="只在 updated_at 等于该值时写入，避免覆盖并发修改")
-    change.add_argument("--expect-sha256", help="只在 CASE.md 内容摘要等于该值时写入（比 updated_at 更严格）")
-    check = command("validate", "按 Schema 校验 Case")
+    change.add_argument("--expect-updated-at", help=_("只在 updated_at 等于该值时写入，避免覆盖并发修改"))
+    change.add_argument("--expect-sha256", help=_("只在 CASE.md 内容摘要等于该值时写入（比 updated_at 更严格）"))
+    check = command("validate", _("按 Schema 校验 Case"))
     check.add_argument("case", nargs="?")
     return result
 
 
 def render_text(command: str, result: dict) -> str:
     if command == "list":
-        lines = [f"{item['status']:9} {item['id']}  {item['title']}" + (f"\n          下一步：{item['next_action']}"
+        lines = [f"{item['status']:9} {item['id']}  {item['title']}" + (_("\n          下一步：{0}").format(item['next_action'])
                                                                           if item["next_action"] else "")
                  for item in result["cases"]]
         lines += [f"invalid   {item['path']}: {item['error']}" for item in result["invalid"]]
-        return "\n".join(lines) or "没有 Case。"
+        return "\n".join(lines) or _("没有 Case。")
     if command == "validate":
         lines = [f"{'ok' if item['valid'] else 'FAIL'}  {item['path']}" +
                  "".join(f"\n      {error}" for error in item["errors"]) for item in result["results"]]
-        return "\n".join(lines) or "没有 Case。"
+        return "\n".join(lines) or _("没有 Case。")
     if command == "show":
         return result["content"]
-    return json.dumps(result, ensure_ascii=False, indent=2)
+    text = json.dumps(result, ensure_ascii=False, indent=2)
+    for hint in result.get("sop_events") or []:
+        text += _("\n命中流程 {0}（{1}）：{2}\n  是否按它执行由用户决定；确认后运行：{3}").format(hint['id'], hint['title'], hint['trigger'], hint['command'])
+    return text
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -534,7 +593,7 @@ def main(argv: list[str] | None = None) -> int:
             result = list_cases(project, args)
         elif args.command == "show":
             directory = project.find(args.case)
-            data, _ = read_case(directory / "CASE.md")
+            data, _body = read_case(directory / "CASE.md")
             result = {"ok": True, "case": data, "path": project.relative(directory / "CASE.md"),
                       "content": (directory / "CASE.md").read_text(encoding="utf-8")}
         elif args.command == "update":

package/runtime/plugins/project-orchestrator/runtime/case_structure.py

@@ -0,0 +1,71 @@
+"""Case 正文的结构：小节名与默认文字，按项目文件语言（Project Profile 的 ``language``）。
+
+文件里写什么语言是项目的属性，随项目同步，不随命令行界面语言（AGENTHELM_LANG）变化：``language`` 为 ``en`` 的项目
+新建的 Case 用英文小节名与默认文字，缺省或 ``zh`` 的项目保持原来的中文。读取与更新时两种小节名都认，所以
+旧 Case、换过语言的项目与手写的 Case 都能照常追加记录；找不到小节时按项目语言新建。
+"""
+from __future__ import annotations
+
+LANGUAGES = ("zh", "en")
+SECTIONS = {
+    "current_state": ("当前可信状态", "Current trusted state"),
+    "next_action": ("下一动作", "Next action"),
+    "decisions": ("决策记录", "Decision log"),
+    "work_log": ("工作记录", "Work log"),
+    "blockers": ("阻塞与恢复条件", "Blockers and resume conditions"),
+    "result": ("结果", "Result"),
+}
+# 默认文字：新建 Case 时写进去的字段占位。
+TEXTS = {
+    "just_created": ("刚创建", "Just created"),
+    "to_define": ("待明确", "To be defined"),
+}
+# 模板里的空小节占位；第一次追加记录时被替换掉。
+PLACEHOLDERS = ("暂无。", "无。", "待执行。", "None yet.", "None.", "Pending.")
+
+
+def language_of(profile: dict) -> str:
+    """The project's file language; projects that predate the field stay Chinese."""
+    value = profile.get("language")
+    return value if value in LANGUAGES else "zh"
+
+
+def names(key: str) -> tuple[str, ...]:
+    return SECTIONS[key]
+
+
+def key_of(name: str) -> str:
+    """The logical section for a logical key or for a heading in either language."""
+    if name in SECTIONS:
+        return name
+    for key, variants in SECTIONS.items():
+        if name in variants:
+            return key
+    raise KeyError(name)
+
+
+def heading(key: str, language: str) -> str:
+    return SECTIONS[key][LANGUAGES.index(language)]
+
+
+def existing_heading(body: str, key: str) -> str | None:
+    """The heading of this section as the file spells it, if present in either language."""
+    for name in SECTIONS[key]:
+        if f"## {name}\n" in body or body.endswith(f"## {name}"):
+            return name
+    return None
+
+
+def resolve(body: str, name: str, language: str) -> str:
+    """The heading to use for a section: the file's own spelling, else the project language's.
+
+    A heading outside the Case vocabulary (for example the ones SOP adds) is used as written."""
+    try:
+        key = key_of(name)
+    except KeyError:
+        return name
+    return existing_heading(body, key) or heading(key, language)
+
+
+def text(key: str, language: str) -> str:
+    return TEXTS[key][LANGUAGES.index(language)]