claude-dev-env 8.17.1 → 8.19.0

package/rules/review-closure-is-a-check.md

@@ -4,7 +4,7 @@
 
 ## Rule
 
-A review finding on the head is answered before the pull request merges. The agent driving it replies, pushes the fix, or both. The check named `Review closure` reads that state on every push and on every review event, and reports red while a finding waits.
+A review finding on the head is answered before the pull request merges. The agent driving it replies, pushes the fix, or both. The check named `Review closure` reads that state on every push, on every review event, and on every top-level comment, and reports red while a finding waits.
 
 One command prints the same verdict:
 
@@ -24,6 +24,7 @@ It prints `CLOSED` and exits 0 when every finding on the head is answered. It pr
 | A red-circle finding | A reply from the driving account, or a push that replaced the code |
 | A thread the driving account opened | Itself |
 | A blocking `Claude Approvals` row | A push, which moves the head the check reports on |
+| A top-level comment on the pull request | A later top-level comment from the driving account |
 
 A red circle marks a finding a review states as blocking, so resolution in silence leaves it open. The reply says what changed or why the finding stands, and the reviewer reads it beside the diff.
 
@@ -31,7 +32,9 @@ The driving account is the one that opened the pull request. Where the agent com
 
 ## Where the check runs
 
-`.github/workflows/review-closure.yml` runs it here on a push to a pull request, on a submitted or dismissed review, and on a review comment. Each run reports on the pull request's head commit, so a finding posted after the last push still turns the check red.
+`.github/workflows/review-closure.yml` runs it here on a push to a pull request, on a submitted or dismissed review, on a review comment, and on a top-level comment posted or edited on a pull request. Each run reports on the pull request's head commit, so a finding posted after the last push still turns the check red.
+
+A top-level comment arrives as an `issue_comment` event, and a run on that event belongs to the default branch commit. The comment job reads the pull request's head, runs the same command, and posts the verdict on that head through the Checks API as a `Review closure` check run. The token belongs to the GitHub Actions app, so that check run carries the same name and app as the pull request job's own, and the newest one on the head is the one branch rules read.
 
 A private repository that installs this package runs the same command from its own workflow, against the revision of this package that its workflow pins.
 

package/scripts/dev_env_scripts_constants/digest_check_constants.py

@@ -0,0 +1,76 @@
+"""Constants for the digest page check.
+
+A digest page summarizes a set of changes for a reader who reads little and
+needs to know every change. These values set the word budgets, the attribute
+that marks one card, the elements that count as a picture, and the finding
+messages.
+"""
+
+from __future__ import annotations
+
+import re
+
+UTF8_ENCODING: str = "utf-8"
+
+CARD_WORD_BUDGET: int = 25
+
+LEAD_WORD_BUDGET: int = 40
+
+ALL_PICTURE_TAGS: frozenset[str] = frozenset({"img", "svg", "canvas", "picture"})
+
+ALL_HIDDEN_TEXT_TAGS: frozenset[str] = frozenset(
+    {"head", "script", "style", "template", "noscript"}
+)
+
+ALL_RAW_TEXT_TAGS: frozenset[str] = frozenset({"script", "style"})
+
+ALL_VOID_TAGS: frozenset[str] = frozenset(
+    {
+        "area",
+        "base",
+        "br",
+        "col",
+        "embed",
+        "hr",
+        "img",
+        "input",
+        "link",
+        "meta",
+        "source",
+        "track",
+        "wbr",
+    }
+)
+
+MARKUP_PATTERN: re.Pattern[str] = re.compile(
+    r"<!--.*?-->|<![^>]*>"
+    r"|<(?P<closing>/?)(?P<tag_name>[a-zA-Z][\w:-]*)"
+    r"(?P<attributes>(?:[^>\"']|\"[^\"]*\"|'[^']*')*?)(?P<self_closing>/?)>",
+    re.DOTALL,
+)
+
+CARD_ATTRIBUTE_PATTERN: re.Pattern[str] = re.compile(
+    r"\bdata-digest-card\s*=\s*(?:\"(?P<double>[^\"]*)\"|'(?P<single>[^']*)')"
+)
+
+WORD_PATTERN: re.Pattern[str] = re.compile(r"[^\W_][\w'’-]*")
+
+MISSING_CARD_FINDING: str = "missing card {card_id}: the page leaves it out"
+
+DUPLICATE_CARD_FINDING: str = "card {card_id} appears {count} times"
+
+CARD_OVER_BUDGET_FINDING: str = (
+    "card {card_id} carries {word_count} words; the budget is {budget}"
+)
+
+CARD_WITHOUT_PICTURE_FINDING: str = "card {card_id} has no picture"
+
+LEAD_OVER_BUDGET_FINDING: str = (
+    "text outside the cards carries {word_count} words; the budget is {budget}"
+)
+
+CLEAN_VERDICT: str = "CLEAN: {card_count} cards, every one present"
+
+EXIT_CLEAN: int = 0
+
+EXIT_FINDINGS: int = 1

