From 72229119a3e056ac41e7a2aea787be8bf3bec54e Mon Sep 17 00:00:00 2001 From: L4XB Date: Fri, 23 Oct 2026 01:24:15 +0200 Subject: [PATCH 1/9] fix(docs-governance): ignore link-shaped text inside HTML comments The audit read links inside comments, so a commented-out link to a removed or planned page was reported as a broken Markdown link. Blank out closed HTML comments after code is removed, the same way code examples are already skipped; an opener without a closer stays literal text, as in CommonMark. The three copies of markdown_links.py stay identical, and the skill trigger manifest's registry binding is refreshed for the changed skill files. --- .../docs-governance/scripts/markdown_links.py | 24 ++++++++++++++++++- manifests/context-packs/skill-triggers@1.json | 2 +- .../docs-governance/scripts/markdown_links.py | 24 ++++++++++++++++++- .../docs-governance/scripts/markdown_links.py | 24 ++++++++++++++++++- tests/test_docs_governance_audit.py | 14 +++++++++++ 5 files changed, 84 insertions(+), 4 deletions(-) diff --git a/.agents/skills/docs-governance/scripts/markdown_links.py b/.agents/skills/docs-governance/scripts/markdown_links.py index bb4612469..05ebb3423 100644 --- a/.agents/skills/docs-governance/scripts/markdown_links.py +++ b/.agents/skills/docs-governance/scripts/markdown_links.py @@ -74,6 +74,28 @@ def without_inline_code(text: str) -> str: return "".join(output) +def without_html_comments(text: str) -> str: + """Blank out HTML comments, where link-shaped text is not a link. + + A comment runs from `` after it (`` and `` included). An + opener with no closer is left alone, as CommonMark leaves it literal text inline. + """ + output: list[str] = [] + cursor = 0 + while True: + start = text.find("", start + 2) + if end == -1: + break + output.append(text[cursor:start]) + output.append(re.sub(r"[^\n]", " ", text[start : end + 3])) + cursor = end + 3 + output.append(text[cursor:]) + return "".join(output) + + def inline_link_targets(text: str) -> list[str]: targets: list[str] = [] matches = list(INLINE_LINK_START_RE.finditer(text)) @@ -173,7 +195,7 @@ def reference_link_targets(text: str) -> list[str]: def markdown_link_targets(text: str) -> list[str]: - text = without_inline_code(without_fenced_code(text)) + text = without_html_comments(without_inline_code(without_fenced_code(text))) return inline_link_targets(text) + reference_link_targets(text) diff --git a/manifests/context-packs/skill-triggers@1.json b/manifests/context-packs/skill-triggers@1.json index a49a8c824..edcb97000 100644 --- a/manifests/context-packs/skill-triggers@1.json +++ b/manifests/context-packs/skill-triggers@1.json @@ -10,7 +10,7 @@ "id": "hand-seeded", "source": "manual-curation-pending-regeneration" }, - "registryDigest": "498caee2738006d64530e9be34883111cf67742d8c4389f39d61299e1a1c4400", + "registryDigest": "26e3471f7d97e474b311e1cc45c3d967f5be98fca09f264a8cfd8de33ac1158d", "schemaVersion": 1, "triggers": { "skill:agent-runtime-gateway-smoke-test": [ diff --git a/pi/core/skills/docs-governance/scripts/markdown_links.py b/pi/core/skills/docs-governance/scripts/markdown_links.py index bb4612469..05ebb3423 100644 --- a/pi/core/skills/docs-governance/scripts/markdown_links.py +++ b/pi/core/skills/docs-governance/scripts/markdown_links.py @@ -74,6 +74,28 @@ def without_inline_code(text: str) -> str: return "".join(output) +def without_html_comments(text: str) -> str: + """Blank out HTML comments, where link-shaped text is not a link. + + A comment runs from `` after it (`` and `` included). An + opener with no closer is left alone, as CommonMark leaves it literal text inline. + """ + output: list[str] = [] + cursor = 0 + while True: + start = text.find("", start + 2) + if end == -1: + break + output.append(text[cursor:start]) + output.append(re.sub(r"[^\n]", " ", text[start : end + 3])) + cursor = end + 3 + output.append(text[cursor:]) + return "".join(output) + + def inline_link_targets(text: str) -> list[str]: targets: list[str] = [] matches = list(INLINE_LINK_START_RE.finditer(text)) @@ -173,7 +195,7 @@ def reference_link_targets(text: str) -> list[str]: def markdown_link_targets(text: str) -> list[str]: - text = without_inline_code(without_fenced_code(text)) + text = without_html_comments(without_inline_code(without_fenced_code(text))) return inline_link_targets(text) + reference_link_targets(text) diff --git a/skills/docs-governance/scripts/markdown_links.py b/skills/docs-governance/scripts/markdown_links.py index bb4612469..05ebb3423 100644 --- a/skills/docs-governance/scripts/markdown_links.py +++ b/skills/docs-governance/scripts/markdown_links.py @@ -74,6 +74,28 @@ def without_inline_code(text: str) -> str: return "".join(output) +def without_html_comments(text: str) -> str: + """Blank out HTML comments, where link-shaped text is not a link. + + A comment runs from `` after it (`` and `` included). An + opener with no closer is left alone, as CommonMark leaves it literal text inline. + """ + output: list[str] = [] + cursor = 0 + while True: + start = text.find("", start + 2) + if end == -1: + break + output.append(text[cursor:start]) + output.append(re.sub(r"[^\n]", " ", text[start : end + 3])) + cursor = end + 3 + output.append(text[cursor:]) + return "".join(output) + + def inline_link_targets(text: str) -> list[str]: targets: list[str] = [] matches = list(INLINE_LINK_START_RE.finditer(text)) @@ -173,7 +195,7 @@ def reference_link_targets(text: str) -> list[str]: def markdown_link_targets(text: str) -> list[str]: - text = without_inline_code(without_fenced_code(text)) + text = without_html_comments(without_inline_code(without_fenced_code(text))) return inline_link_targets(text) + reference_link_targets(text) diff --git a/tests/test_docs_governance_audit.py b/tests/test_docs_governance_audit.py index 04c39dd73..073f4676b 100644 --- a/tests/test_docs_governance_audit.py +++ b/tests/test_docs_governance_audit.py @@ -266,6 +266,20 @@ def test_artifact_scope_ignores_links_inside_code_examples(project: Path) -> Non assert result.returncode == 0, result.stdout +def test_artifact_scope_ignores_links_inside_html_comments(project: Path) -> None: + (project / "guide.md").write_text( + "Intro text\n\n" + "\n\n" + " [after](missing-after.md)\n", + encoding="utf-8", + ) + result = run_audit(project, "artifacts") + assert result.returncode == 1 + assert "missing-inline.md" not in result.stdout + assert "missing-draft.md" not in result.stdout + assert "Broken Markdown link: 'guide.md' -> 'missing-after.md'" in result.stdout + + def test_artifact_scope_ignores_title_with_escaped_quotes(project: Path) -> None: (project / "guide.md").write_text("# Guide\n", encoding="utf-8") (project / "index.md").write_text( From bf38bfcae2fad5a0e5f030b2d1b71ba99eb4eefc Mon Sep 17 00:00:00 2001 From: L4XB Date: Fri, 23 Oct 2026 01:54:04 +0200 Subject: [PATCH 2/9] fix(docs-governance): read HTML comments and code spans in one pass, as CommonMark does Code spans were blanked before comments, so a code span could swallow a comment's closer and the comment then hid a real link after it. Comments and code spans are now read left to right, whichever opens first. An escaped \` after it (`` and `` included). It + becomes an opaque run of NUL characters, so a link or a reference definition cannot continue + through it, as none can through raw HTML. An escaped `\\", cursor + 2) + if closing != -1: + output.extend( + "\n" if character == "\n" else "\0" + for character in text[cursor : closing + 3] + ) + cursor = closing + 3 + continue + # -- no closer here means none for any later opener either -- + comments_can_close = False if text[cursor] != "`": output.append(text[cursor]) cursor += 1 @@ -74,28 +100,6 @@ def without_inline_code(text: str) -> str: return "".join(output) -def without_html_comments(text: str) -> str: - """Blank out HTML comments, where link-shaped text is not a link. - - A comment runs from `` after it (`` and `` included). An - opener with no closer is left alone, as CommonMark leaves it literal text inline. - """ - output: list[str] = [] - cursor = 0 - while True: - start = text.find("", start + 2) - if end == -1: - break - output.append(text[cursor:start]) - output.append(re.sub(r"[^\n]", " ", text[start : end + 3])) - cursor = end + 3 - output.append(text[cursor:]) - return "".join(output) - - def inline_link_targets(text: str) -> list[str]: targets: list[str] = [] matches = list(INLINE_LINK_START_RE.finditer(text)) @@ -195,7 +199,7 @@ def reference_link_targets(text: str) -> list[str]: def markdown_link_targets(text: str) -> list[str]: - text = without_html_comments(without_inline_code(without_fenced_code(text))) + text = without_inline_code_and_html_comments(without_fenced_code(text)) return inline_link_targets(text) + reference_link_targets(text) diff --git a/manifests/context-packs/skill-triggers@1.json b/manifests/context-packs/skill-triggers@1.json index edcb97000..dbe73c73e 100644 --- a/manifests/context-packs/skill-triggers@1.json +++ b/manifests/context-packs/skill-triggers@1.json @@ -10,7 +10,7 @@ "id": "hand-seeded", "source": "manual-curation-pending-regeneration" }, - "registryDigest": "26e3471f7d97e474b311e1cc45c3d967f5be98fca09f264a8cfd8de33ac1158d", + "registryDigest": "f2a5daa835fd6ed2974e14b3f6118ac640115fd8caf10fd8568f1b8adc9a432b", "schemaVersion": 1, "triggers": { "skill:agent-runtime-gateway-smoke-test": [ diff --git a/pi/core/skills/docs-governance/scripts/markdown_links.py b/pi/core/skills/docs-governance/scripts/markdown_links.py index 05ebb3423..c0da8da97 100644 --- a/pi/core/skills/docs-governance/scripts/markdown_links.py +++ b/pi/core/skills/docs-governance/scripts/markdown_links.py @@ -49,10 +49,36 @@ def without_fenced_code(text: str) -> str: return "".join(output) -def without_inline_code(text: str) -> str: +def _is_escaped(text: str, index: int) -> bool: + backslashes = 0 + while index - backslashes > 0 and text[index - backslashes - 1] == "\\": + backslashes += 1 + return backslashes % 2 == 1 + + +def without_inline_code_and_html_comments(text: str) -> str: + """Blank out inline code spans and HTML comments, whichever opens first. + + A comment runs from `` after it (`` and `` included). It + becomes an opaque run of NUL characters, so a link or a reference definition cannot continue + through it, as none can through raw HTML. An escaped `\\", cursor + 2) + if closing != -1: + output.extend( + "\n" if character == "\n" else "\0" + for character in text[cursor : closing + 3] + ) + cursor = closing + 3 + continue + # -- no closer here means none for any later opener either -- + comments_can_close = False if text[cursor] != "`": output.append(text[cursor]) cursor += 1 @@ -74,28 +100,6 @@ def without_inline_code(text: str) -> str: return "".join(output) -def without_html_comments(text: str) -> str: - """Blank out HTML comments, where link-shaped text is not a link. - - A comment runs from `` after it (`` and `` included). An - opener with no closer is left alone, as CommonMark leaves it literal text inline. - """ - output: list[str] = [] - cursor = 0 - while True: - start = text.find("", start + 2) - if end == -1: - break - output.append(text[cursor:start]) - output.append(re.sub(r"[^\n]", " ", text[start : end + 3])) - cursor = end + 3 - output.append(text[cursor:]) - return "".join(output) - - def inline_link_targets(text: str) -> list[str]: targets: list[str] = [] matches = list(INLINE_LINK_START_RE.finditer(text)) @@ -195,7 +199,7 @@ def reference_link_targets(text: str) -> list[str]: def markdown_link_targets(text: str) -> list[str]: - text = without_html_comments(without_inline_code(without_fenced_code(text))) + text = without_inline_code_and_html_comments(without_fenced_code(text)) return inline_link_targets(text) + reference_link_targets(text) diff --git a/skills/docs-governance/scripts/markdown_links.py b/skills/docs-governance/scripts/markdown_links.py index 05ebb3423..c0da8da97 100644 --- a/skills/docs-governance/scripts/markdown_links.py +++ b/skills/docs-governance/scripts/markdown_links.py @@ -49,10 +49,36 @@ def without_fenced_code(text: str) -> str: return "".join(output) -def without_inline_code(text: str) -> str: +def _is_escaped(text: str, index: int) -> bool: + backslashes = 0 + while index - backslashes > 0 and text[index - backslashes - 1] == "\\": + backslashes += 1 + return backslashes % 2 == 1 + + +def without_inline_code_and_html_comments(text: str) -> str: + """Blank out inline code spans and HTML comments, whichever opens first. + + A comment runs from `` after it (`` and `` included). It + becomes an opaque run of NUL characters, so a link or a reference definition cannot continue + through it, as none can through raw HTML. An escaped `\\", cursor + 2) + if closing != -1: + output.extend( + "\n" if character == "\n" else "\0" + for character in text[cursor : closing + 3] + ) + cursor = closing + 3 + continue + # -- no closer here means none for any later opener either -- + comments_can_close = False if text[cursor] != "`": output.append(text[cursor]) cursor += 1 @@ -74,28 +100,6 @@ def without_inline_code(text: str) -> str: return "".join(output) -def without_html_comments(text: str) -> str: - """Blank out HTML comments, where link-shaped text is not a link. - - A comment runs from `` after it (`` and `` included). An - opener with no closer is left alone, as CommonMark leaves it literal text inline. - """ - output: list[str] = [] - cursor = 0 - while True: - start = text.find("", start + 2) - if end == -1: - break - output.append(text[cursor:start]) - output.append(re.sub(r"[^\n]", " ", text[start : end + 3])) - cursor = end + 3 - output.append(text[cursor:]) - return "".join(output) - - def inline_link_targets(text: str) -> list[str]: targets: list[str] = [] matches = list(INLINE_LINK_START_RE.finditer(text)) @@ -195,7 +199,7 @@ def reference_link_targets(text: str) -> list[str]: def markdown_link_targets(text: str) -> list[str]: - text = without_html_comments(without_inline_code(without_fenced_code(text))) + text = without_inline_code_and_html_comments(without_fenced_code(text)) return inline_link_targets(text) + reference_link_targets(text) diff --git a/tests/test_docs_governance_audit.py b/tests/test_docs_governance_audit.py index 073f4676b..1c6b1ad56 100644 --- a/tests/test_docs_governance_audit.py +++ b/tests/test_docs_governance_audit.py @@ -280,6 +280,23 @@ def test_artifact_scope_ignores_links_inside_html_comments(project: Path) -> Non assert "Broken Markdown link: 'guide.md' -> 'missing-after.md'" in result.stdout +def test_artifact_scope_reads_html_comments_as_commonmark_does(project: Path) -> None: + (project / "guide.md").write_text( + # -- an escaped opener is text, so the link after it is real -- + "Intro \\\n\n" + # -- a comment that opens before a code span ends at its own closer -- + " `sample` [after-code](missing-after-code.md)\n\n" + # -- a comment where a destination must begin does not make a definition -- + "[foo]: missing-definition.md\n\n[foo]\n", + encoding="utf-8", + ) + result = run_audit(project, "artifacts") + assert result.returncode == 1 + assert "Broken Markdown link: 'guide.md' -> 'missing-escaped.md'" in result.stdout + assert "Broken Markdown link: 'guide.md' -> 'missing-after-code.md'" in result.stdout + assert "missing-definition.md" not in result.stdout + + def test_artifact_scope_ignores_title_with_escaped_quotes(project: Path) -> None: (project / "guide.md").write_text("# Guide\n", encoding="utf-8") (project / "index.md").write_text( From f6d7f5c37ef8970685097253d100290315ccfa88 Mon Sep 17 00:00:00 2001 From: L4XB Date: Fri, 23 Oct 2026 02:08:24 +0200 Subject: [PATCH 3/9] fix(docs-governance): keep fence lines inside comment blocks and blanked comments out of targets A fence line inside an HTML comment block opened a fence that ran past the comment's closer, so the comment then had no closer and a link inside the real fence after it was audited. The fence pass now skips comment blocks that open at the start of a line. A destination made only of a blanked comment, as in [bar]: , is no longer returned as a link target. --- .../docs-governance/scripts/markdown_links.py | 13 ++++++++++++- manifests/context-packs/skill-triggers@1.json | 2 +- .../docs-governance/scripts/markdown_links.py | 13 ++++++++++++- skills/docs-governance/scripts/markdown_links.py | 13 ++++++++++++- tests/test_docs_governance_audit.py | 7 ++++++- 5 files changed, 43 insertions(+), 5 deletions(-) diff --git a/.agents/skills/docs-governance/scripts/markdown_links.py b/.agents/skills/docs-governance/scripts/markdown_links.py index c0da8da97..b8aab58dd 100644 --- a/.agents/skills/docs-governance/scripts/markdown_links.py +++ b/.agents/skills/docs-governance/scripts/markdown_links.py @@ -28,7 +28,14 @@ def without_fenced_code(text: str) -> str: output: list[str] = [] fence_character: str | None = None fence_length = 0 + # -- inside an HTML comment block that opened on an earlier line, a fence line is comment + # -- text, which the inline pass blanks with the rest of the comment -- + in_comment = False for line in text.splitlines(keepends=True): + if in_comment: + in_comment = "-->" not in line + output.append(line) + continue marker = re.match(r"^ {0,3}(`{3,}|~{3,})(.*)$", line) if fence_character is None and marker: fence_character = marker.group(1)[0] @@ -45,6 +52,8 @@ def without_fenced_code(text: str) -> str: fence_length = 0 output.append("\n" if line.endswith("\n") else "") continue + opener = re.match(r"^ {0,3}" not in line[opener.end() - 2 :] output.append(line) return "".join(output) @@ -200,7 +209,9 @@ def reference_link_targets(text: str) -> list[str]: def markdown_link_targets(text: str) -> list[str]: text = without_inline_code_and_html_comments(without_fenced_code(text)) - return inline_link_targets(text) + reference_link_targets(text) + targets = inline_link_targets(text) + reference_link_targets(text) + # -- a destination made of a blanked comment is no link -- + return [target for target in targets if "\0" not in target] def normalize_link_target(raw: str) -> str | None: diff --git a/manifests/context-packs/skill-triggers@1.json b/manifests/context-packs/skill-triggers@1.json index dbe73c73e..4c6a740f8 100644 --- a/manifests/context-packs/skill-triggers@1.json +++ b/manifests/context-packs/skill-triggers@1.json @@ -10,7 +10,7 @@ "id": "hand-seeded", "source": "manual-curation-pending-regeneration" }, - "registryDigest": "f2a5daa835fd6ed2974e14b3f6118ac640115fd8caf10fd8568f1b8adc9a432b", + "registryDigest": "77c061805c8948d8e0b7929816fcfedd4f30136f2c0c3af6d23db92cd3f03379", "schemaVersion": 1, "triggers": { "skill:agent-runtime-gateway-smoke-test": [ diff --git a/pi/core/skills/docs-governance/scripts/markdown_links.py b/pi/core/skills/docs-governance/scripts/markdown_links.py index c0da8da97..b8aab58dd 100644 --- a/pi/core/skills/docs-governance/scripts/markdown_links.py +++ b/pi/core/skills/docs-governance/scripts/markdown_links.py @@ -28,7 +28,14 @@ def without_fenced_code(text: str) -> str: output: list[str] = [] fence_character: str | None = None fence_length = 0 + # -- inside an HTML comment block that opened on an earlier line, a fence line is comment + # -- text, which the inline pass blanks with the rest of the comment -- + in_comment = False for line in text.splitlines(keepends=True): + if in_comment: + in_comment = "-->" not in line + output.append(line) + continue marker = re.match(r"^ {0,3}(`{3,}|~{3,})(.*)$", line) if fence_character is None and marker: fence_character = marker.group(1)[0] @@ -45,6 +52,8 @@ def without_fenced_code(text: str) -> str: fence_length = 0 output.append("\n" if line.endswith("\n") else "") continue + opener = re.match(r"^ {0,3}" not in line[opener.end() - 2 :] output.append(line) return "".join(output) @@ -200,7 +209,9 @@ def reference_link_targets(text: str) -> list[str]: def markdown_link_targets(text: str) -> list[str]: text = without_inline_code_and_html_comments(without_fenced_code(text)) - return inline_link_targets(text) + reference_link_targets(text) + targets = inline_link_targets(text) + reference_link_targets(text) + # -- a destination made of a blanked comment is no link -- + return [target for target in targets if "\0" not in target] def normalize_link_target(raw: str) -> str | None: diff --git a/skills/docs-governance/scripts/markdown_links.py b/skills/docs-governance/scripts/markdown_links.py index c0da8da97..b8aab58dd 100644 --- a/skills/docs-governance/scripts/markdown_links.py +++ b/skills/docs-governance/scripts/markdown_links.py @@ -28,7 +28,14 @@ def without_fenced_code(text: str) -> str: output: list[str] = [] fence_character: str | None = None fence_length = 0 + # -- inside an HTML comment block that opened on an earlier line, a fence line is comment + # -- text, which the inline pass blanks with the rest of the comment -- + in_comment = False for line in text.splitlines(keepends=True): + if in_comment: + in_comment = "-->" not in line + output.append(line) + continue marker = re.match(r"^ {0,3}(`{3,}|~{3,})(.*)$", line) if fence_character is None and marker: fence_character = marker.group(1)[0] @@ -45,6 +52,8 @@ def without_fenced_code(text: str) -> str: fence_length = 0 output.append("\n" if line.endswith("\n") else "") continue + opener = re.match(r"^ {0,3}" not in line[opener.end() - 2 :] output.append(line) return "".join(output) @@ -200,7 +209,9 @@ def reference_link_targets(text: str) -> list[str]: def markdown_link_targets(text: str) -> list[str]: text = without_inline_code_and_html_comments(without_fenced_code(text)) - return inline_link_targets(text) + reference_link_targets(text) + targets = inline_link_targets(text) + reference_link_targets(text) + # -- a destination made of a blanked comment is no link -- + return [target for target in targets if "\0" not in target] def normalize_link_target(raw: str) -> str | None: diff --git a/tests/test_docs_governance_audit.py b/tests/test_docs_governance_audit.py index 1c6b1ad56..27893f0e4 100644 --- a/tests/test_docs_governance_audit.py +++ b/tests/test_docs_governance_audit.py @@ -287,7 +287,10 @@ def test_artifact_scope_reads_html_comments_as_commonmark_does(project: Path) -> # -- a comment that opens before a code span ends at its own closer -- " `sample` [after-code](missing-after-code.md)\n\n" # -- a comment where a destination must begin does not make a definition -- - "[foo]: missing-definition.md\n\n[foo]\n", + "[foo]: missing-definition.md\n\n[foo]\n\n" + "[bar]: \n\n[bar]\n\n" + # -- a fence line inside a comment block is comment text; the fence after it is real -- + "\n```\n[fenced](missing-fenced.md)\n```\n", encoding="utf-8", ) result = run_audit(project, "artifacts") @@ -295,6 +298,8 @@ def test_artifact_scope_reads_html_comments_as_commonmark_does(project: Path) -> assert "Broken Markdown link: 'guide.md' -> 'missing-escaped.md'" in result.stdout assert "Broken Markdown link: 'guide.md' -> 'missing-after-code.md'" in result.stdout assert "missing-definition.md" not in result.stdout + assert "missing-fenced.md" not in result.stdout + assert result.stdout.count("Broken Markdown link") == 2, result.stdout def test_artifact_scope_ignores_title_with_escaped_quotes(project: Path) -> None: From 51fec836dbf68dd66ce430e3cbebc787034ad5e5 Mon Sep 17 00:00:00 2001 From: L4XB Date: Fri, 23 Oct 2026 02:56:22 +0200 Subject: [PATCH 4/9] fix(docs-governance): look for a blanked comment in the link destination, not its title A title may hold comment-shaped text, as in [x](missing.md ""). The filter for blanked comments looked at the whole target, title included, so it dropped that link and its broken destination went unreported. The filter now strips the title first, with the same pattern normalize_link_target uses, which moves to LINK_TITLE_RE. --- .../docs-governance/scripts/markdown_links.py | 26 ++++++++++++------- manifests/context-packs/skill-triggers@1.json | 2 +- .../docs-governance/scripts/markdown_links.py | 26 ++++++++++++------- .../docs-governance/scripts/markdown_links.py | 26 ++++++++++++------- tests/test_docs_governance_audit.py | 9 +++++-- 5 files changed, 59 insertions(+), 30 deletions(-) diff --git a/.agents/skills/docs-governance/scripts/markdown_links.py b/.agents/skills/docs-governance/scripts/markdown_links.py index b8aab58dd..e2ad8a714 100644 --- a/.agents/skills/docs-governance/scripts/markdown_links.py +++ b/.agents/skills/docs-governance/scripts/markdown_links.py @@ -18,6 +18,9 @@ REFERENCE_DEFINITION_RE = re.compile( REFERENCE_USAGE_RE = re.compile( r"(?[^\]\n]+)\](?:\[(?P