claude-dev-env 8.17.0 → 8.18.0

package/.agents/skills/eli5/SKILL.md

@@ -71,6 +71,8 @@ keep ownership of their native artifact rules while ELI5 supplies the global
 - Preserve an explicit user-supplied output path and an existing artifact path.
 - Keep one artifact path across all updates in the active task or conversation.
 - Keep every page self-contained and browser-ready.
+- Give every source change a card in a digest. The reader reads less and still
+  knows every change, so a dropped change is a defect.
 - Preserve native wrapper, payload, evidence, and file-format contracts owned by
   the named capability skill.
 - Use human review for accuracy, terminology, safety, confidentiality, meaning,
@@ -92,7 +94,19 @@ Process steps in order.
    `~/.claude/rules/asd-ste100-language.md` to every sentence. Frame the topic
    for a beginner, use a large useful visual, keep the text minimal, and update
    the same artifact in place.
-3. **Judgment — share the updated artifact with the user.**
+3. **Deterministic — run the digest check on a summary of many changes.** A
+   summary of a set of changes, such as the pull requests merged in a day, is a
+   digest. Give each change one card marked `data-digest-card="<id>"` that holds
+   its picture and its one-line change. Pass every source id to the check:
+
+   ```bash
+   python "$HOME/.claude/scripts/digest_check.py" <page.html> --expect <id> <id>
+   ```
+
+   The check reports each source id with no card, each card over 25 words, each
+   card without a picture, and more than 40 words outside the cards. Fix every
+   finding and run it again until it prints `CLEAN`.
+4. **Judgment — share the updated artifact with the user.**
 
 ### Examples
 

package/.agents/skills/eli5/reference/task-seeds.md

@@ -7,4 +7,6 @@ the start of the ELI5 process.
 2. Create the artifact when no active path exists and keep it self-contained.
 3. Apply the ASD-STE100 rule to page and response sentences.
 4. Add the concise beginner explanation and useful large visual in place.
-5. Share the updated artifact with the user.
+5. Run `digest_check.py` on a digest with every source id until it prints
+   `CLEAN`.
+6. Share the updated artifact with the user.

package/bin/merge_managed_permissions.test.mjs