package/scripts/dev_env_scripts_constants/review_closure_constants.py

@@ -234,8 +234,33 @@ REVIEW_COMMENTS_ENDPOINT_TEMPLATE: str = (
 )
 """REST route carrying one page of a pull request's review comments."""
 
-REVIEW_COMMENT_PAGE_SIZE: int = 100
-"""How many review comments one page carries."""
+COMMENT_PAGE_SIZE: int = 100
+"""How many review or top-level comments one page carries."""
 
-MAX_REVIEW_COMMENT_PAGES: int = 20
-"""How many comment pages one run reads before it stops."""
+MAX_COMMENT_PAGES: int = 20
+"""How many comment pages one listing reads before it stops."""
+
+TOP_LEVEL_COMMENTS_ENDPOINT_TEMPLATE: str = (
+    "{api_root}/repos/{slug}/issues/{number}/comments?per_page={page_size}&page={page}"
+)
+"""REST route carrying one page of a pull request's top-level comments."""
+
+HTML_URL_KEY: str = "html_url"
+"""Field carrying the page address of a top-level comment."""
+
+CREATED_AT_KEY: str = "created_at"
+"""Field carrying when a top-level comment was posted."""
+
+UPDATED_AT_KEY: str = "updated_at"
+"""Field carrying when a top-level comment was last edited."""
+
+TOP_LEVEL_OPEN_REASON_TEMPLATE: str = (
+    "a top-level comment from {author} with no later top-level comment from "
+    "the driving agent"
+)
+"""Why a top-level comment stays open until the agent posts after it."""
+
+UNREADABLE_TOP_LEVEL_COMMENT_TEMPLATE: str = (
+    "a top-level comment carries an unreadable timestamp: {record}"
+)
+"""What to report when a top-level comment's timestamps do not parse."""

