[CI] ci: add @aiter-bot review (self-hosted GLM PR reviewer)

.claude/skills/review-pr/RUNNER-SETUP.md

@@ -0,0 +1,48 @@
+# Runner setup — aiter-review-bot
+
+The `@aiter-bot review` workflow (`.github/workflows/aiter-review-bot.yml`) runs on a
+self-hosted runner labeled `self-hosted, box308`. This is what that runner must provide.
+Verify the box with `bash .claude/skills/review-pr/preflight.sh` — it checks every item below
+and prints a fix hint for each red. This doc explains how to make those checks pass; it holds
+no machine-specific paths (each site fills in its own).
+
+## 1. Register the runner (needs repo admin)
+
+Creating a runner registration token requires **repo admin** on this repository (a `maintain`
+or `push` role is not enough — the `registration-token` API returns 403). Either get an admin
+to add the runner, or reuse a runner your org already has by giving it the labels above.
+
+Install the runner on a **data volume with room to spare**, not `$HOME` or `/`: each review
+checks out the repo and builds two worktrees (~180 MB apiece) under the runner's `_work`, and
+a box whose root fs fills up will fail mid-review. Register with the labels `box308`.
+
+## 2. Box config via the runner `.env` (loaded into every job)
+
+The workflow's review step sets no environment on purpose, so the box-specific config lives in
+`<runner-dir>/.env`, which the GitHub Actions runner injects into every job. Set at least:
+
+    TMPDIR=<data-volume>/tmp                 # review scratch (WORK) lands here, off the root fs
+    AITER_REVIEW_AGENT=<path>/claude          # the headless Claude entrypoint for this box
+    ANTHROPIC_BASE_URL=http://localhost:30000 # the model endpoint (a local GLM here)
+    ANTHROPIC_MODEL=<model>                    # e.g. a local GLM served by the box
+    ANTHROPIC_SMALL_FAST_MODEL=<model>         # same model, or the session-title call warns
+    PATH=<data-volume>/bin:/usr/local/bin:/usr/bin:/bin   # a gh >= 2.24 must be first (fetch needs baseRefOid)
+    GH_CONFIG_DIR=<data-volume>/gh-config      # gh auth stored here, NOT as GH_TOKEN in the env
+
+## 3. gh auth off the job environment
+
+`fetch.sh` calls `gh` to read the PR. Authenticate it under `GH_CONFIG_DIR` (from a token with
+`public_repo` read) rather than exporting `GH_TOKEN`, so the headless review agent never
+inherits a token from its environment:
+
+    GH_CONFIG_DIR=<data-volume>/gh-config gh auth login --with-token < token-file
+
+## 4. Bot identity
+
+Set the repo secret `AITER_BOT_TOKEN` to the bot account's PAT (`public_repo`). The workflow
+uses it only in the claim and publish steps — never in the review step — so the review agent
+cannot read it.
+
+## 5. Verify
+
+    bash .claude/skills/review-pr/preflight.sh    # all green = @aiter-bot review runs end to end

.claude/skills/review-pr/_apply_refutation.py