@@ -0,0 +1,87 @@
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import {
+    emptyManagedPermissions,
+    managedPermissionsFromPackageSettings,
+    countManagedPermissions,
+    retiredManagedPermissions,
+    mergeManagedPermissionsIntoSettings,
+    pruneManagedPermissionsFromSettings,
+} from './merge_managed_permissions.mjs';
+
+test('emptyManagedPermissions returns separate empty records', () => {
+    const first = emptyManagedPermissions();
+    const second = emptyManagedPermissions();
+    assert.deepEqual(first, { allow: [], deny: [] });
+    first.allow.push('Read(./managed/**)');
+    assert.deepEqual(second, { allow: [], deny: [] });
+});
+
+test('managedPermissionsFromPackageSettings keeps nonblank string rules', () => {
+    const settings = {
+        permissions: {
+            allow: ['Read(./managed/**)', '', '   ', 4],
+            deny: ['Write(./managed/**)', null],
+            ask: ['Write(./user/**)'],
+        },
+    };
+    assert.deepEqual(managedPermissionsFromPackageSettings(settings), {
+        allow: ['Read(./managed/**)'],
+        deny: ['Write(./managed/**)'],
+    });
+    assert.deepEqual(managedPermissionsFromPackageSettings(null), {
+        allow: [],
+        deny: [],
+    });
+});
+
+test('countManagedPermissions counts both owned lists', () => {
+    assert.equal(countManagedPermissions({ allow: ['read-a', 'read-b'], deny: ['write-a'] }), 3);
+});
+
+test('retiredManagedPermissions keeps only rules absent from the same current list', () => {
+    const prior = {
+        allow: ['Read(./old/**)', 'Read(./keep/**)'],
+        deny: ['Write(./keep/**)', 'Write(./old/**)'],
+    };
+    const current = {
+        allow: ['Read(./keep/**)'],
+        deny: ['Write(./keep/**)'],
+    };
+    assert.deepEqual(retiredManagedPermissions(prior, current), {
+        allow: ['Read(./old/**)'],
+        deny: ['Write(./old/**)'],
+    });
+    assert.equal(prior.allow.length, 2);
+    assert.equal(prior.deny.length, 2);
+});
+
+test('mergeManagedPermissionsIntoSettings adds owned rules once and keeps user rules', () => {
+    const settings = { permissions: { allow: ['Read(./user/**)'], ask: ['Write(./user/**)'] } };
+    const managed = { allow: ['Read(./managed/**)'], deny: ['Write(./managed/**)'] };
+    const first = mergeManagedPermissionsIntoSettings(settings, managed);
+    const second = mergeManagedPermissionsIntoSettings(settings, managed);
+    assert.deepEqual([first.addedCount, first.alreadyPresentCount], [2, 0]);
+    assert.deepEqual([second.addedCount, second.alreadyPresentCount], [0, 2]);
+    assert.deepEqual(settings.permissions, {
+        allow: ['Read(./user/**)', 'Read(./managed/**)'],
+        ask: ['Write(./user/**)'],
+        deny: ['Write(./managed/**)'],
+    });
+});
+
+test('pruneManagedPermissionsFromSettings removes owned rules and keeps user rules', () => {
+    const settings = {
+        permissions: {
+            allow: ['Read(./user/**)', 'Read(./managed/**)'],
+            ask: ['Write(./user/**)'],
+            deny: ['Write(./managed/**)'],
+        },
+    };
+    const managed = { allow: ['Read(./managed/**)'], deny: ['Write(./managed/**)'] };
+    assert.deepEqual(pruneManagedPermissionsFromSettings(settings, managed), { removedCount: 2 });
+    assert.deepEqual(settings.permissions, {
+        allow: ['Read(./user/**)'],
+        ask: ['Write(./user/**)'],
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.17.0",
+    "version": "8.18.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

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/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/test_digest_check.py

@@ -0,0 +1,147 @@
+"""Tests for the digest page check."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+_SCRIPTS_DIRECTORY = Path(__file__).resolve().parent
+if str(_SCRIPTS_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIRECTORY))
+
+import digest_check
+from dev_env_scripts_constants.digest_check_constants import (
+    CARD_WORD_BUDGET,
+    LEAD_WORD_BUDGET,
+)
+
+PICTURE = '<svg viewBox="0 0 10 10"><rect width="10" height="10"/></svg>'
+
+
+def _card(card_id: str, words: str, picture: str = PICTURE) -> str:
+    return f'<section data-digest-card="{card_id}">{picture}<p>{words}</p></section>'
+
+
+def _page(*all_parts: str, lead: str = "Merged today") -> str:
+    body = "".join(all_parts)
+    return (
+        "<!doctype html><html><head><title>Digest</title>"
+        "<style>p{margin:0}</style></head>"
+        f"<body><h1>{lead}</h1>{body}"
+        "<script>const words = 'one two three four five';</script></body></html>"
+    )
+
+
+def _findings(page_html: str, all_expected_ids: list[str]) -> list[str]:
+    page = digest_check.read_digest_page(page_html)
+    return digest_check.digest_findings(page, all_expected_ids)
+
+
+def test_page_covering_every_card_briefly_with_pictures_passes() -> None:
+    page_html = _page(
+        _card("4701", "Search now keeps your filters."),
+        _card("4702", "Exports finish twice as fast."),
+    )
+    assert _findings(page_html, ["4701", "4702"]) == []
+
+
+def test_page_leaving_out_an_expected_card_reports_it() -> None:
+    page_html = _page(_card("4701", "Search now keeps your filters."))
+    assert _findings(page_html, ["4701", "4715"]) == [
+        "missing card 4715: the page leaves it out"
+    ]
+
+
+def test_card_over_the_word_budget_reports_its_count() -> None:
+    long_words = " ".join(["word"] * (CARD_WORD_BUDGET + 1))
+    page_html = _page(_card("4701", long_words))
+    assert _findings(page_html, ["4701"]) == [
+        f"card 4701 carries {CARD_WORD_BUDGET + 1} words; "
+        f"the budget is {CARD_WORD_BUDGET}"
+    ]
+
+
+def test_card_at_the_word_budget_passes() -> None:
+    page_html = _page(_card("4701", " ".join(["word"] * CARD_WORD_BUDGET)))
+    assert _findings(page_html, ["4701"]) == []
+
+
+def test_card_without_a_picture_reports_it() -> None:
+    page_html = _page(_card("4701", "Search now keeps your filters.", picture=""))
+    assert _findings(page_html, ["4701"]) == ["card 4701 has no picture"]
+
+
+def test_self_closing_image_counts_as_a_picture() -> None:
+    page_html = _page(
+        _card("4701", "Search now keeps your filters.", picture='<img src="a.png"/>')
+    )
+    assert _findings(page_html, ["4701"]) == []
+
+
+def test_lead_text_over_its_budget_reports_the_count() -> None:
+    long_lead = " ".join(["word"] * (LEAD_WORD_BUDGET + 1))
+    page_html = _page(_card("4701", "Search now keeps your filters."), lead=long_lead)
+    assert _findings(page_html, ["4701"]) == [
+        f"text outside the cards carries {LEAD_WORD_BUDGET + 1} words; "
+        f"the budget is {LEAD_WORD_BUDGET}"
+    ]
+
+
+def test_head_script_and_style_text_stay_out_of_the_count() -> None:
+    page = digest_check.read_digest_page(_page(lead="Merged today"))
+    assert page.lead_word_count == 2
+
+
+def test_picture_label_text_counts_toward_its_card() -> None:
+    labelled_picture = "<svg><text>before after</text></svg>"
+    page = digest_check.read_digest_page(
+        _page(_card("4701", "one two", picture=labelled_picture))
+    )
+    assert [each_card.word_count for each_card in page.all_cards] == [4]
+
+
+def test_card_marked_twice_reports_the_duplicate() -> None:
+    page_html = _page(
+        _card("4701", "Search now keeps your filters."),
+        _card("4701", "Search now keeps your filters."),
+    )
+    assert _findings(page_html, ["4701"]) == ["card 4701 appears 2 times"]
+
+
+def test_main_exits_one_and_prints_findings_for_a_missing_card(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    page_path = tmp_path / "digest.html"
+    page_path.write_text(_page(_card("4701", "Search keeps filters.")), encoding="utf-8")
+    exit_code = digest_check.main([str(page_path), "--expect", "4701", "4702"])
+    assert exit_code == 1
+    assert capsys.readouterr().out == "missing card 4702: the page leaves it out\n"
+
+
+def test_main_exits_zero_and_names_the_count_for_a_clean_page(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    page_path = tmp_path / "digest.html"
+    page_path.write_text(_page(_card("4701", "Search keeps filters.")), encoding="utf-8")
+    exit_code = digest_check.main([str(page_path), "--expect", "4701"])
+    assert exit_code == 0
+    assert capsys.readouterr().out == "CLEAN: 1 cards, every one present\n"
+
+
+def test_markup_inside_a_script_leaves_the_cards_intact() -> None:
+    page_html = _page(
+        "<script>if (a<b) { x = '<div data-digest-card=\"9\">'; }</script>",
+        _card("4701", "Search keeps filters."),
+    )
+    assert _findings(page_html, ["4701"]) == []
+
+
+def test_single_quoted_card_marker_and_entities_parse() -> None:
+    page = digest_check.read_digest_page(
+        f"<div data-digest-card='4701'>{PICTURE}<p>Fish &amp; chips</p></div>"
+    )
+    assert [(each_card.card_id, each_card.word_count) for each_card in page.all_cards] == [
+        ("4701", 2)
+    ]

package/scripts/tests/test_policy_lint_rules_callers.py

@@ -23,10 +23,12 @@ def _write(repository_root: Path, relative_path: str, text: str) -> None:
     target.write_text(text, "utf-8")
 
 
-def _added(relative_path: str, prior_text: str | None = None) -> Document:
+def _added(
+    relative_path: str, prior_text: str | None = None, text: str = "print('hi')\n"
+) -> Document:
     return Document(
         PurePosixPath(relative_path),
-        "print('hi')\n",
+        text,
         prior_text,
         None,
         ContentOrigin.REVISION_DIFF,
@@ -138,3 +140,30 @@ def test_should_report_new_ci_and_tools_helpers_only_tests_name(
     all_messages = _messages(tmp_path, (_added(ci_helper), _added(tools_helper)))
 
     assert len(all_messages) == 2
+
+
+def test_should_pass_a_new_module_that_a_called_new_script_imports(
+    tmp_path: Path,
+) -> None:
+    constants_path = f"{_PACKAGE}/scripts/constants/lonely_watcher_constants.py"
+    script_text = "from constants.lonely_watcher_constants import LIMIT\n"
+    _write(tmp_path, _NEW_SCRIPT, script_text)
+    _write(tmp_path, constants_path, "LIMIT = 3\n")
+    _write(tmp_path, ".github/workflows/ci.yml", f"run: python {_NEW_SCRIPT}\n")
+
+    all_documents = (_added(_NEW_SCRIPT, text=script_text), _added(constants_path))
+
+    assert _messages(tmp_path, all_documents) == ()
+
+
+def test_should_report_a_new_module_only_an_uncalled_new_script_imports(
+    tmp_path: Path,
+) -> None:
+    constants_path = f"{_PACKAGE}/scripts/constants/lonely_watcher_constants.py"
+    script_text = "from constants.lonely_watcher_constants import LIMIT\n"
+    _write(tmp_path, _NEW_SCRIPT, script_text)
+    _write(tmp_path, constants_path, "LIMIT = 3\n")
+
+    all_documents = (_added(_NEW_SCRIPT, text=script_text), _added(constants_path))
+
+    assert len(_messages(tmp_path, all_documents)) == 2