package/scripts/digest_check.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""Check that a digest page lets its reader read less and still know all.
+
+A digest page summarizes a set of changes, such as the pull requests merged in
+a day. Each change gets one card, marked with ``data-digest-card="<id>"``,
+that holds its picture and its one-line change.
+
+::
+
+    python digest_check.py summary.html --expect 4701 4702 4715
+    ok:   CLEAN: 3 cards, every one present
+    flag: missing card 4715: the page leaves it out
+    flag: card 4701 carries 31 words; the budget is 25
+    flag: card 4702 has no picture
+
+The check also reports lead text over its own budget and a card marked twice.
+"""
+
+from __future__ import annotations
+
+import argparse
+import html
+import re
+import sys
+from collections import Counter
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from dev_env_scripts_constants.digest_check_constants import (
+    ALL_HIDDEN_TEXT_TAGS,
+    ALL_PICTURE_TAGS,
+    ALL_RAW_TEXT_TAGS,
+    ALL_VOID_TAGS,
+    CARD_ATTRIBUTE_PATTERN,
+    CARD_OVER_BUDGET_FINDING,
+    CARD_WITHOUT_PICTURE_FINDING,
+    CARD_WORD_BUDGET,
+    CLEAN_VERDICT,
+    DUPLICATE_CARD_FINDING,
+    EXIT_CLEAN,
+    EXIT_FINDINGS,
+    LEAD_OVER_BUDGET_FINDING,
+    LEAD_WORD_BUDGET,
+    MARKUP_PATTERN,
+    MISSING_CARD_FINDING,
+    UTF8_ENCODING,
+    WORD_PATTERN,
+)
+
+
+@dataclass
+class DigestCard:
+    """One marked card on a digest page."""
+
+    card_id: str
+    word_count: int = 0
+    has_picture: bool = False
+
+
+@dataclass
+class DigestPage:
+    """Every marked card on a page, and the words outside them."""
+
+    all_cards: list[DigestCard] = field(default_factory=list)
+    lead_word_count: int = 0
+
+
+@dataclass
+class _OpenElement:
+    tag_name: str
+    card: DigestCard | None
+    is_hidden: bool
+
+
+def _innermost_card(all_open: list[_OpenElement]) -> DigestCard | None:
+    for each_open in reversed(all_open):
+        if each_open.card is not None:
+            return each_open.card
+    return None
+
+
+def _count_words(page: DigestPage, all_open: list[_OpenElement], text: str) -> None:
+    if any(each_open.is_hidden for each_open in all_open):
+        return
+    word_count = len(WORD_PATTERN.findall(html.unescape(text)))
+    enclosing_card = _innermost_card(all_open)
+    if enclosing_card is None:
+        page.lead_word_count += word_count
+    else:
+        enclosing_card.word_count += word_count
+
+
+def _close_element(all_open: list[_OpenElement], tag_name: str) -> None:
+    for each_index in range(len(all_open) - 1, -1, -1):
+        if all_open[each_index].tag_name == tag_name:
+            del all_open[each_index:]
+            return
+
+
+def _open_element(
+    page: DigestPage, all_open: list[_OpenElement], tag_match: re.Match[str]
+) -> None:
+    tag_name = tag_match.group("tag_name").lower()
+    if tag_name in ALL_PICTURE_TAGS:
+        enclosing_card = _innermost_card(all_open)
+        if enclosing_card is not None:
+            enclosing_card.has_picture = True
+    if tag_name in ALL_VOID_TAGS or tag_match.group("self_closing"):
+        return
+    new_card = None
+    card_match = CARD_ATTRIBUTE_PATTERN.search(tag_match.group("attributes"))
+    if card_match is not None:
+        card_id = card_match.group("double") or card_match.group("single") or ""
+        new_card = DigestCard(card_id=html.unescape(card_id).strip())
+        page.all_cards.append(new_card)
+    all_open.append(_OpenElement(tag_name, new_card, tag_name in ALL_HIDDEN_TEXT_TAGS))
+
+
+def read_digest_page(page_html: str) -> DigestPage:
+    """Return the marked cards and lead word count of one page.
+
+    Args:
+        page_html: Full HTML source of the page.
+
+    Returns:
+        The parsed page, with words counted toward their innermost card.
+    """
+    page = DigestPage()
+    all_open: list[_OpenElement] = []
+    position = 0
+    while position < len(page_html):
+        tag_match = MARKUP_PATTERN.search(page_html, position)
+        text_end = len(page_html) if tag_match is None else tag_match.start()
+        _count_words(page, all_open, page_html[position:text_end])
+        if tag_match is None:
+            break
+        position = tag_match.end()
+        if tag_match.group("tag_name") is None:
+            continue
+        tag_name = tag_match.group("tag_name").lower()
+        if tag_match.group("closing"):
+            _close_element(all_open, tag_name)
+            continue
+        _open_element(page, all_open, tag_match)
+        if tag_name in ALL_RAW_TEXT_TAGS and not tag_match.group("self_closing"):
+            raw_end = page_html.lower().find(f"</{tag_name}", position)
+            position = len(page_html) if raw_end == -1 else raw_end
+    return page
+
+
+def _coverage_findings(page: DigestPage, all_expected_ids: list[str]) -> list[str]:
+    card_counts = Counter(each_card.card_id for each_card in page.all_cards)
+    all_findings = [
+        MISSING_CARD_FINDING.format(card_id=each_expected_id)
+        for each_expected_id in all_expected_ids
+        if card_counts[each_expected_id] == 0
+    ]
+    all_findings.extend(
+        DUPLICATE_CARD_FINDING.format(card_id=each_card_id, count=each_count)
+        for each_card_id, each_count in card_counts.items()
+        if each_count > 1
+    )
+    return all_findings
+
+
+def _budget_findings(page: DigestPage) -> list[str]:
+    all_findings: list[str] = []
+    for each_card in page.all_cards:
+        if each_card.word_count > CARD_WORD_BUDGET:
+            all_findings.append(
+                CARD_OVER_BUDGET_FINDING.format(
+                    card_id=each_card.card_id,
+                    word_count=each_card.word_count,
+                    budget=CARD_WORD_BUDGET,
+                )
+            )
+        if not each_card.has_picture:
+            all_findings.append(
+                CARD_WITHOUT_PICTURE_FINDING.format(card_id=each_card.card_id)
+            )
+    if page.lead_word_count > LEAD_WORD_BUDGET:
+        all_findings.append(
+            LEAD_OVER_BUDGET_FINDING.format(
+                word_count=page.lead_word_count, budget=LEAD_WORD_BUDGET
+            )
+        )
+    return all_findings
+
+
+def digest_findings(page: DigestPage, all_expected_ids: list[str]) -> list[str]:
+    """Return every way the page makes its reader read more or know less.
+
+    Args:
+        page: The parsed page.
+        all_expected_ids: Every source id the page must cover with a card.
+
+    Returns:
+        Coverage findings first, then budget findings; empty when the page passes.
+    """
+    return _coverage_findings(page, all_expected_ids) + _budget_findings(page)
+
+
+def main(all_arguments: list[str]) -> int:
+    """Check one page against its source ids and print the verdict.
+
+    Args:
+        all_arguments: Command-line arguments after the program name.
+
+    Returns:
+        Zero when the page passes, one when any finding reports.
+    """
+    argument_parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    argument_parser.add_argument("page", type=Path)
+    argument_parser.add_argument("--expect", nargs="+", required=True)
+    parsed = argument_parser.parse_args(all_arguments)
+    page = read_digest_page(parsed.page.read_text(encoding=UTF8_ENCODING))
+    all_findings = digest_findings(page, parsed.expect)
+    for each_finding in all_findings:
+        print(each_finding)
+    if all_findings:
+        return EXIT_FINDINGS
+    print(CLEAN_VERDICT.format(card_count=len(parsed.expect)))
+    return EXIT_CLEAN
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/scripts/policy_lint/adapter_callers.py

@@ -83,6 +83,49 @@ def _has_caller(document: Document, all_caller_texts: tuple[str, ...]) -> bool:
     return any(name_pattern.search(each_text) for each_text in all_caller_texts)
 
 
+def _reached_paths(
+    all_new_documents: tuple[Document, ...],
+    all_caller_texts: tuple[str, ...],
+    all_called: set[PurePosixPath],
+) -> set[PurePosixPath]:
+    return {
+        each_document.path
+        for each_document in all_new_documents
+        if each_document.path not in all_called
+        and _has_caller(each_document, all_caller_texts)
+    }
+
+
+def _called_paths(
+    all_new_documents: tuple[Document, ...], all_caller_texts: tuple[str, ...]
+) -> frozenset[PurePosixPath]:
+    """Return each new file a caller reaches, directly or through a called new file.
+
+    ::
+
+        workflow step -> new_check.py -> new_check_constants.py   both called
+        nothing       -> lonely.py    -> helper.py               both uncalled
+
+    Args:
+        all_new_documents: Every new code file in the change.
+        all_caller_texts: Text of every existing file that may name one.
+
+    Returns:
+        Paths of the new files some caller chain reaches.
+    """
+    all_called: set[PurePosixPath] = set()
+    all_reached = _reached_paths(all_new_documents, all_caller_texts, all_called)
+    while all_reached:
+        all_called |= all_reached
+        all_reached_texts = tuple(
+            each_document.text
+            for each_document in all_new_documents
+            if each_document.path in all_reached
+        )
+        all_reached = _reached_paths(all_new_documents, all_reached_texts, all_called)
+    return frozenset(all_called)
+
+
 def _uncalled_diagnostic(document: Document) -> Diagnostic:
     return Diagnostic(
         constants.UNCALLED_NEW_FILE_RULE_ID,
@@ -102,7 +145,7 @@ def uncalled_new_file_diagnostics(
 
     Returns:
         One diagnostic for each added script, hook or skill script whose name
-        appears only in tests and inventory files.
+        appears only in tests, inventory files, and other uncalled new files.
     """
     if document_set.selection not in {SelectionKind.STAGED, SelectionKind.BASE}:
         return ()