@@ -0,0 +1,51 @@
+"""Drop the findings the independent refuter KILLED from the card, so the seven gates see only
+what survived. In the interactive review flow a human removes KILLED findings by hand before
+finalizing; run_one.sh calls this to do it headlessly -- without it, the very first review whose
+refuter kills a finding (its designed job) fails triage.py's independent gate and loses the whole
+review.
+
+independent.txt has one `SURVIVED|KILLED -- ...` line per card finding, in the card's order
+(triage.py's independent gate relies on that same 1:1 order). We map by position and, only when
+the counts line up 1:1, remove the KILLED findings; on any mismatch we change nothing and let the
+gate report it, rather than guess.
+
+Usage: _apply_refutation.py <card.md> <independent.txt>
+"""
+
+import pathlib
+import re
+import sys
+
+FIND_PREFIX = ("\U0001F534", "⚠", "\U0001F4DD")  # 🔴 ⚠️ 📝
+VERDICT = re.compile(r"^\s*(SURVIVED|KILLED)\b")
+
+
+def main():
+    if len(sys.argv) < 3:
+        print("usage: _apply_refutation.py <card.md> <independent.txt>"); return 2
+    card_p = pathlib.Path(sys.argv[1])
+    indep = pathlib.Path(sys.argv[2]).read_text(encoding="utf-8")
+    verdicts = [m.group(1) for m in (VERDICT.match(l) for l in indep.splitlines()) if m]
+
+    lines = card_p.read_text(encoding="utf-8").splitlines(keepends=True)
+    finding_lines = [i for i, l in enumerate(lines) if l.lstrip().startswith(FIND_PREFIX)]
+
+    if not finding_lines or not verdicts:
+        print("nothing to apply (no findings or no verdicts)"); return 0
+    if len(verdicts) != len(finding_lines):
+        # Ambiguous mapping -- do not guess which finding a verdict refers to. Leave the card as
+        # is; the independent gate will report the count mismatch.
+        print(f"skip: {len(finding_lines)} card findings vs {len(verdicts)} verdicts -- mismatch")
+        return 0
+
+    drop = {finding_lines[i] for i, v in enumerate(verdicts) if v == "KILLED"}
+    if not drop:
+        print("no KILLED findings; card unchanged"); return 0
+    kept = [l for i, l in enumerate(lines) if i not in drop]
+    card_p.write_text("".join(kept), encoding="utf-8")
+    print(f"applied refutation: dropped {len(drop)} KILLED finding(s), kept {len(finding_lines) - len(drop)}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.claude/skills/review-pr/_collect.py

@@ -0,0 +1,100 @@
+import os
+import pathlib
+import shutil
+import subprocess
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import _lib
+
+HERE = pathlib.Path(os.path.dirname(os.path.abspath(__file__)))
+if len(sys.argv) < 2:
+    sys.exit("usage: collect.sh <WORK_DIR> [PR_number]")
+W = sys.argv[1]
+num, _ = _lib.pr_meta(W)
+pr = sys.argv[2] if len(sys.argv) > 2 else (str(num) if num else None)
+if not pr:
+    sys.exit(
+        f"cannot read PR number ({W}/pr_meta.json missing or corrupt); pass it explicitly: collect.sh {W} <PR_number>"
+    )
+
+missing = [f for f in _lib.REQUIRED if not _lib.nonempty(os.path.join(W, f))]
+if missing:
+    # Validate before making the dir: a refused collect must not leave an empty dir, or it
+    # gets picked up by the report index.
+    sys.exit(
+        f"refusing to collect: {W} is missing required artifacts {', '.join(missing)}.\n"
+        f"{W} is an incomplete WORK dir (fetch likely failed) -- re-run the review."
+    )
+
+D = HERE / "reports" / f"PR-{pr}"
+D.mkdir(parents=True, exist_ok=True)
+
+# SKILL.md's `not independently refuted` is a conditional annotation (written only "when
+# there is no independent reader"). We split Step 7.7 to a separate agent, so when the worker
+# wrote the card it did not yet know whether a refuter would run and had to annotate "none".
+# If independent.txt exists, an independent refutation did happen and the suffix must come off,
+# or the card is lying. Mechanically restore the state SKILL.md specifies; no review judgement.
+_card = pathlib.Path(W) / "card.md"
+if _lib.nonempty(os.path.join(W, "independent.txt")):
+    _t = _card.read_text(encoding="utf-8")
+    if "not independently refuted" in _t:
+        _t2 = _t.replace(" — not independently refuted", "").replace(
+            " -- not independently refuted", ""
+        )
+        _card.write_text(_t2, encoding="utf-8")
+        print(
+            "  removed 'not independently refuted' from the card (independent.txt exists)"
+        )
+
+copied = 0
+for f in _lib.REQUIRED + _lib.OPTIONAL:
+    src = os.path.join(W, f)
+    if _lib.nonempty(src):
+        shutil.copy2(src, D / f)
+        copied += 1
+    elif f in _lib.OPTIONAL:
+        (D / f).unlink(missing_ok=True)
+
+
+# GATES.txt is this report's credibility receipt; keep it with the artifacts — write failures in too
+_proj = subprocess.run(
+    ["git", "-C", str(HERE), "rev-parse", "--show-toplevel"],
+    capture_output=True,
+    text=True,
+    check=False,
+).stdout.strip() or os.path.dirname(os.path.dirname(os.path.dirname(str(HERE))))
+res = _lib.run_gates(W, _proj)
+npass = sum(1 for _, rc, _, _ in res if rc == 0)
+lines = [f"======== SEVEN GATES ({W}) ========"]
+for name, rc, first, full in res:
+    lines.append(
+        f"  {'✅' if rc == 0 else '❌'} {name:<12} "
+        + (
+            first
+            if rc == 0
+            else f"exit={rc}\n" + "\n".join("       " + l for l in full.split("\n"))
+        )
+    )
+lines.append(f"======== {npass} green / {len(res)-npass} red ========")
+(D / "GATES.txt").write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+print(f"  collected into {D}  ({copied} items, {npass}/7 green)")
+
+# Refresh the aggregate report right after collect (a manual step gets forgotten, and a
+# forgotten one leaves the report inconsistent with reality). _report.py is a dev-only tool
+# and may not ship; skip it silently when absent.
+_rep = HERE / "_report.py"
+if _rep.is_file():
+    subprocess.run([sys.executable, str(_rep)], check=False)
+if npass != 7:
+    print(
+        f"  ⚠️ this report has {7-npass} gate(s) unpassed — the index marks it; do not treat it as a conclusion"
+    )
+
+# collect is the last automatic step; the next step, git commit, is manual, and "a manual
+# step gets forgotten" is exactly why #4860 sat unstaged in the worktree. Remind explicitly
+# and point at the breakpoint detector.
+print(
+    f"  ↳ not landed yet: git add reports/PR-{pr}/ && git commit to finish."
+)

.claude/skills/review-pr/_gates.py

@@ -0,0 +1,40 @@
+import os
+import subprocess
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import _lib
+
+if len(sys.argv) < 2:
+    sys.exit("usage: gates.sh <WORK_DIR> [PROJECT_ROOT]")
+W = sys.argv[1]
+if len(sys.argv) > 2:
+    PROJ = sys.argv[2]
+else:
+    PROJ = subprocess.run(
+        [
+            "git",
+            "-C",
+            os.path.dirname(os.path.abspath(__file__)),
+            "rev-parse",
+            "--show-toplevel",
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+    ).stdout.strip()
+
+print(f"======== SEVEN GATES ({W}) ========")
+res = _lib.run_gates(W, PROJ)
+npass = 0
+for name, rc, first, full in res:
+    if rc == 0:
+        npass += 1
+        print(f"  ✅ {name:<12} {first}")
+    else:
+        print(f"  ❌ {name:<12} exit={rc}")
+        for l in full.split("\n"):
+            print(f"       {l}")
+nfail = len(res) - npass
+print(f"======== {npass} green / {nfail} red ========")
+sys.exit(0 if nfail == 0 else 1)