claude-dev-env 8.21.0 → 8.22.0

package/scripts/dev_env_scripts_constants/review_closure_constants.py

@@ -137,6 +137,19 @@ USER_TYPE_KEY: str = "type"
 BOT_USER_TYPE: str = "Bot"
 """The user type GitHub reports for an app account such as a review bot."""
 
+ALL_NOTICE_COMMENT_MARKERS: tuple[str, ...] = (
+    "No code changes since the last review",
+    "was updated up to the latest commit",
+    "<!-- graphite-review-comment -->",
+    "<h3>PR Summary by Qodo</h3>",
+    "<h3>Qodo is busy working</h3>",
+    "<h3>Great, no issues found!</h3>",
+)
+"""Text a bot notice carries: a Qodo skip note, a Qodo pointer to its updated
+summary, a Graphite verdict mirror whose findings arrive as review threads, a
+Qodo description of the change, a Qodo placeholder posted while it reviews, and
+a Qodo review that found nothing."""
+
 SHORT_SHA_LENGTH: int = 7
 """How much of a commit identifier the verdict line prints."""
 

package/scripts/dev_env_scripts_constants/shared_tree_constants.py

@@ -12,5 +12,9 @@ PROCESS_TREE_DIRECTORY_NAME: str = "process-tree"
 
 PROCESS_TREE_KILL_MODULE_FILENAME: str = "process_tree_kill.py"
 
+ADVISOR_DIRECTORY_NAME: str = "advisor"
+
+TIER_MODEL_IDS_MODULE_FILENAME: str = "tier_model_ids.py"
+
 AGENTS_DIRECTORY_SUFFIX: str = ".agents"
 DEFAULT_MANAGED_ROOT_NAME: str = ".claude"

package/scripts/invoke_code_review.py

@@ -26,6 +26,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import subprocess
 import sys
 from collections.abc import Callable, Sequence
@@ -41,8 +42,10 @@ sys.path[:] = [
 ]
 sys.path[:0] = [_scripts_directory]
 