@@ -117,8 +160,9 @@ def uncalled_new_file_diagnostics(
         document_set.repository_root,
         frozenset(each_document.path for each_document in all_new_documents),
     )
+    all_called = _called_paths(all_new_documents, all_caller_texts)
     return tuple(
         _uncalled_diagnostic(each_document)
         for each_document in all_new_documents
-        if not _has_caller(each_document, all_caller_texts)
+        if each_document.path not in all_called
     )

package/scripts/policy_lint/adapter_configuration.py

@@ -127,12 +127,16 @@ def _names_exempt_registration_path(registered_string: str) -> bool:
     ::
 
         hooks/blocking/bash_pre_tool_use_dispatcher.py   -> exempt
+        hooks/blocking/step_note_gate.py                 -> exempt
         hooks/blocking/some_new_blocker.py               -> flagged
 
     The Bash PreToolUse dispatcher sits under ``blocking/`` for layout reasons
     while its roster hosts one allow-and-rewrite hook. Its path segment reads as
     a policy boundary that the chain never carries.
 
+    The step-note gate allows every call until the user runs ``/step-notes on``.
+    It asks for a readable status line and decides no code or safety policy.
+
     Args:
         registered_string: One command, path, script, or entrypoint string.
     """

package/scripts/policy_lint/config/constants.py

@@ -63,6 +63,7 @@ ALL_ACTION_BOUNDARY_SEGMENTS = frozenset(
 ALL_ACTION_BOUNDARY_PREFIXES = ("deny_", "block_", "ask_")
 ALL_ACTION_BOUNDARY_EXEMPT_REGISTRATION_PATHS = (
     "blocking/bash_pre_tool_use_dispatcher.py",
+    "blocking/step_note_gate.py",
 )
 ALL_TEST_DIRECTORY_NAMES = frozenset({"tests"})
 ALL_TEST_FILE_PREFIXES = ("test_",)

package/scripts/review_closure.py

@@ -7,8 +7,9 @@
     CLOSED jl-cmd/claude-dev-env#1442 ab845eb :: every review finding on this
     commit is answered
 
-A finding waits until the agent driving the pull request replies to it or
-pushes the fix. Exit status is 0 for CLOSED, 1 for OPEN, and 2 when the pull
+A finding is a review thread, a top-level comment on the pull request, or a
+blocking Claude Approvals row. It waits until the agent driving the pull
+request replies to it or pushes the fix. Exit status is 0 for CLOSED, 1 for OPEN, and 2 when the pull
 request state could not be read.
 """
 
