orbi-cli 0.7.2__tar.gz → 0.7.4__tar.gz

{orbi_cli-0.7.2/src/orbi_cli.egg-info → orbi_cli-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orbi-cli
-Version: 0.7.2
+Version: 0.7.4
 Summary: Orbi — local AI development worker: claims GitHub Issues, runs Pi in isolated worktrees, and delivers PRs (GitHub Issues + labels are the only state store).
 Author: xqliu
 License-Expression: AGPL-3.0-only OR LicenseRef-Sustainable-Use-1.0

{orbi_cli-0.7.2 → orbi_cli-0.7.4}/pyproject.toml

@@ -44,7 +44,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "orbi-cli"
-version = "0.7.2"
+version = "0.7.4"
 description = "Orbi — local AI development worker: claims GitHub Issues, runs Pi in isolated worktrees, and delivers PRs (GitHub Issues + labels are the only state store)."
 readme = "README.md"
 requires-python = ">=3.14"

{orbi_cli-0.7.2 → orbi_cli-0.7.4}/src/orbi/__init__.py

@@ -18,4 +18,4 @@ the package would shadow the installed package for every process with
 the checkout root on sys.path. The direct-execution compatibility entry
 is `python3 -m orbi.cli` (development path only).
 """
-__version__ = "0.7.2"
+__version__ = "0.7.4"

orbi_cli-0.7.4/src/orbi/blocked_comment.py

@@ -0,0 +1,35 @@
+"""The ONE exit for a comment that blocks an Issue (Issue #1730).
+
+Ten scenes put an Issue into `ai-blocked` and each own their reason text,
+unblock step, hidden markers and extra fields. What they must NOT each own is
+the pointer to where a person can ask for help: it is appended here, once, so
+a blocked scene added later through this exit carries the community help line
+without anyone remembering to add it.
+
+A comment that is not a blocked scene (a retrying diagnostic, progress, a
+receipt) never goes through this exit and never gets the line.
+"""
+from __future__ import annotations
+
+from orbi import language
+from orbi.delivery_labels import EVENT_BLOCKED
+from orbi.github import apply_label_patch, comment_issue
+
+
+def post_blocked_comment(number: int, *, repo: str, body: str,
+                         current_labels, language_code: str) -> None:
+    """Block `number`: apply the `ai-blocked` label patch, then comment.
+
+    The order is part of the contract: the label transition lands first, the
+    comment second. The body is posted exactly as the scene rendered it,
+    followed by a blank line and the `help.community` line in the run's
+    language — added here and only here, so it appears exactly once.
+    """
+    apply_label_patch(
+        number, repo=repo, event=EVENT_BLOCKED,
+        current_labels=current_labels,
+    )
+    comment_issue(
+        number, repo=repo,
+        body=f"{body}\n\n{language.text(language_code, 'help.community')}",
+    )

{orbi_cli-0.7.2 → orbi_cli-0.7.4}/src/orbi/claim.py

@@ -18,10 +18,11 @@ from typing import NamedTuple
 
 from orbi import milestone as milestone_bookkeeping
 from orbi import scene
+from orbi.blocked_comment import post_blocked_comment
 from orbi.checks import _classify_rollup, _render_check
 from orbi.config import RunnerConfig
 from orbi.delivery_labels import (
-    AWAITING_MERGE_LABEL, BLOCKED_LABEL, EPIC_LABEL, EVENT_BLOCKED,
+    AWAITING_MERGE_LABEL, BLOCKED_LABEL, EPIC_LABEL,
     FIX_NEEDED_LABEL, IN_PROGRESS_LABEL, MERGED_LABEL, P0_LABEL,
     PR_OPENED_LABEL, READY_LABEL, RELEASE_LABEL,
 )
@@ -29,7 +30,7 @@ from orbi.delivery_scene import (
     EXTERNAL_PR_MARKER, DeliveryScene, _issue_label_set, body_markers, classify,
 )
 from orbi.github import (
-    _verify_epic_complete, apply_label_patch, close_issue,
+    _verify_epic_complete, close_issue,
     comment_issue, issue_comments, issue_priority, issue_view,
     latest_run_marker, list_issues, milestone_open_issue_count,
     open_blocker_numbers, open_pr_for_branch, pr_comments,
@@ -644,7 +645,7 @@ def pick_resumable_delivery(
     repo_dir: Path | None = None, *, hooks: ResumeHooks,
     language_code: str,
 ) -> tuple[dict, dict] | None:
-    """Return the newest FREE opened-PR delivery and its resume scene.
+    """Return the oldest FREE opened-PR delivery and its resume scene.
 
     All opened-PR states are scanned: `ai-fix-needed`
     (awaiting the next review session after a finding or a base
@@ -691,12 +692,13 @@ def pick_resumable_delivery(
     excluded: `main` took it before the claim scan and holds it for the
     whole delivery.
 
-    The query page is `max_concurrency + 1` candidates. At most
+    The query page is `max_concurrency + 1` candidates, ordered OLDEST
+    Issue first (`sort:created-asc`, Issue #1734). At most
     `max_concurrency` deliveries can be held by live co-runners, so a
     free candidate is inside the page when one exists; one whose OPEN PR
-    still waits for CI (Issue #1473) is skipped too. The scan reviews the
-    newest FREE candidate (held ones are skipped before any candidate
-    read — an in-flight delivery is never touched).
+    still waits for CI (Issue #1473) is skipped too. The scan reviews
+    the oldest FREE candidate (held ones are skipped before any
+    candidate read — an in-flight delivery is never touched).
     """
     held = slot_held_deliveries(slot_dir, max_concurrency)
     # `label:a,b` is GitHub's OR within one label qualifier
@@ -716,7 +718,7 @@ def pick_resumable_delivery(
         search=(
             f"label:{FIX_NEEDED_LABEL},{PR_OPENED_LABEL},"
             f"{AWAITING_MERGE_LABEL} "
-            f"-label:{BLOCKED_LABEL} -label:{MERGED_LABEL}"
+            f"-label:{BLOCKED_LABEL} -label:{MERGED_LABEL} sort:created-asc"
         ),
         json_fields="number,title,state,url,labels,body",
         limit=max_concurrency + 1,
@@ -795,16 +797,14 @@ def pick_resumable_delivery(
                 LOGGER.error("issue=%s resume scene is missing: %s", number, exc)
                 marker = latest_run_marker(comments)
                 try:
-                    apply_label_patch(
-                        number, repo=repo, event=EVENT_BLOCKED,
-                        current_labels={FIX_NEEDED_LABEL},
-                    )
-                    comment_issue(
+                    post_blocked_comment(
                         number, repo=repo,
                         body=(f"{marker}\n" if marker else "")
                         + language.text(
                             language_code, "claim.scene_missing", error=exc,
                         ),
+                        current_labels={FIX_NEEDED_LABEL},
+                        language_code=language_code,
                     )
                 except Exception:
                     LOGGER.exception("issue=%s failure reporting failed", number)

{orbi_cli-0.7.2 → orbi_cli-0.7.4}/src/orbi/delivery_comment.py

@@ -1,12 +1,15 @@
-"""The runner-owned run comments: the started-Pi and opened-PR scenes
-(Issue #1660).
+"""The runner-owned run comments and the PR body's footer: the
+started-Pi and opened-PR scenes (Issue #1660) and the attribution footer
+(Issue #1729).
 
 Both comments double as the run's machine-readable anchors: the started
 comment carries the `started` kind marker and the opened-PR comment
-carries the `orbi:scene:v1` block the next tick resumes from. Only their
-HEADLINE is human prose and follows the run's bound message language
-(the explicit `language_code`); the hidden
-markers, the field lines and the scene block stay exactly as they were.
+carries the `orbi:scene:v1` block the next tick resumes from. Their
+human text — the headline, the field labels and the stored display
+values — follows the run's bound message language (the explicit
+`language_code`); the hidden markers, the public machine rows
+(`run_id=`, `repo_config:`) and the scene block stay exactly as they
+were.
 
 Extracted from `runner.py` unchanged apart from the language, so the
 frozen runner module does not grow (Issue #1229) and a caller keeps
@@ -19,7 +22,16 @@ from orbi import language, scene
 from orbi.comment_kind import COMMENT_KIND_STARTED
 from orbi.delivery_scene import RunContext
 from orbi.journal import validate_run_id
-from orbi.progress import STARTED_HEADER, _run_info_fields, field_block
+from orbi.progress import (
+    STARTED_HEADER,
+    _run_info_fields,
+    field_block,
+)
+from orbi.progress_display import (
+    field_label,
+    localized_fields,
+    vocabulary,
+)
 
 
 def started_pi_comment_body(ctx: RunContext, run_info: str,
@@ -38,20 +50,38 @@ def started_pi_comment_body(ctx: RunContext, run_info: str,
     if extra_fields:
         fields.update(extra_fields)
     info = _run_info_fields(run_info)
+    rendered_info = {
+        key: (vocabulary(language_code, "priority", info[key])
+              if key == "priority" else info[key])
+        for key in ("run_id", "priority")
+        if key in info
+    }
     headline = language.text(
         language_code, "delivery.started_headline",
     ) + " " + " ".join(
-        f"{key}={info[key]}" for key in ("run_id", "priority")
-        if key in info
+        f"{key}={value}" for key, value in rendered_info.items()
     )
+    detail_keys = {"base_sha", "repo_config", "branch", "session"}
     return field_block(
-        ctx.run_id, headline, fields,
-        detail_keys={"base_sha", "repo_config", "branch", "session"},
+        ctx.run_id, headline, localized_fields(language_code, fields),
+        detail_keys={field_label(language_code, key) for key in detail_keys},
         kind=COMMENT_KIND_STARTED,
         language_code=language_code,
     )
 
 
+def pr_attribution_footer(issue: int, attribution_link: str, *,
+                          language_code: str) -> str:
+    """The PR body's attribution footer in the bound message language.
+
+    The link URL and `#<issue>` are the machine facts and stay verbatim.
+    """
+    return language.text(
+        language_code, "runner.pr_attribution",
+        link=attribution_link, issue=issue,
+    )
+
+
 def opened_pr_comment_body(run_id: str, run_info: str, pr_url: str,
                            external: bool = False, *,
                            language_code: str,
@@ -86,9 +116,10 @@ def opened_pr_comment_body(run_id: str, run_info: str, pr_url: str,
         pr_url=pr_url,
         external="true" if external else "",
     )
+    detail_keys = {"base_sha", "repo_config", "branch", "session"}
     body = field_block(
-        run_id, headline, fields,
-        detail_keys={"base_sha", "repo_config", "branch", "session"},
+        run_id, headline, localized_fields(language_code, fields),
+        detail_keys={field_label(language_code, key) for key in detail_keys},
         language_code=language_code,
     )
     lines = body.splitlines()

{orbi_cli-0.7.2 → orbi_cli-0.7.4}/src/orbi/failure.py

@@ -529,9 +529,7 @@ def _failure_comment_body(*, outcome: str, action: str, reason: str,
     if evidence:
         details.append(evidence.lstrip())
     details.append("</details>")
-    body = "\n\n".join(parts + ["\n".join(details)])
-    if retrying:
-        return body
-    # The blocked diagnostic is a problem a person must resolve, so its
-    # last paragraph is the community help line (Issue #1684).
-    return f"{body}\n\n{message('help.community')}"
+    # The blocked diagnostic's community help line is NOT added here: the
+    # ONE blocked exit appends it to every blocked comment (Issue #1730),
+    # so this renderer and that exit can never both add it.
+    return "\n\n".join(parts + ["\n".join(details)])

{orbi_cli-0.7.2 → orbi_cli-0.7.4}/src/orbi/failure_report.py

@@ -27,12 +27,13 @@ import re
 from pathlib import Path
 
 from orbi import failure, language, runner_health, scene
+from orbi.blocked_comment import post_blocked_comment
 from orbi.comment_kind import (
     COMMENT_KIND_FAILURE,
     comment_kind_marker,
 )
 from orbi.delivery_labels import (
-    EVENT_BLOCKED, EVENT_FIX_NEEDED, FIX_NEEDED_LABEL, IN_PROGRESS_LABEL,
+    EVENT_FIX_NEEDED, FIX_NEEDED_LABEL, IN_PROGRESS_LABEL,
 )
 from orbi.failure import (
     _failure_comment_body, _failure_detail, _failure_summary,
@@ -488,10 +489,6 @@ def block_scene_failure(issue: dict, error: ValueError, repo: str,
     )
     marker = latest_run_marker(comments)
     try:
-        apply_label_patch(
-            number, repo=repo, event=EVENT_BLOCKED,
-            current_labels={FIX_NEEDED_LABEL},
-        )
         # A scene that cannot be recovered is an external
         # precondition the AI cannot fix by itself (the runner cannot
         # derive run_id, branch, worktree or PR without the trusted
@@ -499,7 +496,7 @@ def block_scene_failure(issue: dict, error: ValueError, repo: str,
         # comment states the EXPLICIT reason why automatic recovery is
         # impossible plus the human next step (restore the scene comment,
         # then the ONE shared unblock step of the catalog, Issue #1724).
-        comment_issue(
+        post_blocked_comment(
             number, repo=repo,
             body=(
                 (f"{marker}\n"
@@ -508,6 +505,8 @@ def block_scene_failure(issue: dict, error: ValueError, repo: str,
             ) + language.text(
                 language_code, "failure.scene_blocked", error=error,
             ),
+            current_labels={FIX_NEEDED_LABEL},
+            language_code=language_code,
         )
     except Exception:
         LOGGER.exception("issue=%s failure reporting failed", number)
@@ -529,11 +528,7 @@ def block_repo_config_failure(number: int, source_repo: str,
     cleanly (`main` releases the slot in its `finally`).
     """
     try:
-        apply_label_patch(
-            number, repo=source_repo, event=EVENT_BLOCKED,
-            current_labels=set(current_labels),
-        )
-        comment_issue(
+        post_blocked_comment(
             number, repo=source_repo,
             body=(
                 f"{run_marker(run_id)}\n"
@@ -542,6 +537,8 @@ def block_repo_config_failure(number: int, source_repo: str,
                     language_code, "failure.repo_config_blocked", error=error,
                 )
             ),
+            current_labels=set(current_labels),
+            language_code=language_code,
         )
     except Exception:
         LOGGER.exception("issue=%s repo_config_failure_report_failed", number)
@@ -600,14 +597,10 @@ def _report_resume_failure(*, number: int, source_repo: str, run_id: str,
     verified: continuing on a guessed identity risks a
     silent fresh redo on top of unknown work, and a fresh run would
     lose the existing work. The Issue goes `ai-blocked` ALONE (the
-    claim label removed) with the exact reason, then the community
-    help line — a human decides (restore or remove the worktree, relabel).
+    claim label removed) with the exact reason — a human decides (restore
+    or remove the worktree, relabel).
     """
-    apply_label_patch(
-        number, repo=source_repo, event=EVENT_BLOCKED,
-        current_labels={IN_PROGRESS_LABEL},
-    )
-    comment_issue(
+    post_blocked_comment(
         number, repo=source_repo,
         body=(
             f"{run_marker(run_id)}\n"
@@ -616,8 +609,10 @@ def _report_resume_failure(*, number: int, source_repo: str, run_id: str,
                 language_code, "failure.resume_blocked",
                 detail=_redact_local_paths(_failure_detail(error)),
                 run_id=run_id,
-            ) + f"\n\n{language.text(language_code, 'help.community')}"
+            )
         ),
+        current_labels={IN_PROGRESS_LABEL},
+        language_code=language_code,
     )
 
 
@@ -804,52 +799,47 @@ def report_delivery_failure(
         action if workflow_refusal and action
         else _failure_summary(reason, language_code)
     )
+    scene = scene_line() or "- run: `-`"
     if blocked:
-        apply_label_patch(
-            number, repo=source_repo, event=EVENT_BLOCKED,
-            current_labels=labels,
-        )
-        scene = scene_line() or "- run: `-`"
-        body = _failure_comment_body(
-            outcome="blocked", action=action, reason=reason,
-            diagnosis=diagnosis, scene=scene, evidence=evidence_detail,
-            pr_url=pr_url, issue=issue_context(source_repo, number),
-            run_id=run_id or "-", failure_record=failure_record,
-            language_code=language_code,
-        )
-        if classify:
-            body = body.replace(
-                "</details>",
-                f"\n{language.text(language_code, _BLOCKED_PRECONDITION_PHRASE_KEY)}\n</details>",
-                1,
-            )
-        if blocked_suffix:
-            body = body.replace(
-                "</details>",
-                f"\n{blocked_suffix.lstrip('; ')}\n</details>", 1,
-            )
         outcome = "blocked"
     else:
+        # The recoverable scene is the only one that rewrites labels here:
+        # the blocked exit owns its own patch (Issue #1730).
         apply_label_patch(
             number, repo=source_repo, event=EVENT_FIX_NEEDED,
             current_labels=labels,
         )
-        scene = scene_line() or "- run: `-`"
         if review_scene_block is not None:
             scene += f"\n{_redact_local_paths(review_scene_block)}"
-        body = _failure_comment_body(
-            outcome="fix needed", action=action, reason=reason,
-            diagnosis=diagnosis, scene=scene, evidence=evidence_detail,
-            pr_url=pr_url, issue=issue_context(source_repo, number),
-            run_id=run_id or "-", failure_record=failure_record,
-            language_code=language_code,
-        )
         outcome = "fix needed"
+    body = _failure_comment_body(
+        outcome="blocked" if blocked else "fix needed",
+        action=action, reason=reason, diagnosis=diagnosis, scene=scene,
+        evidence=evidence_detail, pr_url=pr_url,
+        issue=issue_context(source_repo, number), run_id=run_id or "-",
+        failure_record=failure_record, language_code=language_code,
+    )
+    if blocked and classify:
+        body = body.replace(
+            "</details>",
+            f"\n{language.text(language_code, _BLOCKED_PRECONDITION_PHRASE_KEY)}\n</details>",
+            1,
+        )
+    if blocked and blocked_suffix:
+        body = body.replace(
+            "</details>",
+            f"\n{blocked_suffix.lstrip('; ')}\n</details>", 1,
+        )
     # An oversized comment shrinks ONLY its evidence segments, never its
     # structure: a cut lands inside the last fence, so the closer and the
-    # help line render as code in the collapsed block (Issue #1711).
+    # help line render as code in the collapsed block (Issue #1711). The
+    # help line the blocked exit appends is inside that budget too (#1730).
+    help_suffix = (
+        f"\n\n{language.text(language_code, 'help.community')}" if blocked else ""
+    )
     cap = EVIDENCE_SEGMENT_CAP
-    while evidence_detail and cap and len(body) > FAILURE_COMMENT_MAX_CHARS:
+    while (evidence_detail and cap
+           and len(body) + len(help_suffix) > FAILURE_COMMENT_MAX_CHARS):
         cap = max(0, cap - _EVIDENCE_CAP_STEP)
         shrunk = _failure_evidence(
             worktree, exc, language_code=language_code, cap=cap)
@@ -928,9 +918,16 @@ def report_delivery_failure(
                     "failure_comment_deduplicated", issue=number,
                     run_id=run_id, fingerprint=fingerprint,
                 )
-    if post_new_comment:
+    if post_new_comment and blocked:
+        # The blocked exit owns the label patch and the help line (Issue
+        # #1730): the label lands first, the comment second.
+        post_blocked_comment(
+            number, repo=source_repo, body=body,
+            current_labels=labels, language_code=language_code,
+        )
+    elif post_new_comment:
         comment_issue(number, repo=source_repo, body=body)
-        if pr_url and not blocked:
+        if pr_url:
             # The recoverable scene is written to the PR too:
             # the next review session and any human watcher see it where
             # the delivery lives. A blocked Issue is terminal — Issue only.

{orbi_cli-0.7.2 → orbi_cli-0.7.4}/src/orbi/language.py

@@ -37,6 +37,8 @@ import os
 import re
 from typing import Mapping
 
+from orbi.language_terms import DISPLAY_TERMS
+
 LANGUAGE_EN = "en"
 LANGUAGE_ZH = "zh"
 LANGUAGES = (LANGUAGE_EN, LANGUAGE_ZH)
@@ -220,7 +222,7 @@ MESSAGES: dict[str, tuple[str, str]] = {
     "review.findings_heading": ("### Findings", "### 评审发现"),
     "review.findings_milestone": ("review findings: round {round}, {blockers} blocker(s), {majors} major(s) for PR #{pr_number}", "评审发现：第 {round} 轮，PR #{pr_number} 有 {blockers} 个 blocker、{majors} 个 major"),
     "review.findings_outcome": ("**Orbi review findings**\n\nround {round}: {blockers} blocker(s), {majors} major(s); the next review session retries the same PR automatically", "**Orbi 评审发现**\n\n第 {round} 轮：{blockers} 个 blocker、{majors} 个 major；下一个评审 session 会自动重试同一个 PR"),
-    "review.delivered_outcome": ("**Orbi delivered**\n\nPR {pr_url} merged (merge_commit={merge_commit} review_rounds={round})", "**Orbi 已交付**\n\nPR {pr_url} 已合并（merge_commit={merge_commit} review_rounds={round}）"),
+    "review.delivered_outcome": ("**Orbi delivered**\n\nPR {pr_url} merged (merge_commit={merge_commit} review_rounds={round})", "**Orbi 已交付**\n\nPR {pr_url} 已合并（合并提交 {merge_commit}，共 {round} 个评审轮次）"),
     "review.base_advance_heading": ("Orbi base advance retry {round} for PR #{pr_number}:", "Orbi base 同步重试第 {round} 次，PR #{pr_number}："),
     "review.gate_ci_blocked": ("CI merge gate blocked: {message} (run_id={run_id})", "CI 合并门禁被阻塞：{message}（run_id={run_id}）"),
     "review.gate_blocked": ("Merge gate blocked: {message} (run_id={run_id})", "合并门禁被阻塞：{message}（run_id={run_id}）"),
@@ -289,6 +291,7 @@ MESSAGES: dict[str, tuple[str, str]] = {
     "progress.header": ("**Orbi progress**", "**Orbi 进度**"),
     "progress.run_details": ("Run details", "运行详情"),
     "progress.milestone": ("Orbi:", "Orbi："),
+    "progress.milestone_heading": ("{prefix} {headline}", "{prefix}{headline}"),
     "progress.field.role": ("role", "角色"),
     "progress.field.step": ("step", "阶段"),
     "progress.field.reported_at": ("reported at", "报告时间"),
@@ -580,6 +583,10 @@ MESSAGES: dict[str, tuple[str, str]] = {
         "The delivery stopped before it could be completed: {detail}",
         "交付在完成之前停止了：{detail}",
     ),
+    "runner.pr_attribution": (
+        "Built by [Orbi]({link}) from Issue #{issue}",
+        "由 [Orbi]({link}) 构建，基于 Issue #{issue}",
+    ),
     "runner.pr_closed_milestone": ("blocked: PR {pr_url} was closed without a merge; the delivery is terminally failed", "已阻塞：PR {pr_url} 未合并就被关闭；本次交付最终失败"),
     # The standalone terminal failure comment of a closed PR (the
     # milestone above and the progress scene carry the same fact).
@@ -635,9 +642,12 @@ MESSAGES: dict[str, tuple[str, str]] = {
     ),
     # The implement-phase finish: the PR was OPENED, not merged, so this
     # is its own key (`review.delivered_outcome` is the merge outcome).
+    # It names the wait that follows (checks and the review session),
+    # never a wait duration: the tick interval is each deployment's own
+    # setting (Issue #1733).
     "delivery.outcome_pr_opened": (
-        "**Orbi delivered**",
-        "**Orbi 已交付**",
+        "**Orbi opened the PR: waiting for checks and review**",
+        "**Orbi 已打开 PR：等待检查与评审**",
     ),
     "delivery.recoverable_outcome": (
         "**Orbi {recoverable_name}**\n\n"
@@ -665,7 +675,7 @@ MESSAGES: dict[str, tuple[str, str]] = {
     ),
     "review.summary_human_action": ("maintainer-actionable merge retry", "需要维护者处理的合并重试"),
     "review.summary_pass_recorded": ("pass recorded on {head}; merged after CI", "在 {head} 上记录通过；CI 之后合并"),
-    "review.summary_pass_clean": ("pass, no findings", "通过，没有发现"),
+    "review.summary_pass_clean": ("pass, no findings", "通过，没有发现问题"),
     "review.summary_pass_fixed": ("pass, {findings} findings fixed in-session", "通过，会话内修复了 {findings} 项发现"),
 
     # Delivery failures (blocked / fix needed).
@@ -841,12 +851,12 @@ MESSAGES: dict[str, tuple[str, str]] = {
     ),
     "clarify.repair_outcome": (
         "Outcome: what a user does, and what they should see differently.",
-        "Outcome：用户要做什么，以及应该看到什么变化。",
+        "结果：用户要做什么，以及应该看到什么变化。",
     ),
     "clarify.repair_acceptance": (
         "Acceptance: how a finished delivery is told apart from an "
         "unfinished one.",
-        "Acceptance：如何判断交付已完成、而不是半成品。",
+        "验收：如何判断交付已完成、而不是半成品。",
     ),
     "clarify.followup": (
         "Orbi re-checks the ticket when it claims it and starts the "
@@ -881,6 +891,10 @@ MESSAGES: dict[str, tuple[str, str]] = {
     ),
 }
 
+# The display vocabulary of the run comments lives in its own module to
+# keep this catalog owner under the size cap (Issue #1729).
+MESSAGES.update(DISPLAY_TERMS)
+
 
 UNBLOCK_STEP_FIELD = "unblock_step"
 
@@ -905,6 +919,18 @@ def text(language: str, key: str, **fields: object) -> str:
     return template.format(**fields) if fields else template
 
 
+def term(language: str, key: str, default: str) -> str:
+    """One catalogue term, or `default` when the key has no entry.
+
+    Used for display vocabulary whose raw value must survive when the
+    catalogue does not know it (an external tool name, a future phase):
+    the caller keeps the raw value instead of inventing a translation.
+    """
+    if key not in MESSAGES:
+        return default
+    return text(language, key)
+
+
 # --- the model-session boundary -------------------------------------------
 #
 # The instruction is appended to the rendered system prompt AT THE SESSION

orbi_cli-0.7.4/src/orbi/language_terms.py

@@ -0,0 +1,77 @@
+"""The display vocabulary of Orbi's run comments (Issue #1729).
+
+Split out of `language.MESSAGES` so the catalog owner stays under the
+size ratchet's 1,000-line cap. Every key here is a display label or a
+stored display value; `language.MESSAGES` merges this map in place, so
+`language.text()` / `language.term()` remain the ONE reading point. No
+machine row (run marker, `run_id=`, `repo_config:`, `failure:`, receipt
+rows) has an entry here.
+"""
+
+DISPLAY_TERMS: dict[str, tuple[str, str]] = {
+    # Display labels of the started / opened-PR scene field blocks. The
+    # machine rows (`run_id=`, `repo_config:`) have no entry here and stay
+    # verbatim (Issue #1729).
+    "progress.field.base_branch": ("base_branch", "基础分支"),
+    "progress.field.base_sha": ("base_sha", "基础 SHA"),
+    "progress.field.task_type": ("task_type", "任务类型"),
+    "progress.field.external": ("external", "外部"),
+    "progress.field.repo_config_ignored": (
+        "repo_config_ignored", "忽略的仓库配置键",
+    ),
+    "progress.field.repo_config_changed": (
+        "repo_config_changed", "仓库配置变更",
+    ),
+    "progress.field.repo_config_diff": ("repo_config_diff", "仓库配置差异"),
+    # Display labels of the merged milestone's visible rows.
+    "progress.field.result": ("result", "结果"),
+    "progress.field.merge_commit": ("merge_commit", "合并提交"),
+    "progress.field.review_rounds": ("review_rounds", "评审轮次"),
+    "progress.field.external_commits": ("external_commits", "外部提交"),
+    "progress.field.commits": ("commits", "提交数"),
+    # The display vocabulary of the progress values (Issue #1729): the
+    # stored value stays the raw machine word, the rendered one follows
+    # the message language. An unknown value renders verbatim.
+    "progress.role.implement": ("implement", "实现"),
+    "progress.role.review": ("review", "评审"),
+    "progress.role.release": ("release", "发布"),
+    "progress.role.ticket": ("ticket", "工单"),
+    "progress.role.suggest": ("suggest", "建议"),
+    "progress.step.starting": ("starting", "启动中"),
+    "progress.step.implement": ("implement", "实现"),
+    "progress.step.review": ("review", "评审"),
+    "progress.step.checks": ("checks", "检查"),
+    "progress.step.merge": ("merge", "合并"),
+    "progress.step.release": ("release", "发布"),
+    "progress.priority.p0": ("p0", "P0"),
+    "progress.priority.normal": ("normal", "普通"),
+    "progress.tests.passed": ("passed", "通过"),
+    "progress.tests.pending": ("pending", "等待中"),
+    "progress.tests.failed": ("failed: {names}", "失败：{names}"),
+    "progress.activity.read": ("read", "读取"),
+    "progress.activity.edit": ("edit", "编辑"),
+    "progress.activity.command": ("command", "命令"),
+    "progress.activity.analysis": ("analysis", "分析"),
+    "progress.phase.starting": ("starting", "启动中"),
+    "progress.phase.session_pending": ("session_pending", "等待会话"),
+    "progress.phase.request_pending": ("request_pending", "等待响应"),
+    "progress.phase.read": ("read", "读取"),
+    "progress.phase.edit": ("edit", "编辑"),
+    "progress.phase.write": ("write", "写入"),
+    "progress.phase.bash": ("bash", "命令行"),
+    "progress.phase.pr": ("pr", "PR"),
+    "progress.phase.push": ("push", "推送"),
+    "progress.phase.commit": ("commit", "提交"),
+    "progress.phase.base": ("base", "基线"),
+    "progress.phase.worktree": ("worktree", "工作树"),
+    "progress.phase.ui": ("ui", "界面"),
+    "progress.task_type.ticket-only": ("ticket-only", "仅工单"),
+    "progress.task_type.ops": ("ops", "运维"),
+    "progress.boolean.true": ("true", "是"),
+    "progress.boolean.false": ("false", "否"),
+    # The merged milestone's display headline. It is the ONLY milestone
+    # whose event word arrives raw: every other milestone text is already
+    # a localized sentence from `language.text`, so an entry for its
+    # English word would never be reached (Issue #1729).
+    "progress.milestone_headline.merged": ("merged", "已合并"),
+}