+from shared_tree_paths import resolve_shared_advisor_scripts_directory
+
 _advisor_scripts_path = str(
-    _scripts_directory_path.parent / "_shared" / "advisor" / "scripts"
+    resolve_shared_advisor_scripts_directory(__file__, all_environment=os.environ)
 )
 sys.path[:] = [
     each_existing_entry

package/scripts/local_report_cli.py

@@ -2,16 +2,16 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import sys
 from collections.abc import Mapping, Sequence
-from dataclasses import dataclass
 from pathlib import Path
 from typing import TextIO
 
 from local_report_core import PublicationOutcome, publish_local_report
 from local_verification.config import SUCCESS_EXIT_CODE
 from pr_verification.config.constants import GIT_BARE_SUFFIX, GITHUB_API_URL
-from pr_verification.github import GitHubAppAuthenticator, GitHubError
+from pr_verification.github import GitHubApi, GitHubAppAuthenticator, GitHubError
 from pr_verification.model import RepositorySettings
 
 
@@ -34,8 +34,7 @@ def main(
     parser = _build_parser()
     parsed_arguments = parser.parse_args(list(all_arguments))
     try:
-        settings = _load_settings(parsed_arguments)
-        outcome = _publish_from_settings(settings, parsed_arguments)
+        outcome = _publish_from_arguments(parsed_arguments)
     except (OSError, TypeError, ValueError, GitHubError) as error:
         stderr.write(f"{error}\n")
         return 3
@@ -43,31 +42,57 @@ def main(
     return SUCCESS_EXIT_CODE
 
 
-def _publish_from_settings(
-    settings: _PublisherSettings, parsed_arguments: argparse.Namespace
-) -> PublicationOutcome:
-    repository = RepositorySettings(
-        settings.repository, settings.repository + GIT_BARE_SUFFIX
+def _publish_from_arguments(parsed_arguments: argparse.Namespace) -> PublicationOutcome:
+    all_settings = _read_settings_file(parsed_arguments.settings)
+    api_url = _required_setting(
+        parsed_arguments.api_url, all_settings, "api_url", GITHUB_API_URL
     )
-    authenticator = GitHubAppAuthenticator(
-        settings.api_url,
-        settings.app_id,
-        settings.installation_id,
-        settings.private_key_path,
+    repository_slug = _required_repository_setting(
+        parsed_arguments.repository, all_settings
     )
-    github = authenticator.issue_repository_api(
-        repository, should_write_issue_labels=True
+    pull_request_number = _required_integer_setting(
+        parsed_arguments.pull_number, all_settings, "pull_number"
     )
+    repository = RepositorySettings(repository_slug, repository_slug + GIT_BARE_SUFFIX)
+    github = _issue_repository_api(parsed_arguments, all_settings, api_url, repository)
     return publish_local_report(
         github,
         repository,
-        settings.pull_request_number,
+        pull_request_number,
         parsed_arguments.local_repo,
         parsed_arguments.manifest,
         parsed_arguments.report,
     )
 
 
+def _issue_repository_api(
+    parsed_arguments: argparse.Namespace,
+    all_settings: Mapping[str, object],
+    api_url: str,
+    repository: RepositorySettings,
+) -> GitHubApi:
+    if parsed_arguments.token_environment is not None:
+        return GitHubApi(api_url, _environment_token(parsed_arguments.token_environment))
+    authenticator = GitHubAppAuthenticator(
+        api_url,
+        _required_integer_setting(parsed_arguments.app_id, all_settings, "app_id"),
+        _required_integer_setting(
+            parsed_arguments.installation_id, all_settings, "installation_id"
+        ),
+        _required_path_setting(parsed_arguments.private_key_path, all_settings),
+    )
+    return authenticator.issue_repository_api(
+        repository, should_write_issue_labels=True
+    )
+
+
+def _environment_token(variable_name: str) -> str:
+    token = os.environ.get(variable_name)
+    if not token:
+        raise TypeError(f"Missing publisher token in environment variable: {variable_name}")
+    return token
+
+
 def _outcome_mapping(outcome: PublicationOutcome) -> dict[str, object]:
     return {
         "status": outcome.status.value,
@@ -76,16 +101,6 @@ def _outcome_mapping(outcome: PublicationOutcome) -> dict[str, object]:
     }
 
 
-@dataclass(frozen=True)
-class _PublisherSettings:
-    api_url: str
-    app_id: int
-    installation_id: int
-    private_key_path: Path
-    repository: str
-    pull_request_number: int
-
-
 def _build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="cde publish-local-report")
     parser.add_argument("--settings", type=Path)
@@ -93,6 +108,7 @@ def _build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--app-id", type=int)
     parser.add_argument("--installation-id", type=int)
     parser.add_argument("--private-key-path", type=Path)
+    parser.add_argument("--token-environment")
     parser.add_argument("--repository")
     parser.add_argument("--pull-number", type=int)
     parser.add_argument("--local-repo", type=Path, required=True)
@@ -101,32 +117,13 @@ def _build_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def _load_settings(parsed_arguments: argparse.Namespace) -> _PublisherSettings:
-    all_settings: Mapping[str, object] = {}
-    if parsed_arguments.settings is not None:
-        parsed_settings = json.loads(
-            parsed_arguments.settings.read_text(encoding="utf-8")
-        )
-        if not isinstance(parsed_settings, Mapping):
-            raise ValueError("Publisher settings must be an object")
-        all_settings = parsed_settings
-    return _PublisherSettings(
-        _required_setting(
-            parsed_arguments.api_url,
-            all_settings,
-            "api_url",
-            GITHUB_API_URL,
-        ),
-        _required_integer_setting(parsed_arguments.app_id, all_settings, "app_id"),
-        _required_integer_setting(
-            parsed_arguments.installation_id, all_settings, "installation_id"
-        ),
-        _required_path_setting(parsed_arguments.private_key_path, all_settings),
-        _required_repository_setting(parsed_arguments.repository, all_settings),
-        _required_integer_setting(
-            parsed_arguments.pull_number, all_settings, "pull_number"
-        ),
-    )
+def _read_settings_file(settings_path: Path | None) -> Mapping[str, object]:
+    if settings_path is None:
+        return {}
+    parsed_settings = json.loads(settings_path.read_text(encoding="utf-8"))
+    if not isinstance(parsed_settings, Mapping):
+        raise ValueError("Publisher settings must be an object")
+    return parsed_settings
 
 
 def _required_setting(

package/scripts/policy_lint/adapter_configuration.py

@@ -128,6 +128,8 @@ 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/reply_length_gate.py              -> exempt
+        hooks/blocking/edit_marker_gate.py               -> exempt
         hooks/blocking/some_new_blocker.py               -> flagged
 
     The Bash PreToolUse dispatcher sits under ``blocking/`` for layout reasons
@@ -137,6 +139,12 @@ def _names_exempt_registration_path(registered_string: str) -> bool:
     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.
 
+    The reply length gate caps the sentences in a chat reply to the user. It
+    decides the shape of prose and no code or safety policy.
+
+    The edit marker gate keeps strikethrough and edit notes out of an edited
+    chat message. It decides the shape of prose and no code or safety policy.
+
     Args:
         registered_string: One command, path, script, or entrypoint string.
     """

package/scripts/policy_lint/config/constants.py

@@ -64,6 +64,8 @@ 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",
+    "blocking/reply_length_gate.py",
+    "blocking/edit_marker_gate.py",
 )
 ALL_TEST_DIRECTORY_NAMES = frozenset({"tests"})
 ALL_TEST_FILE_PREFIXES = ("test_",)

package/scripts/resolve_worker_spawn.py

@@ -24,6 +24,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import subprocess
 import sys
 from collections.abc import Callable, Sequence
@@ -40,8 +41,10 @@ sys.path[:] = [
 ]
 sys.path[:0] = [_scripts_directory]
 
+from shared_tree_paths import resolve_shared_advisor_scripts_directory
+
 _advisor_scripts_path = str(
-    _scripts_directory_path.parent / "_shared" / "advisor" / "scripts"
+    resolve_shared_advisor_scripts_directory(__file__, all_environment=os.environ)
 )
 sys.path[:] = [
     each_existing_entry

package/scripts/review_closure_model.py

@@ -15,12 +15,16 @@ and the approvals conclusion, and name what waits.
     top-level: a bot comment, then an agent one -> closed
     top-level: the bot edits after that reply   -> closed
     top-level: a person edits after that reply  -> open
+    top-level: a bot notice with no finding     -> closed
 
 A red circle marks a finding a review states as blocking, so resolution alone
 leaves it open. The reply says what changed, or why the finding stands.
 A review bot rewrites its summary comment on each pass, and any new finding it
 has arrives as a review thread or a new comment, so its edit alone reopens
-nothing.
+nothing. A bot notice carries a skip note, a pointer to an updated summary, a
+verdict mirror, a description of the change, a placeholder posted while the bot
+reviews, or a review that found nothing, and never a finding, so it waits on
+nobody.
 """
 
 from __future__ import annotations
@@ -33,6 +37,7 @@ from dev_env_scripts_constants.review_closure_constants import (
     ALL_BLOCKING_CONCLUSIONS,
     ALL_COMMENT_AUTHOR_KEYS,
     ALL_COMMENT_LIST_KEYS,
+    ALL_NOTICE_COMMENT_MARKERS,
     ALL_OUTDATED_KEYS,
     ALL_RESOLVED_KEYS,
     APPROVALS_CHECK_NAME,
@@ -93,6 +98,7 @@ class TopLevelComment:
     identifier: object
     author_login: str
     is_bot: bool
+    is_notice: bool
     created_at: datetime
     updated_at: datetime
     url: str
@@ -217,7 +223,7 @@ def top_level_finding(
     Returns:
         The finding this comment leaves open, or None when it is answered.
     """
-    if comment.author_login in all_driver_logins:
+    if comment.author_login in all_driver_logins or comment.is_notice:
         return None
     last_counted_at = comment.created_at if comment.is_bot else comment.updated_at
     if latest_driver_time is not None and last_counted_at <= latest_driver_time:
@@ -423,6 +429,9 @@ def parse_top_level_comment(
 ) -> TopLevelComment:
     """Read one top-level comment from the REST answer.
 
+    A bot comment whose body carries a notice marker is a notice. A person's
+    comment carrying the same text still counts, since anyone can paste it.
+
     Args:
         all_comment_fields: The comment as the issue comments route reports it.
 
@@ -432,10 +441,14 @@ def parse_top_level_comment(
     Raises:
         ValueError: A timestamp is missing or does not parse.
     """
+    is_bot = _is_bot_author(all_comment_fields)
+    body = str(all_comment_fields.get(COMMENT_BODY_KEY) or "")
     return TopLevelComment(
         identifier=all_comment_fields.get(COMMENT_IDENTIFIER_KEY),
         author_login=_comment_author_login(all_comment_fields),
-        is_bot=_is_bot_author(all_comment_fields),
+        is_bot=is_bot,
+        is_notice=is_bot
+        and any(each_marker in body for each_marker in ALL_NOTICE_COMMENT_MARKERS),
         created_at=datetime.fromisoformat(str(all_comment_fields.get(CREATED_AT_KEY))),
         updated_at=datetime.fromisoformat(str(all_comment_fields.get(UPDATED_AT_KEY))),
         url=str(all_comment_fields.get(HTML_URL_KEY) or ""),

package/scripts/shared_tree_paths.py

@@ -11,6 +11,7 @@ from collections.abc import Mapping
 from pathlib import Path
 
 from dev_env_scripts_constants.shared_tree_constants import (
+    ADVISOR_DIRECTORY_NAME,
     AGENTS_DIRECTORY_SUFFIX,
     CLAUDE_CONFIG_DIR_ENV_VAR,
     DEFAULT_MANAGED_ROOT_NAME,
@@ -18,6 +19,7 @@ from dev_env_scripts_constants.shared_tree_constants import (
     PROCESS_TREE_KILL_MODULE_FILENAME,
     SCRIPTS_DIRECTORY_NAME,
     SHARED_PACKAGE_DIRECTORY_NAME,
+    TIER_MODEL_IDS_MODULE_FILENAME,
 )
 
 
@@ -131,3 +133,28 @@ def resolve_shared_process_tree_scripts_directory(
         PROCESS_TREE_KILL_MODULE_FILENAME,
         1,
     )
+
+
+def resolve_shared_advisor_scripts_directory(
+    module_file: str | Path,
+    all_environment: Mapping[str, str],
+) -> Path:
+    """Return the advisor scripts directory that holds the tier model ids.
+
+    Names the advisor sub-package for a caller sitting one level under the
+    installed root, such as a dispatcher in the managed ``scripts`` directory.
+
+    Args:
+        module_file: Path of the importing module (``__file__``).
+        all_environment: Mapping that may hold ``CLAUDE_CONFIG_DIR``.
+
+    Returns:
+        Directory that should hold ``tier_model_ids.py``.
+    """
+    return resolve_shared_scripts_directory(
+        module_file,
+        all_environment,
+        ADVISOR_DIRECTORY_NAME,
+        TIER_MODEL_IDS_MODULE_FILENAME,
+        1,
+    )

package/scripts/test_resolve_worker_spawn.py

@@ -56,6 +56,7 @@ from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
     REASON_GROK_AUTH_FAILED,
     REASON_PROMPT_FILE_MISSING,
     REASON_TIMEOUT_OUT_OF_BOUNDS,
+    ROLE_TRANSLATOR,
     RESULT_KEY_ATTEMPTS,
     RESULT_KEY_OK,
     RESULT_KEY_OUTPUT,
@@ -865,6 +866,33 @@ def test_tier_three_argv_includes_agent_for_default_role(
     )
 
 
+def test_translator_role_dispatches_the_poteto_agent_on_tier_three(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    prompt_file, working_directory, run_state_directory = _paths(tmp_path)
+    call_log = _install_seams(
+        monkeypatch,
+        grok_outcome=_grok_failure(CLASSIFICATION_AUTH_FAILURE),
+        claude_outcome=_claude_served(),
+        host_profile=HOST_PROFILE_CLAUDE,
+    )
+
+    spawn_outcome = dispatcher.resolve_worker_spawn(
+        role=ROLE_TRANSLATOR,
+        prompt_file=prompt_file,
+        working_directory=working_directory,
+        timeout_seconds=DEFAULT_WORKER_TIMEOUT_SECONDS,
+        is_claude_tier_enabled=True,
+        run_state_directory=run_state_directory,
+    )
+
+    assert spawn_outcome.tier_used == TIER_CLAUDE_HEADLESS
+    assert call_log.claude_arguments is not None
+    agent_flag_index = call_log.claude_arguments.index(AGENT_FLAG)
+    assert call_log.claude_arguments[agent_flag_index + 1] == "poteto-agent"
+    assert ROLE_TRANSLATOR not in call_log.claude_arguments
+
+
 def test_large_prompt_stays_out_of_claude_argv(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:

package/scripts/test_shared_tree_paths.py

@@ -21,6 +21,10 @@ from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
     SCRIPTS_DIRECTORY_NAME,
     SHARED_PACKAGE_DIRECTORY_NAME,
 )
+from dev_env_scripts_constants.shared_tree_constants import (
+    ADVISOR_DIRECTORY_NAME,
+    TIER_MODEL_IDS_MODULE_FILENAME,
+)
 
 
 def _create_directory_link(*, from_link: Path, to_target: Path) -> None:
@@ -143,6 +147,29 @@ def test_missing_module_returns_unresolved_candidate(tmp_path: Path) -> None:
     ).is_file()
 
 
+def test_junction_scripts_dir_finds_advisor_scripts_on_unresolved_parent(
+    tmp_path: Path,
+) -> None:
+    module_file = _build_junction_scripts_layout(tmp_path)
+    expected_scripts_directory = (
+        tmp_path
+        / "root"
+        / SHARED_PACKAGE_DIRECTORY_NAME
+        / ADVISOR_DIRECTORY_NAME
+        / SCRIPTS_DIRECTORY_NAME
+    )
+    expected_scripts_directory.mkdir(parents=True)
+    (expected_scripts_directory / TIER_MODEL_IDS_MODULE_FILENAME).write_text(
+        "", encoding="utf-8"
+    )
+    resolved_scripts_directory = (
+        shared_tree_paths.resolve_shared_advisor_scripts_directory(
+            module_file, all_environment={}
+        )
+    )
+    assert resolved_scripts_directory == expected_scripts_directory
+
+
 def test_generalized_resolver_serves_a_deeper_anchor(tmp_path: Path) -> None:
     """A caller three levels under the root resolves its own sub-package.
 

package/scripts/tests/test_adapter_configuration.py

@@ -58,6 +58,22 @@ def test_new_step_note_gate_registration_is_clean(tmp_path: Path) -> None:
     assert adapters.hook_configuration_diagnostics(current_document, tmp_path) == ()
 
 
+def test_new_reply_length_gate_registration_is_clean(tmp_path: Path) -> None:
+    current_document = _hook_document(
+        ["hooks/blocking/reply_length_gate.py"],
+        '{"hooks": {}}',
+    )
+    assert adapters.hook_configuration_diagnostics(current_document, tmp_path) == ()
+
+
+def test_new_edit_marker_gate_registration_is_clean(tmp_path: Path) -> None:
+    current_document = _hook_document(
+        ["hooks/blocking/edit_marker_gate.py"],
+        '{"hooks": {}}',
+    )
+    assert adapters.hook_configuration_diagnostics(current_document, tmp_path) == ()
+
+
 def test_new_blocker_in_staged_change_is_rejected(tmp_path: Path) -> None:
     current_document = _hook_document(
         ["hooks/blocking/new.py"],

package/scripts/tests/test_local_report_publisher_cli.py

@@ -6,6 +6,8 @@ import subprocess
 import sys
 from pathlib import Path
 
+import pytest
+
 SCRIPTS_DIRECTORY = Path(__file__).resolve().parents[1]
 if str(SCRIPTS_DIRECTORY) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIRECTORY))
@@ -83,3 +85,55 @@ def test_publisher_script_displays_help_without_authentication() -> None:
 
     assert completed_process.returncode == 0
     assert "usage:" in completed_process.stdout
+
+
+def _token_arguments(tmp_path: Path, variable_name: str) -> list[str]:
+    return [
+        "--api-url",
+        "http://127.0.0.1:9",
+        "--token-environment",
+        variable_name,
+        "--repository",
+        "owner/repository",
+        "--pull-number",
+        "7",
+        "--local-repo",
+        str(tmp_path),
+        "--manifest",
+        str(tmp_path / "manifest.json"),
+        "--report",
+        str(tmp_path / "report.json"),
+    ]
+
+
+def test_cli_names_missing_token_variable_without_network_access(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.delenv("PUBLISHER_TEST_TOKEN", raising=False)
+    standard_output = io.StringIO()
+    standard_error = io.StringIO()
+
+    exit_code = main(
+        _token_arguments(tmp_path, "PUBLISHER_TEST_TOKEN"),
+        stdout=standard_output,
+        stderr=standard_error,
+    )
+
+    assert exit_code == 3
+    assert standard_output.getvalue() == ""
+    assert "PUBLISHER_TEST_TOKEN" in standard_error.getvalue()
+
+
+def test_cli_token_path_reaches_the_api_without_app_settings(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv("PUBLISHER_TEST_TOKEN", "token")
+    standard_error = io.StringIO()
+
+    exit_code = main(
+        _token_arguments(tmp_path, "PUBLISHER_TEST_TOKEN"), stderr=standard_error
+    )
+
+    assert exit_code == 3
+    assert "Missing publisher setting" not in standard_error.getvalue()
+    assert "refused" in standard_error.getvalue().lower()

package/scripts/tests/test_review_closure.py

@@ -140,6 +140,7 @@ def should_print_the_url_of_a_waiting_top_level_comment(
         identifier=1,
         author_login="qodo-merge-pro[bot]",
         is_bot=True,
+        is_notice=False,
         created_at=posted,
         updated_at=posted,
         url=summary_url,

package/scripts/tests/test_review_closure_model.py

@@ -4,6 +4,8 @@ import sys
 from datetime import datetime
 from pathlib import Path
 
+import pytest
+
 SCRIPTS_DIRECTORY = Path(__file__).resolve().parents[1]
 if str(SCRIPTS_DIRECTORY) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIRECTORY))
@@ -315,11 +317,13 @@ def top_level_comment(
     edited_minute: int | None = None,
     url: str = BOT_SUMMARY_URL,
     is_bot: bool = True,
+    is_notice: bool = False,
 ) -> model.TopLevelComment:
     return model.TopLevelComment(
         identifier=posted_minute,
         author_login=author_login,
         is_bot=is_bot,
+        is_notice=is_notice,
         created_at=at_minute(posted_minute),
         updated_at=at_minute(posted_minute if edited_minute is None else edited_minute),
         url=url,
@@ -445,6 +449,72 @@ def should_open_a_bot_comment_posted_after_the_driver_time() -> None:
     )
 
 
+def should_close_a_bot_notice_posted_after_the_driver_time() -> None:
+    comment = top_level_comment(REVIEW_BOT, 5, is_notice=True)
+
+    assert model.top_level_finding(comment, DRIVING_AGENT, at_minute(4)) is None
+
+
+@pytest.mark.parametrize(
+    "body",
+    [
+        "No code changes since the last review \u2014 review skipped",
+        "[Code review](https://example.test/pull/7#issuecomment-1) by qodo was "
+        "updated up to the latest commit https://example.test/commit/abc",
+        "<!-- graphite-review-comment -->\n\n### Graphite AI review",
+        "<h3>PR Summary by Qodo</h3>\n\nBuild the default map per instance",
+        "\n<h3>Qodo is busy working</h3>\n\nCheck back in a few minutes.",
+        "\n<h3>Code Review by Qodo</h3>\n<code>\U0001f41e Bugs (0)</code>\n\n"
+        "<h3>Great, no issues found!</h3>\nQodo reviewed your code",
+    ],
+)
+def should_read_a_bot_notice_as_a_notice(body: str) -> None:
+    comment = model.parse_top_level_comment(notice_record(body, "Bot"))
+
+    assert comment.is_notice
+    assert model.top_level_findings((comment,), DRIVING_AGENT) == ()
+
+
+def should_read_a_person_pasting_notice_text_as_a_comment() -> None:
+    comment = model.parse_top_level_comment(
+        notice_record("No code changes since the last review", "User")
+    )
+
+    assert not comment.is_notice
+    assert len(model.top_level_findings((comment,), DRIVING_AGENT)) == 1
+
+
+def should_read_a_bot_finding_as_a_comment() -> None:
+    comment = model.parse_top_level_comment(
+        notice_record("A finding: the loop never ends.", "Bot")
+    )
+
+    assert not comment.is_notice
+
+
+def should_read_a_qodo_review_with_bugs_as_a_comment() -> None:
+    comment = model.parse_top_level_comment(
+        notice_record(
+            "\n<h3>Code Review by Qodo</h3>\n<code>\U0001f41e Bugs (2)</code>\n\n"
+            "1. The loop never ends.",
+            "Bot",
+        )
+    )
+
+    assert not comment.is_notice
+
+
+def notice_record(body: str, user_type: str) -> dict[str, object]:
+    return {
+        "id": 1,
+        "user": {"login": REVIEW_BOT, "type": user_type},
+        "body": body,
+        "created_at": "2026-09-26T12:05:00+00:00",
+        "updated_at": "2026-09-26T12:05:00+00:00",
+        "html_url": BOT_SUMMARY_URL,
+    }
+
+
 def should_count_waiting_top_level_comments_among_the_findings() -> None:
     all_findings = model.all_open_findings(
         (), (top_level_comment(REVIEW_BOT, 1),), DRIVING_AGENT, None