claude-dev-env 8.6.0 → 8.7.0

package/.agents/skills/privacy-hygiene/reference/sweep-procedure.md

@@ -49,7 +49,7 @@ Review each hit. Ignore:
 
 - Stage only clean files
 - Prefer `--body-file` for `gh` posts (also required by the gh-cli-conventions rule)
-- Let `pii_prevention_blocker` re-run on the next Write / commit / post
+- No hook re-scans the next Write, commit, or post; `pii_prevention_blocker` was retired. Re-run this sweep before the next commit or post.
 
 ## Accepted residual (do not over-scrub)
 

package/_shared/advisor/scripts/config/advisor_scripts_constants/model_tier_run_validator_constants.py

@@ -105,3 +105,4 @@ CLI_SUCCESS_EXIT_CODE: int = 0
 ALL_ADVISOR_REPLY_PATHS: frozenset[str] = frozenset(
     {"native", "sendmessage", "cli", "codex", "none"}
 )
+EVIDENCE_MUST_BE_OBJECT_MESSAGE: str = "evidence must be an object"

package/_shared/advisor/scripts/model_tier_run_validator.py

@@ -76,6 +76,7 @@ from advisor_scripts_constants.model_tier_run_validator_constants import (
     CLI_SUCCESS_EXIT_CODE,
     CLI_USAGE_MESSAGE,
     CLI_VALIDATION_FAILURE_EXIT_CODE,
+    EVIDENCE_MUST_BE_OBJECT_MESSAGE,
     HOST_PROFILE_CLAUDE,
     HOST_PROFILE_CODEX,
     HOST_PROFILE_JSON_KEY,
@@ -242,7 +243,7 @@ def _validate_advisor_evidence(
     run: ModelTierRun,
 ) -> None:
     if not isinstance(evidence, Mapping):
-        raise ModelTierRunError("evidence must be an object")
+        raise ModelTierRunError(EVIDENCE_MUST_BE_OBJECT_MESSAGE)
     raw_schema_version = evidence.get("schema_version")
     if isinstance(raw_schema_version, bool) or raw_schema_version != 1:
         raise ModelTierRunError("evidence.schema_version must be 1")
@@ -415,7 +416,7 @@ def load_model_tier_run_from_json_path(from_path: Path) -> ModelTierRun:
         raise TypeError(HOST_PROFILE_MUST_BE_STRING_MESSAGE)
     raw_evidence = parsed_payload.get("evidence")
     if raw_evidence is not None and not isinstance(raw_evidence, dict):
-        raise TypeError("evidence must be an object")
+        raise TypeError(EVIDENCE_MUST_BE_OBJECT_MESSAGE)
     return ModelTierRun(
         own_tier=parsed_payload["own_tier"],
         candidate_tiers=list(parsed_payload["candidate_tiers"]),

package/_shared/advisor/scripts/tests/test_model_tier_run_validator.py

@@ -35,6 +35,9 @@ load_model_tier_run_from_json_path = (
 )
 ADVISOR_MODEL_TIER = model_tier_run_validator.ADVISOR_MODEL_TIER
 CODEX_BIND_SUCCESS_TOKEN = model_tier_run_validator.CODEX_BIND_SUCCESS_TOKEN
+EVIDENCE_MUST_BE_OBJECT_MESSAGE = (
+    model_tier_run_validator.EVIDENCE_MUST_BE_OBJECT_MESSAGE
+)
 
 
 def _native_codex_evidence(
@@ -136,6 +139,38 @@ def test_cli_reads_versioned_advisor_evidence(tmp_path: Path) -> None:
     assert loaded_run.evidence["consult"]["report_back_status"] == "recorded"
 
 
+def test_non_object_evidence_reports_the_same_message_at_validate_and_load(
+    tmp_path: Path,
+) -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=[ADVISOR_MODEL_TIER],
+        attempts=[{"tier": ADVISOR_MODEL_TIER, "result": "spawned"}],
+        selected_tier=ADVISOR_MODEL_TIER,
+        host_profile="Codex",
+        evidence=["not", "an", "object"],
+    )
+    with pytest.raises(ModelTierRunError, match=EVIDENCE_MUST_BE_OBJECT_MESSAGE):
+        validate_model_tier_run(run)
+
+    log_path = tmp_path / "model-tier-run.json"
+    log_path.write_text(
+        json.dumps(
+            {
+                "own_tier": "Opus",
+                "candidate_tiers": [ADVISOR_MODEL_TIER],
+                "attempts": [{"tier": ADVISOR_MODEL_TIER, "result": "spawned"}],
+                "selected_tier": ADVISOR_MODEL_TIER,
+                "host_profile": "Codex",
+                "evidence": "not an object",
+            }
+        ),
+        encoding="utf-8",
+    )
+    with pytest.raises(TypeError, match=EVIDENCE_MUST_BE_OBJECT_MESSAGE):
+        load_model_tier_run_from_json_path(from_path=log_path)
+
+
 def test_clean_single_spawn_at_top_of_slice_passes() -> None:
     run = ModelTierRun(
         own_tier="Opus",

package/_shared/pr-loop/scripts/pr_loop_shared_constants/terminology_sweep_constants.py

@@ -10,6 +10,10 @@ MARKDOWN_FILE_EXTENSION: str = ".md"
 
 INLINE_CODE_SPAN_PATTERN: re.Pattern[str] = re.compile(r"`[^`]*`")
 
+MARKDOWN_LINK_TARGET_PATTERN: re.Pattern[str] = re.compile(r"\]\([^)]*\)")
+
+SENTENCE_BOUNDARY_PATTERN: re.Pattern[str] = re.compile(r"(?<=[.!?])\s+")
+
 SNAKE_CASE_IDENTIFIER_PATTERN: re.Pattern[str] = re.compile(
     r"\b[a-z][a-z0-9]*(?:_[a-z0-9]+)+\b"
 )

package/_shared/pr-loop/scripts/terminology_sweep.py

@@ -62,10 +62,12 @@ from pr_loop_shared_constants.terminology_sweep_constants import (
     JAVASCRIPT_LINE_COMMENT_MARKER,
     JSDOC_CONTINUATION_MARKER,
     MARKDOWN_FILE_EXTENSION,
+    MARKDOWN_LINK_TARGET_PATTERN,
     MINIMUM_IDENTIFIER_TOKEN_COUNT,
     PROSE_WINDOW_WORD_SEPARATOR,
     PROSE_WORD_PATTERN,
     PYTHON_COMMENT_MARKER,
+    SENTENCE_BOUNDARY_PATTERN,
     SNAKE_CASE_IDENTIFIER_PATTERN,
     STRING_LITERAL_CONTENT_PATTERN,
     TERMINOLOGY_FINDING_TEMPLATE,
@@ -74,7 +76,6 @@ from pr_loop_shared_constants.terminology_sweep_constants import (
     TEST_FILE_PREFIX,
     TEST_FILE_SUFFIX,
 )
-
 from subprocess_window_access import hidden_window_creation_flags
 
 IdentifierTuple = tuple[str, ...]
@@ -161,27 +162,76 @@ def _collect_introduced_identifiers(
 ) -> frozenset[IdentifierTuple]:
     """Return the identifier tuples introduced on added code lines.
 
+    A name bound only inside a test module is a fixture's own local variable,
+    not a term the rest of the repository is expected to agree with, so a
+    test file's identifiers are left out.
+
     Args:
         all_added_lines: Added-line triples from :func:`_parse_added_lines`.
 
     Returns:
-        Every multi-word identifier tuple appearing on an added code line.
+        Every multi-word identifier tuple appearing on an added,
+        non-test-module code line.
     """
     all_identifier_tuples: set[IdentifierTuple] = set()
     for each_file_path, _, each_text in all_added_lines:
-        if _file_extension(each_file_path) in ALL_SWEEP_CODE_FILE_EXTENSIONS:
+        if _is_swept_non_test_code_file(each_file_path):
             all_identifier_tuples.update(_identifier_tuples_in_text(each_text))
     return frozenset(all_identifier_tuples)
 
 
+def _fragments_split_at_breaks(all_fragments: list[str]) -> list[str]:
+    """Split each fragment at every sentence, link, and code-span break in turn."""
+    for each_break_pattern in (
+        INLINE_CODE_SPAN_PATTERN,
+        MARKDOWN_LINK_TARGET_PATTERN,
+        SENTENCE_BOUNDARY_PATTERN,
+    ):
+        all_fragments = [
+            each_piece
+            for each_fragment in all_fragments
+            for each_piece in each_break_pattern.split(each_fragment)
+        ]
+    return all_fragments
+
+
+def _split_into_prose_fragments(raw_fragment: str) -> list[str]:
+    """Split a raw prose fragment at every sentence, link, and code-span break.
+
+    ::
+
+        raw:  "…gates the pull request. [`link`](docs/README.md) explains it."
+        split -> ["…gates the pull request", "explains it."]
+        flag: a window built from the joined text -- "pull request docs"
+        ok:   "pull request" and "docs" now sit in different fragments
+
+    A sentence-ending period, a Markdown link's target, and a backticked code
+    span each end whatever the reader was reading and start something new.
+    Splitting there keeps a word window scoped to one sentence, clear of a
+    stripped span's unrelated text on its far side.
+
+    Args:
+        raw_fragment: One prose fragment collected from an added line.
+
+    Returns:
+        The fragment's pieces with every break removed, in order, dropping
+        any piece left blank.
+    """
+    all_fragments = _fragments_split_at_breaks([raw_fragment])
+    return [
+        each_fragment.strip() for each_fragment in all_fragments if each_fragment.strip()
+    ]
+
+
 def _prose_fragments(file_path: str, line_text: str) -> list[str]:
     """Return the prose fragments of an added line worth scanning for terms.
 
-    A Markdown line is prose with its inline-code spans removed, since a
-    backticked span names code verbatim. A code line contributes its comment
-    tail, its JSDoc continuation text, and the contents of its string
-    literals. A test module contributes its comment tail and JSDoc text only.
-    Its string literals hold fixture data, not prose.
+    A Markdown line is prose split at its sentence, link, and code-span
+    breaks, since a backticked span names code verbatim and a link target is
+    a path, not a word. A code line contributes its comment tail, its JSDoc
+    continuation text, and the contents of its string literals, each split
+    the same way. A test module contributes its comment tail and JSDoc text
+    only. Its string literals hold fixture data, not prose.
 
     Args:
         file_path: The path the added line belongs to.
@@ -192,17 +242,21 @@ def _prose_fragments(file_path: str, line_text: str) -> list[str]:
     """
     extension = _file_extension(file_path)
     if extension == MARKDOWN_FILE_EXTENSION:
-        return [INLINE_CODE_SPAN_PATTERN.sub(" ", line_text)]
+        return _split_into_prose_fragments(line_text)
     if extension not in ALL_SWEEP_CODE_FILE_EXTENSIONS:
         return []
-    all_fragments: list[str] = []
+    all_raw_fragments: list[str] = []
     stripped_line = line_text.strip()
     if stripped_line.startswith(JSDOC_CONTINUATION_MARKER):
-        all_fragments.append(stripped_line)
-    all_fragments.extend(_comment_fragments(line_text))
+        all_raw_fragments.append(stripped_line)
+    all_raw_fragments.extend(_comment_fragments(line_text))
     if not _is_test_file(file_path):
-        all_fragments.extend(_string_literal_fragments(line_text))
-    return all_fragments
+        all_raw_fragments.extend(_string_literal_fragments(line_text))
+    return [
+        each_split_fragment
+        for each_raw_fragment in all_raw_fragments
+        for each_split_fragment in _split_into_prose_fragments(each_raw_fragment)
+    ]
 
 
 def _is_test_file(file_path: str) -> bool:
@@ -245,6 +299,13 @@ def _is_test_file(file_path: str) -> bool:
     )
 
 
+def _is_swept_non_test_code_file(file_path: str) -> bool:
+    """Return whether a diff path names a swept code file outside a test module."""
+    return _file_extension(
+        file_path
+    ) in ALL_SWEEP_CODE_FILE_EXTENSIONS and not _is_test_file(file_path)
+
+
 def _comment_fragments(line_text: str) -> list[str]:
     """Return the comment tail of a code line, or an empty list when absent."""
     all_fragments: list[str] = []
@@ -428,15 +489,30 @@ def _near_miss_identifier(
     all_identifier_tuples: frozenset[IdentifierTuple],
     identifiers_by_first_token: dict[str, list[IdentifierTuple]],
     all_identifier_tokens: frozenset[str],
+    all_known_identifier_tuples: frozenset[IdentifierTuple],
 ) -> IdentifierTuple | None:
     """Return an identifier the candidate near-misses, or None when it does not.
 
+    ::
+
+        known identifier:  cde_lint            (scripts/cde_lint.py, the tool's own name)
+        introduced:        cde_lint_path        3-token, adds "path" to that name
+        candidate:         "cde lint standard"  shares "cde lint", then "standard"
+        candidate[:-1]:    ("cde", "lint")       == the known identifier cde_lint
+        ok:   candidate[:-1] names cde_lint verbatim -- agreement, not a near-miss
+        flag: "premium request budget" against premium_request_interactions
+              -- "premium request" names no identifier of its own
+
     Args:
         candidate_tuple: The prose term's lowercase token tuple.
         all_identifier_tuples: Every introduced identifier tuple.
         identifiers_by_first_token: Identifier tuples grouped by leading token.
         all_identifier_tokens: Every token of every identifier on added code
             lines, used to spare prose built from real code vocabulary.
+        all_known_identifier_tuples: Every identifier tuple the sweep knows
+            about, introduced or pre-existing, plus each added file's stem,
+            used to spare a candidate whose leading tokens name one of them
+            verbatim.
 
     Returns:
         The first identifier the candidate renames in only its final token. Such a
@@ -449,9 +525,12 @@ def _near_miss_identifier(
         common English compound tail word (``read-only``, ``data-driven``); it
         contains an English stopword (``to a``, ``each image``); it differs
         from the identifier only by a singular/plural form of one or more
-        tokens (``test files`` against ``test_file``); or every diverging word
+        tokens (``test files`` against ``test_file``); every diverging word
         is itself a token of some introduced identifier (``target width box``
-        when ``box_height`` is also in the diff).
+        when ``box_height`` is also in the diff); or its leading tokens, with
+        the final diverging word set aside, spell out a known identifier of
+        their own (``cde_lint standard`` against ``cde_lint_path``, when
+        ``cde_lint`` already names something in the tree).
     """
     if not candidate_tuple or candidate_tuple in all_identifier_tuples:
         return None
@@ -468,6 +547,8 @@ def _near_miss_identifier(
             continue
         if not _diverges_only_in_final_token(candidate_tuple, each_identifier):
             continue
+        if candidate_tuple[:-1] in all_known_identifier_tuples:
+            continue
         diverging_words = [
             each_word
             for each_word, each_token in zip(candidate_tuple, each_identifier)
@@ -489,6 +570,7 @@ def _findings_for_line(
     all_identifier_tuples: frozenset[IdentifierTuple],
     identifiers_by_first_token: dict[str, list[IdentifierTuple]],
     all_identifier_tokens: frozenset[str],
+    all_known_identifier_tuples: frozenset[IdentifierTuple],
 ) -> list[str]:
     """Return the near-miss findings for one added line.
 
@@ -500,6 +582,8 @@ def _findings_for_line(
         identifiers_by_first_token: Identifier tuples grouped by leading token.
         all_identifier_tokens: Every token of every identifier on added code
             lines, used to spare prose built from real code vocabulary.
+        all_known_identifier_tuples: Every identifier tuple the sweep knows
+            about, passed through to :func:`_near_miss_identifier`.
 
     Returns:
         One finding string per distinct near-miss term on the line.
@@ -515,6 +599,7 @@ def _findings_for_line(
                 all_identifier_tuples,
                 identifiers_by_first_token,
                 all_identifier_tokens,
+                all_known_identifier_tuples,
             )
             if matched_identifier is None or each_tuple in reported_tuples:
                 continue
@@ -530,6 +615,48 @@ def _findings_for_line(
     return all_findings
 
 
+def _stem_identifier_tuple_for_code_file(each_file_path: str) -> IdentifierTuple | None:
+    """Return a non-test code file's stem as a multi-word identifier tuple.
+
+    ``None`` when the path is not a swept code file, is a test file, or its
+    stem carries fewer than the minimum identifier token count.
+    """
+    if not _is_swept_non_test_code_file(each_file_path):
+        return None
+    stem_tuple = _identifier_token_tuple(Path(each_file_path).stem)
+    if len(stem_tuple) < MINIMUM_IDENTIFIER_TOKEN_COUNT:
+        return None
+    return stem_tuple
+
+
+def _file_stem_identifier_tuples(
+    all_added_lines: list[tuple[str, int, str]],
+) -> frozenset[IdentifierTuple]:
+    """Return the identifier tuple of each added, non-test code file's stem.
+
+    ::
+
+        touched file:  scripts/cde_lint_partition.py
+        stem tuple:     ("cde", "lint", "partition")
+
+    A file that exists in the tree names something whether or not that name
+    is ever spelled out as a code identifier, so a file's stem joins the
+    known-identifier vocabulary the same way a spelled-out name does.
+
+    Args:
+        all_added_lines: Added-line triples from :func:`_parse_added_lines`.
+
+    Returns:
+        One tuple per distinct, multi-word stem of an added, non-test code
+        file.
+    """
+    return frozenset(
+        stem_tuple
+        for each_file_path, _, _ in all_added_lines
+        if (stem_tuple := _stem_identifier_tuple_for_code_file(each_file_path)) is not None
+    )
+
+
 def _find_terminology_near_misses(
     diff_text: str, all_preexisting_identifier_tuples: frozenset[IdentifierTuple]) -> list[str]:
     all_added_lines = _parse_added_lines(diff_text)
@@ -537,6 +664,9 @@ def _find_terminology_near_misses(
     all_identifier_tokens = frozenset(
         each_token for each_tuple in all_identifier_tuples for each_token in each_tuple
     )
+    all_known_identifier_tuples = all_identifier_tuples | _file_stem_identifier_tuples(
+        all_added_lines
+    )
     introduced_tuples = frozenset(
         each_tuple
         for each_tuple in all_identifier_tuples
@@ -557,6 +687,7 @@ def _find_terminology_near_misses(
                 introduced_tuples,
                 introduced_by_first_token,
                 all_identifier_tokens,
+                all_known_identifier_tuples,
             )
         )
     return all_findings
@@ -605,15 +736,21 @@ def repository_environment() -> dict[str, str]:
 def _identifier_names_on_added_code_lines(diff_text: str) -> frozenset[str]:
     """Return every multi-word identifier name on the diff's added code lines.
 
+    A name bound only inside a test module is left out, matching
+    :func:`_collect_introduced_identifiers`, since it is never treated as
+    introduced terminology and its presence in the base tree is not worth a
+    lookup.
+
     Args:
         diff_text: The unified-diff text to scan.
 
     Returns:
-        The distinct snake_case and camelCase names of two or more tokens.
+        The distinct snake_case and camelCase names of two or more tokens
+        on a non-test-module code line.
     """
     all_names: set[str] = set()
     for each_file_path, _, each_text in _parse_added_lines(diff_text):
-        if _file_extension(each_file_path) not in ALL_SWEEP_CODE_FILE_EXTENSIONS:
+        if not _is_swept_non_test_code_file(each_file_path):
             continue
         all_found_names = SNAKE_CASE_IDENTIFIER_PATTERN.findall(each_text)
         all_found_names += CAMEL_CASE_IDENTIFIER_PATTERN.findall(each_text)

package/_shared/pr-loop/scripts/tests/test_terminology_sweep.py

@@ -626,6 +626,123 @@ def test_does_not_flag_two_token_identifier_first_word_coincidence() -> None:
     assert sweep_diff(diff) == []
 
 
+def test_does_not_flag_window_crossing_a_sentence_boundary() -> None:
+    diff = (
+        "diff --git a/api/quota.py b/api/quota.py\n"
+        "--- a/api/quota.py\n"
+        "+++ a/api/quota.py\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+pull_request_owner = 5\n"
+        "diff --git a/README.md b/README.md\n"
+        "--- a/README.md\n"
+        "+++ b/README.md\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+Merge the pull request. Trigger warnings surface elsewhere.\n"
+    )
+    assert sweep_diff(diff) == []
+
+
+def test_does_not_flag_window_crossing_a_markdown_link_target() -> None:
+    diff = (
+        "diff --git a/api/quota.py b/api/quota.py\n"
+        "--- a/api/quota.py\n"
+        "+++ a/api/quota.py\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+pull_request_owner = 5\n"
+        "diff --git a/README.md b/README.md\n"
+        "--- a/README.md\n"
+        "+++ b/README.md\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+See the pull request [`link`](docs/README.md) explains it.\n"
+    )
+    assert sweep_diff(diff) == []
+
+
+def test_does_not_flag_identifier_bound_only_in_a_test_module() -> None:
+    diff = (
+        "diff --git a/tests/test_config.py b/tests/test_config.py\n"
+        "--- a/tests/test_config.py\n"
+        "+++ b/tests/test_config.py\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+jon_pc_json = load_fixture()\n"
+        "diff --git a/README.md b/README.md\n"
+        "--- a/README.md\n"
+        "+++ b/README.md\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+The jon pc export runs first.\n"
+    )
+    assert sweep_diff(diff) == []
+
+
+def test_still_flags_identifier_bound_in_a_production_module() -> None:
+    diff = (
+        "diff --git a/api/config.py b/api/config.py\n"
+        "--- a/api/config.py\n"
+        "+++ b/api/config.py\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+jon_pc_json = load_config()\n"
+        "diff --git a/README.md b/README.md\n"
+        "--- a/README.md\n"
+        "+++ b/README.md\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+The jon pc export runs first.\n"
+    )
+    findings = sweep_diff(diff)
+    assert len(findings) == 1
+    assert "jon pc export" in findings[0]
+
+
+def test_does_not_flag_window_whose_leading_tokens_are_a_known_identifier() -> None:
+    diff = (
+        "diff --git a/api/store.py b/api/store.py\n"
+        "--- a/api/store.py\n"
+        "+++ b/api/store.py\n"
+        "@@ -0,0 +1,2 @@\n"
+        "+cde_lint_path = Path(value)\n"
+        '+HELP_TEXT = "cde_lint standard output"\n'
+    )
+    assert sweep_diff(diff) == []
+
+
+def test_still_flags_window_whose_leading_tokens_name_nothing_known() -> None:
+    diff = (
+        "diff --git a/api/quota.py b/api/quota.py\n"
+        "--- a/api/quota.py\n"
+        "+++ b/api/quota.py\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+premium_request_interactions = 5\n"
+        "diff --git a/docs/README.md b/docs/README.md\n"
+        "--- a/docs/README.md\n"
+        "+++ b/docs/README.md\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+The premium request budget gates the run.\n"
+    )
+    findings = sweep_diff(diff)
+    assert len(findings) == 1
+    assert "premium request budget" in findings[0]
+
+
+def test_does_not_flag_window_whose_leading_tokens_are_an_added_files_stem() -> None:
+    diff = (
+        "diff --git a/scripts/cde_lint.py b/scripts/cde_lint.py\n"
+        "--- a/scripts/cde_lint.py\n"
+        "+++ b/scripts/cde_lint.py\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+VERSION = 1\n"
+        "diff --git a/scripts/cde_lint_partition.py b/scripts/cde_lint_partition.py\n"
+        "--- a/scripts/cde_lint_partition.py\n"
+        "+++ b/scripts/cde_lint_partition.py\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+cde_lint_owner = 5\n"
+        "diff --git a/docs/README.md b/docs/README.md\n"
+        "--- a/docs/README.md\n"
+        "+++ b/docs/README.md\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+Run cde_lint standard checks first.\n"
+    )
+    assert sweep_diff(diff) == []
+
+
 def test_flags_near_miss_when_second_leading_token_is_plural_variant() -> None:
     diff = (
         "diff --git a/api/store.py b/api/store.py\n"
@@ -642,3 +759,16 @@ def test_flags_near_miss_when_second_leading_token_is_plural_variant() -> None:
     findings = sweep_diff(diff)
     assert len(findings) == 1
     assert "retry policies limit" in findings[0]
+
+
+def test_a_swept_code_file_outside_the_test_modules_reads_as_swept() -> None:
+    assert sweep_module._is_swept_non_test_code_file("api/store.py") is True
+
+
+def test_a_test_module_does_not_read_as_a_swept_code_file() -> None:
+    assert sweep_module._is_swept_non_test_code_file("api/test_store.py") is False
+    assert sweep_module._is_swept_non_test_code_file("api/tests/store.py") is False
+
+
+def test_a_markdown_document_does_not_read_as_a_swept_code_file() -> None:
+    assert sweep_module._is_swept_non_test_code_file("docs/README.md") is False

package/bin/install.test.mjs

@@ -2928,6 +2928,31 @@ test('retired skills leave install groups and stay in the cleanup registry', ()
     }
 });
 
+test('the README agents section names the shipped agent, not archived personal agents', () => {
+    const readme = readFileSync(new URL('../../../README.md', import.meta.url), 'utf8');
+    const agentsSection = readme.slice(
+        readme.indexOf('### Agents'),
+        readme.indexOf('### Commands'),
+    );
+    assert.match(agentsSection, /`poteto-agent`/);
+    for (const archivedAgentName of [
+        'clean-coder',
+        'code-quality-agent',
+        'git-commit-crafter',
+        'issue-tracker',
+        'plan-packet-validator',
+        'pr-description-writer',
+        'session-advisor',
+        'skill-writer-agent',
+    ]) {
+        assert.equal(
+            agentsSection.includes(`\`${archivedAgentName}\``),
+            false,
+            `${archivedAgentName} is archived and should not appear as a shipped agent`,
+        );
+    }
+});
+
 test('the README names current session tools', () => {
     const readme = readFileSync(new URL('../../../README.md', import.meta.url), 'utf8');
     assert.doesNotMatch(readme, /--only journal|session-log|session-tidy/);