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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orbi-cli
-Version: 0.7.1
+Version: 0.7.2
 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.1 → orbi_cli-0.7.2}/pyproject.toml

@@ -44,7 +44,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "orbi-cli"
-version = "0.7.1"
+version = "0.7.2"
 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.1 → orbi_cli-0.7.2}/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.1"
+__version__ = "0.7.2"

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

@@ -29,7 +29,7 @@ from orbi.delivery_scene import (
     EXTERNAL_PR_MARKER, DeliveryScene, _issue_label_set, body_markers, classify,
 )
 from orbi.github import (
-    _epic_audit, _verify_epic_complete, apply_label_patch, close_issue,
+    _verify_epic_complete, apply_label_patch, 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,
@@ -40,8 +40,10 @@ from orbi.journal import LOGGER, current_run_id, event, new_run_id, set_run_id
 from orbi.pilot_slots import slot_held_deliveries, slot_occupancy
 from orbi import language
 from orbi.progress import run_marker
-from orbi.release import release_target_milestone
-from orbi.repo_config import RepoConfigError, RepoPolicy, load_repo_policy
+from orbi.release import _epic_audit, epic_audit_posted, release_target_milestone
+from orbi.repo_config import (
+    RepoConfigError, RepoPolicy, load_repo_policy, merged_repo_language,
+)
 
 
 class ResumeHooks(NamedTuple):
@@ -49,11 +51,14 @@ class ResumeHooks(NamedTuple):
 
     The physical scene handling of `pick_resumable_delivery` plus the PR
     comment writer `reconcile_orphan_prs` reports its orphan through.
+    Every hook that writes a comment takes the claim's already-resolved
+    per-repository `language_code` (Issue #1687): the claim knows the
+    merged repository config before the first comment is written.
     """
     resume_scene: Callable[[list[dict]], dict]
-    route_external_pr_ticket: Callable[[dict, str], bool]
-    block_scene_failure: Callable[[dict, ValueError, str, list[dict]], None]
-    recover_missing_pr_scene: Callable[[dict, str, Path], dict | None]
+    route_external_pr_ticket: Callable[..., bool]
+    block_scene_failure: Callable[..., None]
+    recover_missing_pr_scene: Callable[..., dict | None]
     has_recoverable_pr_scene: Callable[[dict, str, Path], bool]
     comment_pr: Callable[..., None]
 
@@ -195,7 +200,7 @@ def is_release(issue: dict) -> bool:
     return False
 
 
-def reconcile_open_epics(repo: str, run_id: str) -> list[str]:
+def reconcile_open_epics(repo: str, run_id: str, language_code: str) -> list[str]:
     """Sweep open Epics once per tick; ordinary pickup must not depend on it."""
     epics = list_issues(
         repo, state="open", search=f"label:{EPIC_LABEL}",
@@ -211,9 +216,9 @@ def reconcile_open_epics(repo: str, run_id: str) -> list[str]:
             event("epic_kept_open", issue=number, repo=repo, reason=reason)
             evidence.append(f"Epic #{number} kept open: {reason}")
             continue
-        audit = _epic_audit(child_evidence)
+        audit = _epic_audit(child_evidence, None, language_code)
         comments = issue_comments(int(number), repo=repo)
-        if not any(audit in str(comment.get("body", "")) for comment in comments):
+        if not epic_audit_posted(comments, child_evidence):
             comment_issue(int(number), repo=repo,
                          body=f"<!-- orbi:run={run_id} -->\n{audit}\nrun_id={run_id}")
         close_issue(int(number), repo=repo)
@@ -243,7 +248,7 @@ def orphan_pr_branch_issue(head_ref: object) -> int | None:
 
 
 def reconcile_orphan_prs(
-    repo: str, run_id: str, *, hooks: ResumeHooks,
+    repo: str, run_id: str, *, hooks: ResumeHooks, language_code: str,
 ) -> list[str]:
     """Report open delivery PRs whose source Issue is closed.
 
@@ -287,11 +292,10 @@ def reconcile_orphan_prs(
             pr_number, repo=repo,
             body=(
                 f"{ORPHAN_PR_MARK}\n{run_marker(run_id)}\n"
-                f"Orbi orphan PR: the source Issue #{issue_number} is "
-                f"closed while this PR is still open, so it will never "
-                f"be merged automatically. Human decision: merge this "
-                f"PR to keep the work, or close it.\n"
-                f"run_id={run_id}"
+                + language.text(
+                    language_code, "claim.orphan_pr",
+                    issue_number=issue_number, run_id=run_id,
+                )
             ),
         )
         event(
@@ -638,7 +642,7 @@ def pick_next_issue(
 def pick_resumable_delivery(
     repo: str, slot_dir: Path, max_concurrency: int,
     repo_dir: Path | None = None, *, hooks: ResumeHooks,
-    language_code: str = language.DEFAULT_LANGUAGE,
+    language_code: str,
 ) -> tuple[dict, dict] | None:
     """Return the newest FREE opened-PR delivery and its resume scene.
 
@@ -734,15 +738,15 @@ def pick_resumable_delivery(
             # probe the #726 external route first; otherwise this is the
             # ONLY trigger of `block_scene_failure` — a present-but-broken
             # scene is a writer bug or tampering and needs a human.
-            if hooks.route_external_pr_ticket(issue, repo):
+            if hooks.route_external_pr_ticket(issue, repo, language_code=language_code):
                 continue
-            hooks.block_scene_failure(issue, exc, repo, comments)
+            hooks.block_scene_failure(issue, exc, repo, comments, language_code=language_code)
             continue
         except scene.SceneMissingError as exc:
             # No trusted comment carries a scene at all — a distinct branch
             # from corruption. The original #726 incident was
             # exactly this shape, so the external route is probed first.
-            if hooks.route_external_pr_ticket(issue, repo):
+            if hooks.route_external_pr_ticket(issue, repo, language_code=language_code):
                 continue
             # Issue #1216: `awaiting_merge` can deliberately remove the
             # queue label before the delivery returns to `ai-fix-needed`.
@@ -774,7 +778,7 @@ def pick_resumable_delivery(
             # scene comment write. Retry it from the durable local run
             # state; keep ai-pr-opened for another tick if the retry fails.
             recovered = (
-                hooks.recover_missing_pr_scene(issue, repo, repo_dir)
+                hooks.recover_missing_pr_scene(issue, repo, repo_dir, language_code=language_code)
                 if repo_dir is not None else None
             )
             if recovered is not None:
@@ -869,10 +873,12 @@ def pick_next_delivery(
         tick_run_id = new_run_id()
         set_run_id(tick_run_id)
     for repo in repos:
+        repo_language = (language.DEFAULT_LANGUAGE if config is None
+                         else merged_repo_language(config, repo))
         # Epic reconciliation is a per-tick bypass: a broken GitHub query or
         # mutation must never prevent the ordinary delivery scans.
         try:
-            reconcile_open_epics(repo, tick_run_id)
+            reconcile_open_epics(repo, tick_run_id, repo_language)
         except Exception:
             LOGGER.exception("epic_reconcile_failed repo=%s", repo)
         # Milestone reconciliation intentionally follows the Epic sweep so a
@@ -901,18 +907,15 @@ def pick_next_delivery(
         # pattern: a broken GitHub query must never prevent the ordinary
         # delivery scans.
         try:
-            reconcile_orphan_prs(repo, tick_run_id, hooks=hooks)
+            reconcile_orphan_prs(repo, tick_run_id, hooks=hooks,
+                                 language_code=repo_language)
         except Exception:
             LOGGER.exception("orphan_pr_reconcile_failed repo=%s", repo)
-        if config is None:
-            selected = pick_resumable_delivery(
-                repo, slot_dir, max_concurrency, hooks=hooks,
-            )
-        else:
-            selected = pick_resumable_delivery(
-                repo, slot_dir, max_concurrency, config.repo_dir,
-                hooks=hooks, language_code=language.of(config),
-            )
+        selected = pick_resumable_delivery(
+            repo, slot_dir, max_concurrency,
+            repo_dir=config.repo_dir if config is not None else None,
+            hooks=hooks, language_code=repo_language,
+        )
         if selected is not None:
             issue, scene = selected
             return repo, issue, scene

{orbi_cli-0.7.1 → orbi_cli-0.7.2}/src/orbi/clarify.py

@@ -56,7 +56,7 @@ MISSING: dict[str, str] = {
 }
 
 
-def missing_text(item: str, language_code: str = language.DEFAULT_LANGUAGE,
+def missing_text(item: str, language_code: str,
                  ) -> str:
     """The human sentence for one failed check, in one language."""
     return language.text(language_code, MISSING[item])
@@ -154,7 +154,7 @@ def parse_verdict(output: str) -> ClarifyVerdict | None:
 
 def render_comment(issue: dict, verdict: ClarifyVerdict, run_id: str, *,
                    ready_label: str = READY_LABEL,
-                   language_code: str = language.DEFAULT_LANGUAGE) -> str:
+                   language_code: str) -> str:
     """Render the ONE comment that names the missing pieces.
 
     The first line mentions the Issue author (`@<login>`, #1336) so the
@@ -163,7 +163,8 @@ def render_comment(issue: dict, verdict: ClarifyVerdict, run_id: str, *,
     before. `ready_label` is the repository's claim label (default
     `ai-ready`, #527): the repair instruction names the label the claim
     scan really reads, never a hardcoded default a custom-label
-    repository does not use.
+    repository does not use. The comment ends with the community help
+    line (Issue #1684): this stop asks the author to step in.
     """
     def message(key: str, **fields: object) -> str:
         return language.text(language_code, key, **fields)
@@ -185,7 +186,8 @@ def render_comment(issue: dict, verdict: ClarifyVerdict, run_id: str, *,
         f"{message('clarify.repair_acceptance')}\n"
         "```\n\n"
         f"{message('clarify.followup', needs_detail_label=NEEDS_DETAIL_LABEL)}"
-        f"\n\nrun_id={run_id}\n"
+        f"\n\nrun_id={run_id}"
+        f"\n\n{message('help.community')}\n"
     )
 
 

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

@@ -5,7 +5,7 @@ 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
-(`RunContext.language`, or an explicit `language_code`); the hidden
+(the explicit `language_code`); the hidden
 markers, the field lines and the scene block stay exactly as they were.
 
 Extracted from `runner.py` unchanged apart from the language, so the
@@ -22,16 +22,9 @@ from orbi.journal import validate_run_id
 from orbi.progress import STARTED_HEADER, _run_info_fields, field_block
 
 
-def _language_of(ctx: RunContext, language_code: str | None) -> str:
-    """The explicit language, else the run context's bound language."""
-    if language_code is not None:
-        return language_code
-    return getattr(ctx, "language", language.DEFAULT_LANGUAGE)
-
-
 def started_pi_comment_body(ctx: RunContext, run_info: str,
                             extra_fields: dict | None = None, *,
-                            language_code: str | None = None) -> str:
+                            language_code: str) -> str:
     """The start comment doubles as the recoverable run scene.
 
     `extra_fields` carries the repo-config audit fields;
@@ -42,28 +35,26 @@ def started_pi_comment_body(ctx: RunContext, run_info: str,
     """
     fields = _run_info_fields(run_info)
     fields["branch"] = str(ctx.branch)
-    fields["worktree"] = str(ctx.worktree)
     if extra_fields:
         fields.update(extra_fields)
     info = _run_info_fields(run_info)
-    bound = _language_of(ctx, language_code)
     headline = language.text(
-        bound, "delivery.started_headline",
+        language_code, "delivery.started_headline",
     ) + " " + " ".join(
         f"{key}={info[key]}" for key in ("run_id", "priority")
         if key in info
     )
     return field_block(
         ctx.run_id, headline, fields,
-        detail_keys={"base_sha", "repo_config", "branch", "worktree", "session"},
+        detail_keys={"base_sha", "repo_config", "branch", "session"},
         kind=COMMENT_KIND_STARTED,
-        language_code=bound,
+        language_code=language_code,
     )
 
 
 def opened_pr_comment_body(run_id: str, run_info: str, pr_url: str,
                            external: bool = False, *,
-                           language_code: str = language.DEFAULT_LANGUAGE,
+                           language_code: str,
                            ) -> str:
     """The PR-opened comment records the recoverable run scene.
 
@@ -97,7 +88,7 @@ def opened_pr_comment_body(run_id: str, run_info: str, pr_url: str,
     )
     body = field_block(
         run_id, headline, fields,
-        detail_keys={"base_sha", "repo_config", "branch", "worktree", "session"},
+        detail_keys={"base_sha", "repo_config", "branch", "session"},
         language_code=language_code,
     )
     lines = body.splitlines()

{orbi_cli-0.7.1 → orbi_cli-0.7.2}/src/orbi/delivery_scene.py

@@ -204,10 +204,6 @@ class RunContext:
     worktree: Path
     source_repo: str
     pr: str | None = None
-    # The run's bound message language (Issue #1660): `zh` or `en`, bound
-    # from the effective config (host + repository policy) before the
-    # first comment is written. Runtime state only -- never persisted.
-    language: str = "en"
 
 
 @dataclasses.dataclass(frozen=True)

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

@@ -327,7 +327,7 @@ def workflow_permission_refused(detail: str) -> bool:
 
 
 def workflow_permission_cause(
-    language_code: str = language.DEFAULT_LANGUAGE,
+    language_code: str,
 ) -> str:
     """The one-sentence cause of an Actions-workflow permission refusal."""
     return language.text(language_code, _WORKFLOW_PERMISSION_CAUSE_KEY)
@@ -335,7 +335,7 @@ def workflow_permission_cause(
 
 def workflow_permission_action(
     pr_url: str | None = None, *,
-    language_code: str = language.DEFAULT_LANGUAGE,
+    language_code: str,
 ) -> str:
     """The concrete human repair path for the workflow refusal.
 
@@ -358,7 +358,7 @@ def workflow_permission_action(
 
 
 def terminal_action(record: Failure,
-                    language_code: str = language.DEFAULT_LANGUAGE) -> str:
+                    language_code: str) -> str:
     """The reader action for the implement-phase terminal handler.
 
     An unrecognized failure says the cause could not be determined
@@ -410,7 +410,7 @@ def _workflow_permission_line(text: str) -> str | None:
 
 
 def _failure_summary(reason: str,
-                     language_code: str = language.DEFAULT_LANGUAGE) -> str:
+                     language_code: str) -> str:
     """Turn a runner exception description into a short reader summary."""
     command_failed = language.text(language_code, "failure.command_failed")
     stderr_match = re.search(r"\s+stderr=(.*)$", reason,
@@ -452,7 +452,7 @@ def _failure_comment_body(*, outcome: str, action: str, reason: str,
                          diagnosis: str, scene: str, evidence: str,
                          pr_url: str | None, issue: str, run_id: str,
                          failure_record: Failure | None = None,
-                         language_code: str = language.DEFAULT_LANGUAGE,
+                         language_code: str,
                          ) -> str:
     """Build the reader-facing hierarchy shared by classified failures.
 
@@ -529,4 +529,9 @@ def _failure_comment_body(*, outcome: str, action: str, reason: str,
     if evidence:
         details.append(evidence.lstrip())
     details.append("</details>")
-    return "\n\n".join(parts + ["\n".join(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')}"

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

@@ -270,7 +270,7 @@ def _session_summary(session_file: Path,
 
 def _failure_scene(snapshot: dict, *, run_id: str, issue: str, role: str,
                    branch: str, worktree: str, pr_url: str | None = None,
-                   language_code: str = language.DEFAULT_LANGUAGE) -> str:
+                   language_code: str) -> str:
     """Render run facts as wrapping Markdown, never as a host-path dump.
 
     The field labels are human prose and follow the run's message
@@ -312,8 +312,15 @@ def _failure_scene(snapshot: dict, *, run_id: str, issue: str, role: str,
     )
 
 
+# One evidence segment's cap (Issue #1711, `_fenced`'s default) and one
+# fitting step: an oversized comment shrinks these, never its structure.
+EVIDENCE_SEGMENT_CAP = 4000
+_EVIDENCE_CAP_STEP = 500
+
+
 def _failure_evidence(worktree: Path | None, exc: BaseException, *,
-                      language_code: str = language.DEFAULT_LANGUAGE) -> str:
+                      language_code: str,
+                      cap: int = EVIDENCE_SEGMENT_CAP) -> str:
     """Render the bounded evidence that survives terminal worktree cleanup.
 
     Pi subprocess streams come from ``CalledProcessError``. The session and
@@ -322,6 +329,8 @@ def _failure_evidence(worktree: Path | None, exc: BaseException, *,
     the session tail is a structural summary whose duplicates are removed,
     and the full session log is named for the deep-dive. The
     failure reason itself stays the readable head of the comment.
+
+    `cap` bounds each segment, so every fence closes (Issue #1711).
     """
     stderr = getattr(exc, "stderr", None)
     stdout = getattr(exc, "output", None)
@@ -348,11 +357,11 @@ def _failure_evidence(worktree: Path | None, exc: BaseException, *,
     return (
         f"\n\n{language.text(language_code, 'failure.evidence.heading')}\n"
         f"exit_code={return_code if return_code is not None else '<unknown>'}\n"
-        f"\nstderr_tail:\n{_fenced(_redact_local_paths(stderr))}\n"
-        f"\nstdout_tail:\n{_fenced(_redact_local_paths(stdout))}\n"
+        f"\nstderr_tail:\n{_fenced(_redact_local_paths(stderr), cap=cap)}\n"
+        f"\nstdout_tail:\n{_fenced(_redact_local_paths(stdout), cap=cap)}\n"
         f"\n{language.text(language_code, 'failure.evidence.session_last_events', limit=SESSION_SUMMARY_LIMIT, label=session_label)}\n"
-        f"{_fenced(_redact_local_paths(session))}\n"
-        f"\ntest_log_tail:\n{_fenced(_redact_local_paths(test_log))}"
+        f"{_fenced(_redact_local_paths(session), cap=cap)}\n"
+        f"\ntest_log_tail:\n{_fenced(_redact_local_paths(test_log), cap=cap)}"
     )
 
 
@@ -389,8 +398,8 @@ def _snapshot_or_placeholder(session_dir: Path, *, number: int) -> dict:
 _BLOCKED_PRECONDITION_PHRASE_KEY = "failure.blocked_precondition"
 
 
-# The whole failure-comment body is capped well below the
-# GitHub comment limit; the cut is noted with the full session log path.
+# The failure comment's size limit: the body stays under it by shrinking
+# only the evidence segments, never by cutting the comment (Issue #1711).
 FAILURE_COMMENT_MAX_CHARS = 20000
 
 
@@ -461,7 +470,7 @@ def _failure_streak(comments: list, run_id: str,
 
 def block_scene_failure(issue: dict, error: ValueError, repo: str,
                         comments: list[dict], *,
-                        language_code: str = language.DEFAULT_LANGUAGE) -> None:
+                        language_code: str) -> None:
     """Mark an opened-PR Issue `ai-blocked` when its scene is malformed.
 
     The blocked transition is scoped to this one Issue: the
@@ -488,8 +497,8 @@ def block_scene_failure(issue: dict, error: ValueError, repo: str,
         # derive run_id, branch, worktree or PR without the trusted
         # scene comment, so it cannot start a review session): the
         # comment states the EXPLICIT reason why automatic recovery is
-        # impossible plus the human next step (restore the scene or
-        # relabel).
+        # impossible plus the human next step (restore the scene comment,
+        # then the ONE shared unblock step of the catalog, Issue #1724).
         comment_issue(
             number, repo=repo,
             body=(
@@ -506,8 +515,8 @@ def block_scene_failure(issue: dict, error: ValueError, repo: str,
 
 def block_repo_config_failure(number: int, source_repo: str,
                               error: ValueError, run_id: str,
-                              current_labels=(),
-                              language_code: str = language.DEFAULT_LANGUAGE,
+                              current_labels=(), *,
+                              language_code: str,
                               ) -> None:
     """Mark an Issue `ai-blocked` when its repo config is invalid (#527).
 
@@ -583,7 +592,7 @@ def _raise_if_preexisting_ci_failure(
 
 def _report_resume_failure(*, number: int, source_repo: str, run_id: str,
                            error: Exception,
-                           language_code: str = language.DEFAULT_LANGUAGE,
+                           language_code: str,
                            ) -> None:
     """Report a failed resume decision through the terminal path.
 
@@ -591,8 +600,8 @@ 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 in the failure comment
-    — a human decides (restore or remove the worktree, then re-label).
+    claim label removed) with the exact reason, then the community
+    help line — a human decides (restore or remove the worktree, relabel).
     """
     apply_label_patch(
         number, repo=source_repo, event=EVENT_BLOCKED,
@@ -605,8 +614,9 @@ def _report_resume_failure(*, number: int, source_repo: str, run_id: str,
             f"{comment_kind_marker(COMMENT_KIND_FAILURE)}\n"
             + language.text(
                 language_code, "failure.resume_blocked",
-                detail=_failure_detail(error), run_id=run_id,
-            )
+                detail=_redact_local_paths(_failure_detail(error)),
+                run_id=run_id,
+            ) + f"\n\n{language.text(language_code, 'help.community')}"
         ),
     )
 
@@ -621,7 +631,7 @@ def report_delivery_failure(
     blocked_suffix: str = "", review_round: int | None = None,
     review_scene_block: str | None = None,
     finish: bool = True, publisher: ProgressPublisher | None = None,
-    language_code: str = language.DEFAULT_LANGUAGE,
+    language_code: str,
 ) -> str:
     """Report one delivery failure through the classified-failure flow.
 
@@ -727,11 +737,11 @@ def report_delivery_failure(
             streak = _failure_streak(history, run_id, fingerprint)
             if streak + 1 >= FAILURE_STREAK_LIMIT:
                 blocked = True
-                reason = (
-                    f"{reason}; the same failure has now occurred "
-                    f"{streak + 1} consecutive times for run_id={run_id} "
-                    f"(fingerprint {fingerprint}) with unchanged "
-                    "preconditions — a dead loop, not a transient error"
+                reason += language.text(
+                    language_code,
+                    "delivery.failure_streak_escalation",
+                    count=streak + 1, run_id=run_id,
+                    fingerprint=fingerprint,
                 )
                 event(
                     "failure_streak_escalated", level=logging.ERROR,
@@ -783,10 +793,8 @@ def report_delivery_failure(
         current_labels if current_labels is not None
         else issue_labels(number, source_repo)
     )
-    evidence_detail = (
-        _failure_evidence(worktree, exc, language_code=language_code)
-        if evidence else ""
-    )
+    evidence_detail = _failure_evidence(
+        worktree, exc, language_code=language_code) if evidence else ""
     # The milestone is a short mobile notification: for the workflow
     # refusal it must carry the same cause AND repair path as the
     # detailed comment, so it shows the reader-facing action instead of
@@ -837,23 +845,16 @@ def report_delivery_failure(
             language_code=language_code,
         )
         outcome = "fix needed"
-    if len(body) > FAILURE_COMMENT_MAX_CHARS:
-        # The comment body is capped; the cut preserves the
-        # cause-first head and names the full session log for the part
-        # that was dropped.
-        session_file = _latest_session_file(worktree)
-        body = (
-            body[:FAILURE_COMMENT_MAX_CHARS]
-            + language.text(
-                language_code, "failure.comment_truncated",
-                chars=FAILURE_COMMENT_MAX_CHARS,
-                log=(
-                    language.text(
-                        language_code, "failure.scene.local_session_log")
-                    if session_file else "<unavailable>"
-                ),
-            )
-        )
+    # 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).
+    cap = EVIDENCE_SEGMENT_CAP
+    while evidence_detail and cap and len(body) > FAILURE_COMMENT_MAX_CHARS:
+        cap = max(0, cap - _EVIDENCE_CAP_STEP)
+        shrunk = _failure_evidence(
+            worktree, exc, language_code=language_code, cap=cap)
+        body = body.replace(evidence_detail.lstrip(), shrunk.lstrip(), 1)
+        evidence_detail = shrunk
     if run_id:
         # The hidden fingerprint marker rides under the run marker on
         # the recoverable path only: a blocked Issue is terminal, so

{orbi_cli-0.7.1 → orbi_cli-0.7.2}/src/orbi/github.py

@@ -648,13 +648,6 @@ def _epic_child_evidence(repo: str, kind: str, number: int) -> str:
     return f"Issue #{number} closed"
 
 
-def _epic_audit(child_evidence: list[str], version: str | None = None) -> str:
-    prefix = f" for {version}" if version else ""
-    return (f"Epic reconciliation{prefix}: complete; "
-            f"children: {', '.join(child_evidence)}; "
-            "no open native blockers/dependencies.")
-
-
 # Comments are trusted through one of two channels — a repo maintainer
 # association, or the currently authenticated runner account itself (the
 # login fallback in `_comment_is_trusted`, which requires the local gh
@@ -688,9 +681,9 @@ def apply_label_patch(number: int, *, repo: str, event: str,
     patch. The patch is applied through `edit_issue`: one call for the
     add plus the first remove, then one call per extra remove (the exact
     same `edit_issue` kwargs the pre-#175 code emitted). A no-op patch
-    (nothing to add or remove) applies nothing. A NEWLY added attention
-    label then notifies the person through `notify` (Issue #1673),
-    after the last write.
+    (nothing to add or remove) applies nothing. After the last write,
+    `notify.patch_applied` (Issue #1673) owns the one notification the
+    patch warrants — a newly added attention label, never the wait.
     """
     to_add, to_remove = label_patch(event, current_labels)
     if not to_add and not to_remove:
@@ -704,17 +697,15 @@ def apply_label_patch(number: int, *, repo: str, event: str,
     edit_issue(number, **kwargs)
     for label in to_remove[1:]:
         edit_issue(number, repo=repo, remove=label)
-    # Notify only a NEWLY added attention label, and only when
-    # notifications are on (no extra gh call when they are off).
-    if (
-        to_add
-        and to_add[0] in notify.ATTENTION_LABELS
-        and to_add[0] not in set(current_labels)
-        and notify.enabled()
-    ):
-        notify.label_added(
-            repo, number, to_add[0], _issue_title(number, repo=repo),
-        )
+    # Notifying the person is a pure bypass owned by `notify` (Issues
+    # #1673/#1691): it decides from the event, the added labels and the
+    # current labels, and reads the title lazily through the callable --
+    # so a tick with notifications off makes no extra `gh` call.
+    notify.patch_applied(
+        event, to_add, current_labels,
+        repo=repo, number=number,
+        read_title=lambda: _issue_title(number, repo=repo),
+    )
 
 
 def _issue_title(number: int, *, repo: str) -> str | None:

{orbi_cli-0.7.1 → orbi_cli-0.7.2}/src/orbi/human_review.py

@@ -111,7 +111,7 @@ def _is_deploy_path(path: str) -> bool:
 
 def build_checklist(*, test_status: str | None,
                     changed_files: list[str] | None,
-                    language_code: str = language.DEFAULT_LANGUAGE) -> dict:
+                    language_code: str) -> dict:
     """Split the delivery's evidence into the two checklist columns.
 
     `test_status` is the PR head's CI check status (Issue #1613:
@@ -156,7 +156,7 @@ def build_checklist(*, test_status: str | None,
 
 def render_checklist_comment(*, run_id: str, pr_url: str,
                              checklist: dict,
-                             language_code: str = language.DEFAULT_LANGUAGE,
+                             language_code: str,
                              ) -> str:
     """Render the Issue comment: run marker, both columns, machine block.
 
@@ -164,7 +164,8 @@ def render_checklist_comment(*, run_id: str, pr_url: str,
     `Orbi review round ` (`review_rounds_so_far` counts it and the
     checklist would burn the bounded review budget); an empty column 2
     says so explicitly and does not require the label; the wording never
-    claims a guarantee of direction.
+    claims a guarantee of direction. A non-empty column 2 (a person
+    must confirm) ends with the community help line (Issue #1684).
     """
     def message(key: str, **fields: object) -> str:
         return language.text(language_code, key, **fields)
@@ -214,4 +215,9 @@ def render_checklist_comment(*, run_id: str, pr_url: str,
         ),
         "-->",
     ]
+    if column2:
+        # A person must confirm: this problem message ends with the
+        # community help line (Issue #1684). An empty column 2 needs no
+        # human, so it stays exactly as before.
+        lines += ["", message("help.community")]
     return "\n".join(lines)