@@ -35,6 +36,7 @@ from review_closure_github import (
     read_approvals_conclusion,
     read_pull_request,
     read_review_threads,
+    read_top_level_comments,
 )
 from review_closure_model import (
     OpenFinding,
@@ -93,6 +95,7 @@ def closure_report(
     all_pull_request_fields = read_pull_request(slug, number, token)
     all_findings = all_open_findings(
         read_review_threads(slug, number, token),
+        read_top_level_comments(slug, number, token),
         driver_logins(all_pull_request_fields, all_extra_logins),
         read_approvals_conclusion(slug, head_sha(all_pull_request_fields), token),
     )

package/scripts/review_closure_github.py

@@ -1,12 +1,13 @@
 """Read from GitHub what the review closure verdict rests on.
 
-Three reads answer one pull request: the pull request itself, its review
-threads, and the check runs on its head commit.
+Four reads answer one pull request: the pull request itself, its review
+threads, its top-level comments, and the check runs on its head commit.
 
 ::
 
     read_pull_request("jl-cmd/claude-dev-env", 1442, token)
     read_review_threads("jl-cmd/claude-dev-env", 1442, token)
+    read_top_level_comments("jl-cmd/claude-dev-env", 1442, token)
     read_approvals_conclusion("jl-cmd/claude-dev-env", "ab845eb", token)
 
 Two routes carry the review threads. A Claude Code session reaches GitHub
@@ -30,10 +31,11 @@ from dev_env_scripts_constants.review_closure_constants import (
     CHECK_RUN_PAGE_SIZE,
     CHECK_RUNS_ENDPOINT_TEMPLATE,
     CHECK_RUNS_KEY,
+    COMMENT_PAGE_SIZE,
     GET_METHOD,
     GITHUB_API_ROOT,
     GITHUB_GRAPHQL_ENDPOINT,
-    MAX_REVIEW_COMMENT_PAGES,
+    MAX_COMMENT_PAGES,
     NAME_VARIABLE,
     NO_SIGN_IN_MESSAGE,
     NUMBER_VARIABLE,
@@ -44,12 +46,13 @@ from dev_env_scripts_constants.review_closure_constants import (
     QUERY_KEY,
     REQUEST_FAILED_TEMPLATE,
     REQUEST_TIMEOUT_SECONDS,
-    REVIEW_COMMENT_PAGE_SIZE,
     REVIEW_COMMENTS_ENDPOINT_TEMPLATE,
     REVIEW_THREAD_PAGE_SIZE,
     REVIEW_THREAD_QUERY,
     REVIEW_THREADS_ENDPOINT_TEMPLATE,
     SLUG_SEPARATOR,
+    TOP_LEVEL_COMMENTS_ENDPOINT_TEMPLATE,
+    UNREADABLE_TOP_LEVEL_COMMENT_TEMPLATE,
     VARIABLES_KEY,
 )
 from pr_verification.config.constants import (
@@ -67,9 +70,11 @@ from pr_verification.config.constants import (
 from pr_verification.github_parsing import GitHubError
 from review_closure_model import (
     ReviewThread,
+    TopLevelComment,
     approvals_conclusion,
     comment_records_by_id,
     parse_thread,
+    parse_top_level_comment,
 )
 
 
@@ -191,23 +196,72 @@ def read_review_comments_by_id(
     Raises:
         GitHubError: A page answered with something other than a list.
     """
+    return comment_records_by_id(
+        _all_listed_records(REVIEW_COMMENTS_ENDPOINT_TEMPLATE, slug, number, token)
+    )
+
+
+def read_top_level_comments(
+    slug: str, number: int, token: str
+) -> tuple[TopLevelComment, ...]:
+    """Read every top-level comment on a pull request.
+
+    Args:
+        slug: The repository as ``owner/name``.
+        number: The pull request number.
+        token: The GitHub token the request authenticates with.
+
+    Returns:
+        Each comment posted on the pull request itself, outside any review
+        thread.
+
+    Raises:
+        GitHubError: A page answered with something other than a list, or a
+            comment carried a timestamp that does not parse.
+    """
+    all_records = _all_listed_records(
+        TOP_LEVEL_COMMENTS_ENDPOINT_TEMPLATE, slug, number, token
+    )
+    return tuple(
+        _parsed_top_level_comment(each_record)
+        for each_record in all_records
+        if isinstance(each_record, Mapping)
+    )
+
+
+def _parsed_top_level_comment(
+    all_comment_fields: Mapping[str, object],
+) -> TopLevelComment:
+    try:
+        return parse_top_level_comment(all_comment_fields)
+    except ValueError as failure:
+        raise GitHubError(
+            UNREADABLE_TOP_LEVEL_COMMENT_TEMPLATE.format(record=all_comment_fields)
+        ) from failure
+
+
+def _all_listed_records(
+    endpoint_template: str, slug: str, number: int, token: str
+) -> list[object]:
     all_records: list[object] = []
-    for each_page in range(1, MAX_REVIEW_COMMENT_PAGES + 1):
-        page = _review_comment_page(slug, number, token, each_page)
+    for each_page in range(1, MAX_COMMENT_PAGES + 1):
+        page = _listing_page(endpoint_template, slug, number, token, each_page)
         all_records.extend(page)
-        if len(page) < REVIEW_COMMENT_PAGE_SIZE:
+        if len(page) < COMMENT_PAGE_SIZE:
             break
-    return comment_records_by_id(all_records)
+    return all_records
 
 
-def _review_comment_page(slug: str, number: int, token: str, page: int) -> list[object]:
+def _listing_page(
+    endpoint_template: str, slug: str, number: int, token: str, page: int
+) -> list[object]:
     document = request_json(
         GET_METHOD,
-        REVIEW_COMMENTS_ENDPOINT_TEMPLATE.format(
+        endpoint_template.format(
             api_root=GITHUB_API_ROOT,
             slug=slug,
             number=number,
-            page_size=REVIEW_COMMENT_PAGE_SIZE,
+            page_size=COMMENT_PAGE_SIZE,
             page=page,
         ),
         token,