psyclaw 0.27.22 → 0.28.0

package/vendor/ars/scripts/test_check_spec_consistency.py

@@ -0,0 +1,1081 @@
+"""Unit tests for check_spec_consistency.py.
+
+Pre-#171, check_spec_consistency.py uses module-level ROOT + ERRORS state.
+These tests monkey-patch ROOT into a TemporaryDirectory containing a minimal
+fixture README, drive a specific checker directly, and read ERRORS. When
+#171 lands the schema-driven manifest, these tests rewrite to call the
+manifest runner instead.
+"""
+from __future__ import annotations
+
+import unittest
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from scripts import check_spec_consistency as csc
+
+
+class TestRelativeMarkdownLinkGrammar(unittest.TestCase):
+    """#794: rendered-link grammar, with the old lint scope retained."""
+
+    def setUp(self) -> None:
+        self._old_root = csc.ROOT
+        csc.ERRORS.clear()
+        self._tmp = TemporaryDirectory()
+        csc.ROOT = Path(self._tmp.name)
+        (csc.ROOT / "docs").mkdir()
+
+    def tearDown(self) -> None:
+        csc.ROOT = self._old_root
+        csc.ERRORS.clear()
+        self._tmp.cleanup()
+
+    def _check(self, text: str) -> list[str]:
+        (csc.ROOT / "docs/PAGE.md").write_text(text, encoding="utf-8")
+        csc.check_relative_markdown_links("docs/PAGE.md")
+        return list(csc.ERRORS)
+
+    def test_rendered_dead_link_still_fires(self) -> None:
+        errors = self._check("[dead](MISSING.md)\n")
+        self.assertTrue(any("MISSING.md" in error for error in errors))
+
+    def test_non_rendering_and_image_targets_do_not_fire(self) -> None:
+        errors = self._check(
+            "![image](missing-image.png)\n"
+            "`[example](missing-inline.md)`\n"
+            "<!-- [commented](missing-comment.md) -->\n"
+            "```markdown\n[fenced](missing-fenced.md)\n```\n"
+        )
+        self.assertEqual(errors, [])
+
+    def test_titled_link_checks_only_its_destination(self) -> None:
+        errors = self._check('[dead](MISSING.md "optional title")\n')
+        self.assertEqual(
+            errors,
+            ["docs/PAGE.md: broken relative markdown link 'MISSING.md'"],
+        )
+
+    def test_existing_file_with_unknown_fragment_remains_out_of_scope(self) -> None:
+        (csc.ROOT / "docs/TARGET.md").write_text("# Real Heading\n", encoding="utf-8")
+        errors = self._check("[pointer](TARGET.md#not-a-real-heading)\n")
+        self.assertEqual(errors, [])
+
+
+# Minimal ja-JP README capturing the version-bearing surfaces the lint needs
+# to police: badge, release tag link, three release blocks (current + two
+# prior so the symmetric structure with check_readme_zh_sections is visible),
+# four localized mode headings, four skill-detail headings, and the DOCX line.
+JA_README_TEMPLATE = """\
+# Academic Research Skills
+
+[![Version](https://img.shields.io/badge/version-v{ver}-blue)](https://github.com/Imbad0202/academic-research-skills/releases/tag/v{ver})
+
+## クイックスタート
+
+#### Deep Research（8 モード）
+- outline-only モード
+- abstract-only モード
+- disclosure モード
+- review モード
+
+#### Academic Paper（11 モード）
+
+#### Academic Paper Reviewer（6 モード）
+- calibration モード
+
+#### Academic Pipeline（オーケストレーター）
+
+### Deep Research（v2.12.1）
+### Academic Paper（v3.3.1）
+### Academic Paper Reviewer（v1.11.1）
+### Academic Pipeline（v{ver}）
+
+### サポートされる出力フォーマット
+
+- DOCX（利用可能な場合 Pandoc 経由）
+
+## Changelog
+
+### v3.12.0 (2026-06-08) — latest entry
+### v3.11.1 (2026-06-06) — prior patch
+### v3.11.0 (2026-06-04) — prior patch
+### v3.10.0 (2026-06-01) — prior minor
+### v3.9.4.2 (2026-05-19) — CI discipline hotfix
+### v3.9.4.1 (2026-05-19) — previous hotfix
+### v3.9.4 (2026-05-18) — temporal verification
+### v3.9.1 (2026-05-18) — client hardening
+### v3.9.0 (2026-05-17) — triangulation
+### v3.8.0 (2026-05-16) — L3 audit
+### v3.7.0 (2026-05-05) — plugin packaging
+### v3.6.8 (2026-05-03) — generator-evaluator
+### v3.6.7 (2026-04-30) — pattern protection
+### v3.6.5 (2026-04-27) — corpus consumer
+### v3.6.4 (2026-04-25) — corpus input port
+### v3.6.3 (2026-04-23) — passport reset
+### v3.6.2 (2026-04-23) — reviewer sprint
+### v3.5.1 (2026-04-22) — reading-check probe
+### v3.5.0 (2026-04-21) — collaboration depth
+### v3.4.0 (2026-04-20) — compliance agent
+### v3.3.6 (2026-04-15) — README streamlining
+### v3.3.5 (2026-04-15)
+### v3.3.4 (2026-04-15) — changelog sync
+### v3.3.3 (2026-04-15) — release prep
+### v3.3.2 (2026-04-15) — data access levels
+
+## Version Info
+- **Suite version**: {ver}
+"""
+
+
+def _write_ja_readme(root: Path, version: str) -> None:
+    (root / "README.ja-JP.md").write_text(
+        JA_README_TEMPLATE.format(ver=version), encoding="utf-8"
+    )
+
+
+# Minimal ko-KR README capturing the version-bearing surfaces check_readme_ko_sections
+# polices: badge, release tag link, the same release-block list as the other locales,
+# four localized mode headings ("N개 모드" with ASCII parens — Korean typographic norm
+# matching English/ja, NOT the full-width zh form), four skill-detail headings (English
+# ASCII-paren form reused verbatim), and the Korean DOCX line.
+KO_README_TEMPLATE = """\
+# Academic Research Skills
+
+[![Version](https://img.shields.io/badge/version-v{ver}-blue)](https://github.com/Imbad0202/academic-research-skills/releases/tag/v{ver})
+
+## 빠른 시작
+
+#### Deep Research (8개 모드)
+- outline-only 모드
+- abstract-only 모드
+- disclosure 모드
+- review 모드
+
+#### Academic Paper (11개 모드)
+
+#### Academic Paper Reviewer (6개 모드)
+- calibration 모드
+
+#### Academic Pipeline (오케스트레이터)
+
+### Deep Research (v2.12.1)
+### Academic Paper (v3.3.1)
+### Academic Paper Reviewer (v1.11.1)
+### Academic Pipeline (v{ver})
+
+### 지원되는 출력 형식
+
+- DOCX (가능한 경우 Pandoc 경유)
+
+## 변경 이력
+
+### v3.21.1 (2026-08-24) — current release
+### v3.18.0 (2026-07-18) — prior minor
+### v3.12.0 (2026-06-08) — prior release
+### v3.11.1 (2026-06-06) — prior patch
+### v3.11.0 (2026-06-04) — prior patch
+### v3.10.0 (2026-06-01) — prior minor
+### v3.9.4.2 (2026-05-19) — CI discipline hotfix
+### v3.9.4.1 (2026-05-19) — previous hotfix
+### v3.9.4 (2026-05-18) — temporal verification
+### v3.9.1 (2026-05-18) — client hardening
+### v3.9.0 (2026-05-17) — triangulation
+### v3.8.0 (2026-05-16) — L3 audit
+### v3.7.0 (2026-05-05) — plugin packaging
+### v3.6.8 (2026-05-03) — generator-evaluator
+### v3.6.7 (2026-04-30) — pattern protection
+### v3.6.5 (2026-04-27) — corpus consumer
+### v3.6.4 (2026-04-25) — corpus input port
+### v3.6.3 (2026-04-23) — passport reset
+### v3.6.2 (2026-04-23) — reviewer sprint
+### v3.5.1 (2026-04-22) — reading-check probe
+### v3.5.0 (2026-04-21) — collaboration depth
+### v3.4.0 (2026-04-20) — compliance agent
+### v3.3.6 (2026-04-15) — README streamlining
+### v3.3.5 (2026-04-15)
+### v3.3.4 (2026-04-15) — changelog sync
+### v3.3.3 (2026-04-15) — release prep
+### v3.3.2 (2026-04-15) — data access levels
+"""
+
+
+def _write_ko_readme(root: Path, version: str) -> None:
+    (root / "README.ko-KR.md").write_text(
+        KO_README_TEMPLATE.format(ver=version), encoding="utf-8"
+    )
+
+
+# Minimal zh-CN README capturing the version-bearing surfaces the lint needs
+# to police via ZH_README_CONFIGS[1]: badge, release tag link, the same
+# release-block list as zh-TW, four Simplified-Chinese localized mode
+# headings, four skill-detail headings, and the Simplified-Chinese DOCX line.
+ZH_CN_README_TEMPLATE = """\
+# Academic Research Skills
+
+[![Version](https://img.shields.io/badge/version-v{ver}-blue)](https://github.com/Imbad0202/academic-research-skills/releases/tag/v{ver})
+
+#### Deep Research（深度研究，8 种模式）
+- review mode
+
+#### Academic Paper（学术论文撰写，11 种模式）
+- outline-only mode
+- abstract-only mode
+- disclosure mode
+
+#### Academic Paper Reviewer（论文审查，6 种模式）
+- calibration mode
+
+#### Academic Pipeline（全流程调度器）
+
+### Deep Research (v2.12.1)
+### Academic Paper (v3.3.1)
+### Academic Paper Reviewer (v1.11.1)
+### Academic Pipeline (v{ver})
+
+### 支持的输出格式
+
+- DOCX（Pandoc 可用时）
+
+## 更新纪录
+
+### v3.12.0（2026-06-08）— latest entry
+### v3.11.1（2026-06-06）— prior patch
+### v3.11.0（2026-06-04）— prior patch
+### v3.10.0（2026-06-01）— prior minor
+### v3.9.4.2（2026-05-19）— CI discipline hotfix
+### v3.9.4.1（2026-05-19）— previous hotfix
+### v3.9.4（2026-05-18）— temporal verification
+### v3.9.1（2026-05-18）— client hardening
+### v3.9.0（2026-05-17）— triangulation
+### v3.8.0（2026-05-16）— L3 audit
+### v3.7.0（2026-05-05）— plugin packaging
+### v3.6.8（2026-05-03）— generator-evaluator
+### v3.6.7（2026-04-30）— pattern protection
+### v3.6.5（2026-04-27）— corpus consumer
+### v3.6.4（2026-04-25）— corpus input port
+### v3.6.3（2026-04-23）— passport reset
+### v3.6.2（2026-04-23）— reviewer sprint
+### v3.5.1（2026-04-22）— reading-check probe
+### v3.5.0（2026-04-21）— collaboration depth
+### v3.4.0（2026-04-20）— compliance agent
+### v3.3.6 (2026-04-15) — README streamlining
+### v3.3.5 (2026-04-15)
+### v3.3.4 (2026-04-15) — changelog sync
+### v3.3.3 (2026-04-15) — release prep
+### v3.3.2 (2026-04-15) — data access levels
+"""
+
+
+def _write_zh_cn_readme(root: Path, version: str) -> None:
+    (root / "README.zh-CN.md").write_text(
+        ZH_CN_README_TEMPLATE.format(ver=version), encoding="utf-8"
+    )
+
+
+# zh-TW fixture matching ZH_README_CONFIGS[0]. check_readme_zh_sections
+# iterates BOTH configs, so to test the zh-CN branch in isolation we still
+# need a passing zh-TW companion (or vice versa). The minimal zh-TW fixture
+# below uses the same shape with Traditional-Chinese localized strings.
+ZH_TW_README_TEMPLATE = """\
+# Academic Research Skills
+
+[![Version](https://img.shields.io/badge/version-v{ver}-blue)](https://github.com/Imbad0202/academic-research-skills/releases/tag/v{ver})
+
+#### Deep Research（深度研究，8 種模式）
+- review mode
+
+#### Academic Paper（學術論文撰寫，11 種模式）
+- outline-only mode
+- abstract-only mode
+- disclosure mode
+
+#### Academic Paper Reviewer（論文審查，6 種模式）
+- calibration mode
+
+#### Academic Pipeline（全流程調度器）
+
+### Deep Research (v2.12.1)
+### Academic Paper (v3.3.1)
+### Academic Paper Reviewer (v1.11.1)
+### Academic Pipeline (v{ver})
+
+### 支援的輸出格式
+
+- DOCX（Pandoc 可用時）
+
+## 更新紀錄
+
+### v3.12.0（2026-06-08）— latest entry
+### v3.11.1（2026-06-06）— prior patch
+### v3.11.0（2026-06-04）— prior patch
+### v3.10.0（2026-06-01）— prior minor
+### v3.9.4.2（2026-05-19）— CI discipline hotfix
+### v3.9.4.1（2026-05-19）— previous hotfix
+### v3.9.4（2026-05-18）— temporal verification
+### v3.9.1（2026-05-18）— client hardening
+### v3.9.0（2026-05-17）— triangulation
+### v3.8.0（2026-05-16）— L3 audit
+### v3.7.0（2026-05-05）— plugin packaging
+### v3.6.8（2026-05-03）— generator-evaluator
+### v3.6.7（2026-04-30）— pattern protection
+### v3.6.5（2026-04-27）— corpus consumer
+### v3.6.4（2026-04-25）— corpus input port
+### v3.6.3（2026-04-23）— passport reset
+### v3.6.2（2026-04-23）— reviewer sprint
+### v3.5.1（2026-04-22）— reading-check probe
+### v3.5.0（2026-04-21）— collaboration depth
+### v3.4.0（2026-04-20）— compliance agent
+### v3.3.6 (2026-04-15) — README streamlining
+### v3.3.5 (2026-04-15)
+### v3.3.4 (2026-04-15) — changelog sync
+### v3.3.3 (2026-04-15) — release prep
+### v3.3.2 (2026-04-15) — data access levels
+"""
+
+
+def _write_zh_tw_readme(root: Path, version: str) -> None:
+    (root / "README.zh-TW.md").write_text(
+        ZH_TW_README_TEMPLATE.format(ver=version), encoding="utf-8"
+    )
+
+
+class TestReadmeJaSections(unittest.TestCase):
+    def setUp(self) -> None:
+        # check_spec_consistency uses module-level ROOT and ERRORS. Reset and
+        # restore around each test so state does not leak between cases.
+        self._orig_root = csc.ROOT
+        self._orig_errors = list(csc.ERRORS)
+        csc.ERRORS.clear()
+
+    def tearDown(self) -> None:
+        csc.ROOT = self._orig_root
+        csc.ERRORS.clear()
+        csc.ERRORS.extend(self._orig_errors)
+
+    def test_aligned_ja_readme_passes(self) -> None:
+        """A README.ja-JP.md whose badge / tag link / release headings all
+        agree with the suite version v3.9.4.2 must pass without errors."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_ja_readme(root, version="3.21.1")
+
+            csc.check_readme_ja_sections()
+
+            self.assertEqual(
+                csc.ERRORS, [],
+                msg=f"unexpected errors on aligned fixture: {csc.ERRORS!r}",
+            )
+
+    def test_stale_ja_badge_fails(self) -> None:
+        """Regression for #170: if README.ja-JP.md keeps a stale v3.9.4.0
+        badge while CHANGELOG has moved to v3.9.4.2, the lint must surface
+        the drift instead of silently passing (pre-fix behavior: this file
+        was outside the lint's needle list and the drift never surfaced)."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            # Write the "current" v3.9.4.2 release block but downgrade only
+            # the badge and tag link to v3.9.4.0. This is the realistic shape
+            # of drift when one place gets forgotten during a release.
+            stale = JA_README_TEMPLATE.format(ver="3.21.1").replace(
+                "version-v3.21.1-blue", "version-v3.9.4.0-blue"
+            ).replace(
+                "releases/tag/v3.21.1", "releases/tag/v3.9.4.0"
+            )
+            (root / "README.ja-JP.md").write_text(stale, encoding="utf-8")
+
+            csc.check_readme_ja_sections()
+
+            self.assertTrue(
+                any("README.ja-JP.md" in e and "v3.21.1" in e for e in csc.ERRORS),
+                msg=f"expected ja-JP drift error in: {csc.ERRORS!r}",
+            )
+
+
+class TestReadmeKoSections(unittest.TestCase):
+    def setUp(self) -> None:
+        # check_spec_consistency uses module-level ROOT and ERRORS. Reset and
+        # restore around each test so state does not leak between cases.
+        self._orig_root = csc.ROOT
+        self._orig_errors = list(csc.ERRORS)
+        csc.ERRORS.clear()
+
+    def tearDown(self) -> None:
+        csc.ROOT = self._orig_root
+        csc.ERRORS.clear()
+        csc.ERRORS.extend(self._orig_errors)
+
+    def test_aligned_ko_readme_passes(self) -> None:
+        """A README.ko-KR.md whose badge / tag link / release headings / Korean
+        mode + skill headings all agree with the suite version must pass."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_ko_readme(root, version="3.21.1")
+
+            csc.check_readme_ko_sections()
+
+            self.assertEqual(
+                csc.ERRORS, [],
+                msg=f"unexpected errors on aligned ko fixture: {csc.ERRORS!r}",
+            )
+
+    def test_stale_ko_badge_fails(self) -> None:
+        """Symmetric to the ja drift regression: a stale badge / tag link on
+        README.ko-KR.md must surface the drift rather than silently passing."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            stale = KO_README_TEMPLATE.format(ver="3.21.1").replace(
+                "version-v3.21.1-blue", "version-v3.9.4.0-blue"
+            ).replace(
+                "releases/tag/v3.21.1", "releases/tag/v3.9.4.0"
+            )
+            (root / "README.ko-KR.md").write_text(stale, encoding="utf-8")
+
+            csc.check_readme_ko_sections()
+
+            self.assertTrue(
+                any("README.ko-KR.md" in e and "v3.21.1" in e for e in csc.ERRORS),
+                msg=f"expected ko-KR drift error in: {csc.ERRORS!r}",
+            )
+
+    def test_missing_korean_mode_heading_fails(self) -> None:
+        """If a localized mode heading is dropped (e.g. the "N개 모드" form is
+        accidentally written in the English "(8 modes)" shape), the lint must
+        catch it — proving the heading checks are load-bearing, not vacuous."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            broken = KO_README_TEMPLATE.format(ver="3.21.1").replace(
+                "#### Deep Research (8개 모드)", "#### Deep Research (8 modes)"
+            )
+            (root / "README.ko-KR.md").write_text(broken, encoding="utf-8")
+
+            csc.check_readme_ko_sections()
+
+            self.assertTrue(
+                any("README.ko-KR.md" in e and "8개 모드" in e for e in csc.ERRORS),
+                msg=f"expected missing-heading error in: {csc.ERRORS!r}",
+            )
+
+    def test_full_width_korean_changelog_parentheses_fail(self) -> None:
+        """Korean changelog headings use ASCII parentheses, not full-width forms."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            broken = KO_README_TEMPLATE.format(ver="3.21.1").replace(
+                "### v3.18.0 (2026-07-18)",
+                "### v3.18.0（2026-07-18）",
+            )
+            (root / "README.ko-KR.md").write_text(broken, encoding="utf-8")
+
+            csc.check_readme_ko_sections()
+
+            self.assertTrue(
+                any(
+                    "README.ko-KR.md" in e
+                    and "### v3.18.0 (2026-07-18)" in e
+                    for e in csc.ERRORS
+                ),
+                msg=f"expected Korean parenthesis-style error in: {csc.ERRORS!r}",
+            )
+
+
+class TestReadmeZhSections(unittest.TestCase):
+    """Coverage for the ZH_README_CONFIGS tuple branch added when zh-CN
+    joined zh-TW under check_readme_zh_sections. check_readme_zh_sections
+    iterates both configs, so both fixtures must exist on every test path."""
+
+    def setUp(self) -> None:
+        self._orig_root = csc.ROOT
+        self._orig_errors = list(csc.ERRORS)
+        csc.ERRORS.clear()
+
+    def tearDown(self) -> None:
+        csc.ROOT = self._orig_root
+        csc.ERRORS.clear()
+        csc.ERRORS.extend(self._orig_errors)
+
+    def test_aligned_zh_cn_readme_passes(self) -> None:
+        """Both zh-TW and zh-CN fixtures aligned to v3.9.4.2 produce no
+        lint errors. Locks the new ZH_README_CONFIGS[1] branch."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_zh_tw_readme(root, version="3.21.1")
+            _write_zh_cn_readme(root, version="3.21.1")
+
+            csc.check_readme_zh_sections()
+
+            self.assertEqual(
+                csc.ERRORS, [],
+                msg=f"unexpected errors on aligned zh fixtures: {csc.ERRORS!r}",
+            )
+
+    def test_stale_zh_cn_badge_fails(self) -> None:
+        """Regression symmetric with #170 ja-JP: if README.zh-CN.md keeps
+        a stale v3.9.4.0 badge while the rest of the file moved to v3.9.4.2,
+        the lint must surface the drift on the zh-CN branch specifically."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_zh_tw_readme(root, version="3.21.1")
+            stale = ZH_CN_README_TEMPLATE.format(ver="3.21.1").replace(
+                "version-v3.21.1-blue", "version-v3.9.4.0-blue"
+            ).replace(
+                "releases/tag/v3.21.1", "releases/tag/v3.9.4.0"
+            )
+            (root / "README.zh-CN.md").write_text(stale, encoding="utf-8")
+
+            csc.check_readme_zh_sections()
+
+            self.assertTrue(
+                any("README.zh-CN.md" in e and "v3.21.1" in e for e in csc.ERRORS),
+                msg=f"expected zh-CN drift error in: {csc.ERRORS!r}",
+            )
+
+
+# Minimal docs/ARCHITECTURE.md fixture carrying the THREE marker kinds the invariant-4 check (#345)
+# must distinguish: current-component markers (mermaid node + component/stage rows, which MUST equal
+# the suite version), a feature-history timeline marker (`vX.Y.Z : <feature>`, which must NOT be
+# policed), and a prose mention of `academic-pipeline vX.Y.Z` (provenance narrative, which must also
+# NOT be policed — it is excluded by the table-row anchor). `{comp}` = current-component version;
+# `{hist}` = timeline version; `{prose}` = the version named in the narrative provenance line.
+ARCHITECTURE_TEMPLATE = """\
+# Architecture
+
+```mermaid
+flowchart TD
+    Pipeline[academic-pipeline<br/>orchestrator<br/>v{comp}<br/>Agent Team: 5]
+```
+
+| Stage | Gate | ... |
+|-------|------|-----|
+| **2.5 INTEGRITY** | `academic-pipeline` v{comp} (gate) | VERIFIED_ONLY |
+| **6. PROCESS SUMMARY** | `academic-pipeline` v{comp} | VERIFIED_ONLY |
+
+| Component | Role |
+|-----------|------|
+| `academic-pipeline` v{comp} | orchestrator (delegates to sub-skill modes) |
+
+The `academic-pipeline` v{prose} release first introduced the integrity gate (narrative provenance).
+
+```mermaid
+timeline
+    title ARS evolution timeline
+    v{hist} : deterministic citation verification gate (#182)
+```
+"""
+
+
+def _write_architecture_fixture(
+    root: Path, *, suite: str, comp: str, hist: str, prose: str | None = None
+) -> None:
+    """Write `.claude/CLAUDE.md` (suite version source) + a docs/ARCHITECTURE.md fixture.
+
+    `prose` defaults to the suite version so the narrative line is innocuous unless a test
+    deliberately sets it to a stale version to assert the prose mention is not policed.
+    """
+    (root / ".claude").mkdir(parents=True, exist_ok=True)
+    (root / ".claude" / "CLAUDE.md").write_text(
+        f"# ARS\n\n- **Suite version**: {suite} (per CHANGELOG.md)\n", encoding="utf-8"
+    )
+    (root / "docs").mkdir(parents=True, exist_ok=True)
+    (root / "docs" / "ARCHITECTURE.md").write_text(
+        ARCHITECTURE_TEMPLATE.format(comp=comp, hist=hist, prose=prose or suite),
+        encoding="utf-8",
+    )
+
+
+class TestArchitectureComponentVersion(unittest.TestCase):
+    """#345: invariant-4 lint for docs/ARCHITECTURE.md current-component version markers."""
+
+    def setUp(self) -> None:
+        self._orig_root = csc.ROOT
+        self._orig_errors = list(csc.ERRORS)
+        csc.ERRORS.clear()
+
+    def tearDown(self) -> None:
+        csc.ROOT = self._orig_root
+        csc.ERRORS.clear()
+        csc.ERRORS.extend(self._orig_errors)
+
+    def test_aligned_passes(self) -> None:
+        """All component markers at the suite version → no errors (timeline at an older version
+        is fine — it records history)."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_architecture_fixture(root, suite="3.11.1", comp="3.11.1", hist="3.11.0")
+
+            csc.check_architecture_component_version()
+
+            self.assertEqual(
+                csc.ERRORS, [], msg=f"unexpected errors on aligned fixture: {csc.ERRORS!r}"
+            )
+
+    def test_stale_component_marker_fails(self) -> None:
+        """A current-component marker left at the prior version (the exact #343/#344 drift) must
+        fail — both the mermaid node and the rows carry the stale version here."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_architecture_fixture(root, suite="3.11.1", comp="3.11.0", hist="3.11.0")
+
+            csc.check_architecture_component_version()
+
+            self.assertTrue(
+                any("ARCHITECTURE.md" in e and "3.11.0" in e and "3.11.1" in e for e in csc.ERRORS),
+                msg=f"expected stale-component drift error in: {csc.ERRORS!r}",
+            )
+
+    def test_stale_timeline_marker_does_not_fail(self) -> None:
+        """The critical distinction: a timeline `vX.Y.Z : <feature>` node at a DIFFERENT version
+        from the suite must NOT fail — it records which version shipped a feature, and a
+        naive `v3.x` scan would wrongly flag it. Component markers are aligned here."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            # Component markers all at the suite version; only the timeline records an old version.
+            _write_architecture_fixture(root, suite="3.11.1", comp="3.11.1", hist="3.9.4")
+
+            csc.check_architecture_component_version()
+
+            self.assertEqual(
+                csc.ERRORS, [],
+                msg=f"timeline marker must not be policed, but got: {csc.ERRORS!r}",
+            )
+
+    def test_missing_component_marker_fails(self) -> None:
+        """If the component markers vanish entirely (e.g. a refactor removes them), the check must
+        surface that rather than silently passing on an empty match."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            (root / ".claude").mkdir(parents=True, exist_ok=True)
+            (root / ".claude" / "CLAUDE.md").write_text(
+                "- **Suite version**: 3.11.1 (per CHANGELOG.md)\n", encoding="utf-8"
+            )
+            (root / "docs").mkdir(parents=True, exist_ok=True)
+            (root / "docs" / "ARCHITECTURE.md").write_text(
+                "# Architecture\n\nNo component markers here.\n", encoding="utf-8"
+            )
+
+            csc.check_architecture_component_version()
+
+            self.assertTrue(
+                any("no mermaid" in e or "no `academic-pipeline" in e for e in csc.ERRORS),
+                msg=f"expected missing-marker error in: {csc.ERRORS!r}",
+            )
+
+    def test_four_component_aligned_passes(self) -> None:
+        """#352 P2: the repo's own grammar ships 4-component versions (v3.9.4.2). A suite and
+        component markers both at a 4-component version must pass — the version regex must capture
+        the FULL token, not truncate to three components."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_architecture_fixture(root, suite="3.9.4.2", comp="3.9.4.2", hist="3.9.4")
+
+            csc.check_architecture_component_version()
+
+            self.assertEqual(
+                csc.ERRORS, [],
+                msg=f"unexpected errors on aligned 4-component fixture: {csc.ERRORS!r}",
+            )
+
+    def test_four_component_marker_against_three_component_suite_fails(self) -> None:
+        """#352 P2 (the silent-pass this fix closes): suite is the 3-component `3.9.4` but a
+        component marker carries the 4-component `3.9.4.2`. A truncating `\\d+\\.\\d+\\.\\d+`
+        would capture `3.9.4` from the marker and falsely pass (3.9.4 == 3.9.4). The full-token
+        capture must instead see `3.9.4.2` and fail it against the suite."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_architecture_fixture(root, suite="3.9.4", comp="3.9.4.2", hist="3.9.4")
+
+            csc.check_architecture_component_version()
+
+            # The error must name the FULL 4-component marker as != the 3-component suite. Asserting
+            # on `!= suite v3.9.4` (not just substring `3.9.4`, which is contained in `3.9.4.2`)
+            # proves the captured marker was the full `3.9.4.2`, i.e. the truncation was closed.
+            self.assertTrue(
+                any("v3.9.4.2" in e and "!= suite v3.9.4 " in e for e in csc.ERRORS),
+                msg=f"expected 4-vs-3-component drift error in: {csc.ERRORS!r}",
+            )
+
+    def test_prose_provenance_mention_does_not_fail(self) -> None:
+        """#352 P3: a narrative line naming `academic-pipeline v<old>` (feature provenance) must
+        NOT be policed against the suite version — only markdown table-row component cells are.
+        Component markers + timeline are aligned/innocuous; only the prose line is stale."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_architecture_fixture(
+                root, suite="3.11.1", comp="3.11.1", hist="3.9.4", prose="3.9.4"
+            )
+
+            csc.check_architecture_component_version()
+
+            self.assertEqual(
+                csc.ERRORS, [],
+                msg=f"prose provenance mention must not be policed, but got: {csc.ERRORS!r}",
+            )
+
+
+# --- #377: SKILL.md frontmatter↔table consistency (all 4) + suite-skill date sanity ---
+
+# Minimal SKILL.md carrying the version-bearing surfaces the #377 check polices: a
+# `metadata:` frontmatter block with `version` / `last_updated`, and a Version-Info table
+# with `| Skill Version |` / `| Last Updated |` rows. Mirrors the real four SKILL.md shape.
+SKILL_TEMPLATE = """\
+---
+name: {name}
+metadata:
+  version: "{fm_ver}"
+  last_updated: "{fm_date}"
+---
+
+# {name}
+
+Body.
+
+## Version Info
+
+| Field | Value |
+|-------|-------|
+| Skill Version | {tbl_ver} |
+| Last Updated | {tbl_date} |
+"""
+
+# The four SKILL.md paths the generalized check must cover, with their real independent
+# versions/dates. `academic-pipeline` tracks the suite; the other three move independently.
+_SKILL_FIXTURES = {
+    "academic-pipeline": ("3.12.0", "2026-06-08"),
+    "academic-paper": ("3.2.0", "2026-06-01"),
+    "academic-paper-reviewer": ("1.10.0", "2026-06-01"),
+    "deep-research": ("2.9.4", "2026-05-18"),
+}
+
+
+def _write_skill_fixtures(root: Path, overrides: dict | None = None) -> None:
+    """Write all four SKILL.md with frontmatter == table by default. `overrides` maps a
+    skill dir to a partial dict of {fm_ver, fm_date, tbl_ver, tbl_date} to introduce drift."""
+    overrides = overrides or {}
+    for skill, (ver, date) in _SKILL_FIXTURES.items():
+        fields = {"fm_ver": ver, "fm_date": date, "tbl_ver": ver, "tbl_date": date}
+        fields.update(overrides.get(skill, {}))
+        (root / skill).mkdir(parents=True, exist_ok=True)
+        (root / skill / "SKILL.md").write_text(
+            SKILL_TEMPLATE.format(name=skill, **fields), encoding="utf-8"
+        )
+
+
+class TestSkillVersionTableConsistency(unittest.TestCase):
+    """#377(a): frontmatter version/last_updated ↔ Version-Info table for ALL FOUR SKILL.md
+    (pre-#377 only academic-paper-reviewer was checked)."""
+
+    def setUp(self) -> None:
+        self._orig_root = csc.ROOT
+        self._orig_errors = list(csc.ERRORS)
+        csc.ERRORS.clear()
+
+    def tearDown(self) -> None:
+        csc.ROOT = self._orig_root
+        csc.ERRORS.clear()
+        csc.ERRORS.extend(self._orig_errors)
+
+    def test_all_four_aligned_passes(self) -> None:
+        """All four SKILL.md with frontmatter matching their table → no errors."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_skill_fixtures(root)
+
+            csc.check_skill_version_blocks()
+
+            self.assertEqual(
+                csc.ERRORS, [], msg=f"unexpected errors on aligned fixtures: {csc.ERRORS!r}"
+            )
+
+    def test_table_date_drift_in_non_reviewer_skill_fails(self) -> None:
+        """The exact #377 root cause: a SKILL whose frontmatter date is bumped but whose table
+        date is left stale must fail — and crucially for a skill OTHER than reviewer (which is
+        the only one the pre-#377 check covered)."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_skill_fixtures(
+                root, overrides={"academic-pipeline": {"tbl_date": "2026-06-01"}}
+            )
+
+            csc.check_skill_version_blocks()
+
+            self.assertTrue(
+                any(
+                    "academic-pipeline/SKILL.md" in e and "2026-06-08" in e and "2026-06-01" in e
+                    for e in csc.ERRORS
+                ),
+                msg=f"expected frontmatter↔table date drift error in: {csc.ERRORS!r}",
+            )
+
+    def test_table_version_drift_fails(self) -> None:
+        """A version (not date) drift between frontmatter and table also fails — for a third
+        skill (deep-research) to prove the check is not reviewer-specific."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_skill_fixtures(
+                root, overrides={"deep-research": {"tbl_ver": "2.9.3"}}
+            )
+
+            csc.check_skill_version_blocks()
+
+            self.assertTrue(
+                any(
+                    "deep-research/SKILL.md" in e and "2.9.4" in e and "2.9.3" in e
+                    for e in csc.ERRORS
+                ),
+                msg=f"expected frontmatter↔table version drift error in: {csc.ERRORS!r}",
+            )
+
+    def test_missing_table_rows_fails(self) -> None:
+        """A SKILL.md that loses its Version-Info table rows must surface rather than silently
+        pass on an empty match."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_skill_fixtures(root)
+            (root / "academic-paper" / "SKILL.md").write_text(
+                '---\nname: academic-paper\nmetadata:\n  version: "3.2.0"\n'
+                '  last_updated: "2026-06-01"\n---\n\nNo version table here.\n',
+                encoding="utf-8",
+            )
+
+            csc.check_skill_version_blocks()
+
+            self.assertTrue(
+                any("academic-paper/SKILL.md" in e and "Version Info" in e for e in csc.ERRORS),
+                msg=f"expected missing-table-rows error in: {csc.ERRORS!r}",
+            )
+
+
+# Minimal CHANGELOG whose latest entry date is the parameter; the suite-date-sanity check
+# compares academic-pipeline/SKILL.md last_updated against this. Two prior entries so the
+# "latest" selection (first `## [X.Y.Z]` after [Unreleased]) is exercised, not just sole-entry.
+CHANGELOG_TEMPLATE = """\
+# Changelog
+
+## [Unreleased]
+
+## [{latest_ver}] - {latest_date} — latest real entry
+
+## [3.11.1] - 2026-06-06 — prior patch
+
+## [3.11.0] - 2026-06-04 — prior minor
+"""
+
+
+def _write_date_sanity_fixtures(
+    root: Path, *, changelog_date: str, pipeline_date: str, changelog_ver: str = "3.12.0"
+) -> None:
+    """Write a CHANGELOG with a known latest-entry date + four SKILL.md where only
+    academic-pipeline's last_updated is the variable under test."""
+    (root / "CHANGELOG.md").write_text(
+        CHANGELOG_TEMPLATE.format(latest_ver=changelog_ver, latest_date=changelog_date),
+        encoding="utf-8",
+    )
+    _write_skill_fixtures(
+        root,
+        overrides={
+            "academic-pipeline": {"fm_date": pipeline_date, "tbl_date": pipeline_date}
+        },
+    )
+
+
+class TestSuiteSkillDateSanity(unittest.TestCase):
+    """#377(b): academic-pipeline/SKILL.md last_updated must be >= the latest CHANGELOG entry
+    date. The other three SKILL.md version independently and are NOT date-policed here."""
+
+    def setUp(self) -> None:
+        self._orig_root = csc.ROOT
+        self._orig_errors = list(csc.ERRORS)
+        csc.ERRORS.clear()
+
+    def tearDown(self) -> None:
+        csc.ROOT = self._orig_root
+        csc.ERRORS.clear()
+        csc.ERRORS.extend(self._orig_errors)
+
+    def test_pipeline_date_equal_to_changelog_passes(self) -> None:
+        """last_updated == latest CHANGELOG date → fine (the normal aligned-release case)."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_date_sanity_fixtures(
+                root, changelog_date="2026-06-08", pipeline_date="2026-06-08"
+            )
+
+            csc.check_suite_skill_date_sanity()
+
+            self.assertEqual(
+                csc.ERRORS, [], msg=f"unexpected errors on aligned date: {csc.ERRORS!r}"
+            )
+
+    def test_pipeline_date_after_changelog_passes(self) -> None:
+        """last_updated strictly AFTER the latest CHANGELOG date is allowed — a post-release
+        doc touch legitimately advances the date past the release entry."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_date_sanity_fixtures(
+                root, changelog_date="2026-06-08", pipeline_date="2026-06-10"
+            )
+
+            csc.check_suite_skill_date_sanity()
+
+            self.assertEqual(
+                csc.ERRORS, [], msg=f"a later last_updated must pass, got: {csc.ERRORS!r}"
+            )
+
+    def test_pipeline_date_before_changelog_fails(self) -> None:
+        """The exact v3.12.0 drift: suite version bumped, last_updated left at the prior release
+        date (earlier than the latest CHANGELOG entry) → must fail."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_date_sanity_fixtures(
+                root, changelog_date="2026-06-08", pipeline_date="2026-06-01"
+            )
+
+            csc.check_suite_skill_date_sanity()
+
+            self.assertTrue(
+                any(
+                    "academic-pipeline/SKILL.md" in e
+                    and "2026-06-01" in e
+                    and "2026-06-08" in e
+                    for e in csc.ERRORS
+                ),
+                msg=f"expected stale-suite-date error in: {csc.ERRORS!r}",
+            )
+
+    def test_date_check_is_bound_to_suite_path_only(self) -> None:
+        """Out-of-scope guard (#377): the date check polices ONLY `_SUITE_SKILL_PATH`. To prove
+        this is genuine scoping and not a vacuous pass, the test demonstrates that the SAME early
+        date is ignored when carried by an independent skill but flagged when carried by whatever
+        path `_SUITE_SKILL_PATH` names — i.e. repointing the constant repoints the policing.
+
+        Fixture: pipeline date is current (2026-06-08, == CHANGELOG); academic-paper carries an
+        early date (2026-06-01 < CHANGELOG). With the real constant the early academic-paper date
+        is NOT flagged; after repointing the constant AT academic-paper, that exact same early
+        date IS flagged. If the check ever fanned out across all four skills, the first assertion
+        would already fail."""
+        orig_suite_path = csc._SUITE_SKILL_PATH
+        try:
+            with TemporaryDirectory() as tmp:
+                root = Path(tmp)
+                csc.ROOT = root
+                _write_date_sanity_fixtures(
+                    root, changelog_date="2026-06-08", pipeline_date="2026-06-08"
+                )
+                # academic-paper keeps its default early date (2026-06-01) from _write_skill_fixtures.
+
+                # Real constant → only pipeline policed; academic-paper's early date is ignored.
+                csc.check_suite_skill_date_sanity()
+                self.assertEqual(
+                    csc.ERRORS, [],
+                    msg=f"independent-skill early date must not be policed, got: {csc.ERRORS!r}",
+                )
+
+                # Repoint the constant at academic-paper → its early date is now the policed one.
+                csc.ERRORS.clear()
+                csc._SUITE_SKILL_PATH = "academic-paper/SKILL.md"
+                csc.check_suite_skill_date_sanity()
+                self.assertTrue(
+                    any(
+                        "academic-paper/SKILL.md" in e and "2026-06-01" in e and "2026-06-08" in e
+                        for e in csc.ERRORS
+                    ),
+                    msg=f"repointed suite path must police academic-paper's early date: {csc.ERRORS!r}",
+                )
+        finally:
+            csc._SUITE_SKILL_PATH = orig_suite_path
+
+    def test_malformed_suite_skill_does_not_double_report(self) -> None:
+        """When the suite SKILL.md is unparseable, check_skill_version_blocks() already records the
+        error; check_suite_skill_date_sanity() must NOT re-report the same root cause from its own
+        re-parse. Drives both checks in order (as main() does) and asserts a single pipeline error."""
+        with TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            csc.ROOT = root
+            _write_date_sanity_fixtures(
+                root, changelog_date="2026-06-08", pipeline_date="2026-06-08"
+            )
+            # Strip the suite SKILL's Version-Info table rows so it fails to parse.
+            pipeline_skill = root / "academic-pipeline" / "SKILL.md"
+            text = pipeline_skill.read_text(encoding="utf-8")
+            pipeline_skill.write_text(
+                text.replace("| Skill Version | 3.12.0 |", "").replace(
+                    "| Last Updated | 2026-06-08 |", ""
+                ),
+                encoding="utf-8",
+            )
+
+            csc.check_skill_version_blocks()
+            csc.check_suite_skill_date_sanity()
+
+            pipeline_errors = [e for e in csc.ERRORS if "academic-pipeline/SKILL.md" in e]
+            self.assertEqual(
+                len(pipeline_errors), 1,
+                msg=f"expected exactly one pipeline error, got {len(pipeline_errors)}: {pipeline_errors!r}",
+            )
+
+
+class RebuttalAuditGuardTest(unittest.TestCase):
+    """check_rebuttal_audit_guard() must enforce the integrity-boundary language
+    in the academic-paper Rebuttal-Audit Mode section. Mutation tests prove the
+    guard actually fails when the suppression language is dropped — otherwise the
+    check would be a vacuous pass that lets the false-certification risk back in."""
+
+    _GOOD = (
+        "## Rebuttal-Audit Mode\n\n"
+        "Advisory QA of an existing rebuttal draft.\n\n"
+        "**IRON RULE:** standalone, so it MUST NOT emit a Schema 11 ledger, "
+        "MUST NOT write the Material Passport, and MUST NOT mark ready_to_submit.\n\n"
+        "## Next Section\n"
+    )
+
+    def _run_guard_with(self, skill_text: str) -> list:
+        orig_read = csc.read
+        csc.ERRORS.clear()
+        try:
+            csc.read = lambda rel: skill_text if rel == "academic-paper/SKILL.md" else orig_read(rel)
+            csc.check_rebuttal_audit_guard()
+            return list(csc.ERRORS)
+        finally:
+            csc.read = orig_read
+            csc.ERRORS.clear()
+
+    def test_guard_passes_with_full_suppression_language(self) -> None:
+        self.assertEqual(self._run_guard_with(self._GOOD), [])
+
+    def test_guard_fails_when_section_missing(self) -> None:
+        errs = self._run_guard_with("## Some Other Mode\n\nno rebuttal section here\n")
+        self.assertTrue(any("missing" in e and "Rebuttal-Audit" in e for e in errs), errs)
+
+    def test_guard_fails_when_schema11_suppression_dropped(self) -> None:
+        mutated = self._GOOD.replace("Schema 11", "the tracker")
+        errs = self._run_guard_with(mutated)
+        self.assertTrue(any("Schema 11" in e for e in errs), errs)
+
+    def test_guard_fails_when_must_not_dropped(self) -> None:
+        mutated = self._GOOD.replace("MUST NOT", "should avoid")
+        errs = self._run_guard_with(mutated)
+        self.assertTrue(any("MUST NOT" in e for e in errs), errs)
+
+
+if __name__ == "__main__":
+    unittest.main()