@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/collectors/test_registry_parser.py

@@ -1,3514 +0,0 @@
-from __future__ import annotations
-
-import inspect
-import json
-from collections import Counter
-from unittest.mock import AsyncMock
-
-import pytest
-from vds_audit_orchestrator.collectors.registry_parser import RegistryPageParser
-from vds_audit_orchestrator.errors import DataSourceError
-from vds_audit_orchestrator.models.registry import (
-    DocumentRole,
-    LinkSource,
-    RootChildType,
-    SkippedNodeReason,
-)
-
-
-@pytest.fixture
-def mock_client():
-    return AsyncMock()
-
-
-@pytest.fixture
-def parser(mock_client):
-    return RegistryPageParser(mock_client)
-
-
-@pytest.fixture
-def parser_checklist_first(mock_client):
-    """Parser configured with checklist-first mode."""
-    return RegistryPageParser(mock_client)
-
-
-@pytest.fixture
-def sample_project_page_html():
-    return """
-    <table>
-        <tr>
-            <th>Vai trò</th>
-            <th>Loại tài liệu</th>
-            <th>Doc Type EN</th>
-            <th>Link</th>
-        </tr>
-        <tr>
-            <td>PO</td>
-            <td>1. Tài liệu BRD</td>
-            <td>BRD Document</td>
-            <td><a href="/display/TDOV/BRD+Doc">Link</a></td>
-        </tr>
-        <tr>
-            <td>DEV</td>
-            <td>8. Source code</td>
-            <td>Source Code</td>
-            <td><a href="http://bitbucket.digital.vn/projects/PAR">Repo</a></td>
-        </tr>
-    </table>
-    """
-
-
-def test_extract_links_from_html(parser, sample_project_page_html):
-    # Mock base URL
-    base_url = "http://10.254.136.35:8090"
-
-    links = parser._extract_links_from_html(sample_project_page_html, base_url)
-
-    assert len(links) == 2
-
-    # Check BRD link
-    brd = next(link for link in links if "BRD" in link.url)
-    assert brd.source == LinkSource.CONFLUENCE
-    assert brd.url == "http://10.254.136.35:8090/display/TDOV/BRD+Doc"
-    assert brd.role == DocumentRole.PO
-    assert brd.doc_number == 1
-    assert brd.doc_type == "Tài liệu BRD"
-    assert brd.doc_type_en == "BRD Document"
-    assert brd.page_id is None
-
-    # Check Repo link
-    repo = next(link for link in links if "bitbucket" in link.url)
-    assert repo.source == LinkSource.BITBUCKET
-    assert repo.url == "http://bitbucket.digital.vn/projects/PAR"
-    assert repo.role == DocumentRole.DEV
-    assert repo.doc_number == 8
-    assert repo.doc_type == "Source code"
-    assert repo.doc_type_en == "Source Code"
-    assert repo.page_id is None
-
-
-def test_confluence_client_for_url_selects_server_scoped_client(mock_client, monkeypatch):
-    # When the active client is "internal" and the URL points to an external host
-    # (10.254.136.35 or 10.254.136.32 — both map to "external"), a scoped external
-    # client should be created and returned.
-    parser = RegistryPageParser(mock_client)
-    mock_client._server = "internal"
-    scoped_client = AsyncMock()
-    calls: dict[str, object] = {}
-
-    from vds_audit_orchestrator.clients.confluence_cli_client import ConfluenceCliClient
-
-    def _fake_for_registry_discovery(cls, project_path=None, *, server=None, timeout=120):
-        calls["server"] = server
-        calls["timeout"] = timeout
-        return scoped_client
-
-    monkeypatch.setattr(
-        ConfluenceCliClient,
-        "for_registry_discovery",
-        classmethod(_fake_for_registry_discovery),
-    )
-
-    selected = parser._confluence_client_for_url("http://10.254.136.35:8090/display/TMP/2.1.+PYC")
-
-    assert selected is scoped_client
-    assert calls["server"] == "external"
-    assert int(calls["timeout"]) == parser._server_scoped_timeout
-
-
-def test_confluence_client_for_url_returns_existing_when_server_matches(mock_client):
-    # When the active client already matches the server inferred from the URL,
-    # no scoped client is created — the existing client is returned as-is.
-    parser = RegistryPageParser(mock_client)
-    mock_client._server = "external"
-
-    selected = parser._confluence_client_for_url("http://10.254.136.35:8090/display/TMP/2.1.+PYC")
-    assert selected is mock_client
-
-    selected = parser._confluence_client_for_url("http://10.254.136.32:8090/display/TMP/2.1.+PYC")
-    assert selected is mock_client
-
-
-@pytest.mark.asyncio
-async def test_parse_project_page(parser, mock_client, sample_project_page_html):
-    page_id = "12345"
-    mock_client.get_page.return_value = {
-        "id": page_id,
-        "title": "Test Project",
-        "body": {"storage": {"value": sample_project_page_html}},
-        "_links": {"base": "http://10.254.136.35:8090", "webui": "/pages/viewpage.action?pageId=12345"},
-    }
-
-    result = await parser.parse_project_page(page_id, "Test Project")
-
-    assert result is not None
-    assert result.project_name == "Test Project"
-    assert len(result.documents) == 2
-    assert len(result.confluence_links) == 1
-    assert len(result.bitbucket_links) == 1
-
-
-@pytest.mark.asyncio
-async def test_parse_project_page_resolves_display_link_to_page_id(parser, mock_client, sample_project_page_html):
-    page_id = "12345"
-    mock_client.get_page.return_value = {
-        "id": page_id,
-        "title": "Test Project",
-        "body": {"storage": {"value": sample_project_page_html}},
-        "_links": {"base": "http://10.254.136.35:8090", "webui": "/pages/viewpage.action?pageId=12345"},
-    }
-    mock_client.search_cql.return_value = [{"id": "33916401"}]
-
-    result = await parser.parse_project_page(page_id, "Test Project")
-
-    assert result is not None
-    brd = next(link for link in result.documents if "/display/" in link.url)
-    assert brd.page_id == "33916401"
-    assert mock_client.search_cql.await_count == 1
-    assert any('space="TDOV"' in str(call.args[0]) for call in mock_client.search_cql.await_args_list)
-
-
-@pytest.mark.asyncio
-async def test_parse_project_page_reuses_display_link_resolution_cache(parser, mock_client):
-    html = """
-    <table>
-        <tr>
-            <th>Vai trò</th>
-            <th>Loại tài liệu</th>
-            <th>Link</th>
-        </tr>
-        <tr>
-            <td>BA</td>
-            <td>2. Tổng quan Nghiệp vụ</td>
-            <td><a href="/display/TMP/2.1.+PYC">Doc</a></td>
-        </tr>
-    </table>
-    """
-    mock_client.get_page.side_effect = [
-        {
-            "id": "11111",
-            "title": "Project A",
-            "body": {"storage": {"value": html}},
-            "_links": {"base": "http://10.254.136.35:8090", "webui": "/pages/viewpage.action?pageId=11111"},
-        },
-        {
-            "id": "22222",
-            "title": "Project B",
-            "body": {"storage": {"value": html}},
-            "_links": {"base": "http://10.254.136.35:8090", "webui": "/pages/viewpage.action?pageId=22222"},
-        },
-    ]
-    mock_client.search_cql.return_value = [{"id": "33916401"}]
-
-    first = await parser.parse_project_page("11111", "Project A")
-    second = await parser.parse_project_page("22222", "Project B")
-
-    assert first is not None
-    assert second is not None
-    assert first.documents[0].page_id == "33916401"
-    assert second.documents[0].page_id == "33916401"
-    assert mock_client.search_cql.await_count == 1
-
-
-@pytest.mark.asyncio
-async def test_parse_project_page_display_page_id_resolution_fails_fast_on_cql_error(parser, mock_client):
-    html = """
-    <table>
-        <tr>
-            <th>Vai trò</th>
-            <th>Loại tài liệu</th>
-            <th>Link</th>
-        </tr>
-        <tr>
-            <td>BA</td>
-            <td>2. Tổng quan Nghiệp vụ</td>
-            <td><a href="/display/TMP/2.1.+PYC">Doc</a></td>
-        </tr>
-    </table>
-    """
-    mock_client.get_page.return_value = {
-        "id": "11111",
-        "title": "Project A",
-        "body": {"storage": {"value": html}},
-        "_links": {"base": "http://10.254.136.35:8090", "webui": "/pages/viewpage.action?pageId=11111"},
-    }
-    mock_client.search_cql.side_effect = DataSourceError(
-        "API error during cql_search: java.lang.IllegalArgumentException: parameters should not be empty"
-    )
-
-    result = await parser.parse_project_page("11111", "Project A")
-
-    assert result is not None
-    assert result.documents[0].page_id is None
-    assert mock_client.search_cql.await_count == 1
-
-
-@pytest.mark.asyncio
-async def test_parse_project_page_uses_prefetched_child_payload(parser, mock_client, sample_project_page_html):
-    page_id = "12345"
-    payload = {
-        "id": page_id,
-        "title": "Prefetched Project",
-        "body": {"storage": {"value": sample_project_page_html}},
-        "_links": {
-            "self": "http://confluence.digital.vn/rest/api/content/12345",
-            "webui": "/pages/viewpage.action?pageId=12345",
-        },
-    }
-
-    result = await parser.parse_project_page(page_id, "Ignored title", page_payload=payload)
-
-    assert result is not None
-    assert result.project_name == "Prefetched Project"
-    assert result.page_url == "http://confluence.digital.vn/pages/viewpage.action?pageId=12345"
-    assert len(result.documents) == 2
-    mock_client.get_page.assert_not_called()
-
-
-@pytest.mark.asyncio
-async def test_parse_project_page_prefetch_mode_skips_display_page_id_resolution(mock_client, tmp_path):
-    parser = RegistryPageParser(mock_client, prefetch_dir=tmp_path)
-    page_id = "12345"
-    payload = {
-        "id": page_id,
-        "title": "Prefetched Project",
-        "body": {
-            "storage": {
-                "value": "<table><tr><th>Link</th></tr><tr><td><a href='/display/TDOV/BRD+Doc'>Doc</a></td></tr></table>"
-            }
-        },
-        "_links": {
-            "self": "http://confluence.digital.vn/rest/api/content/12345",
-            "webui": "/pages/viewpage.action?pageId=12345",
-        },
-    }
-
-    result = await parser.parse_project_page(page_id, "Ignored title", page_payload=payload)
-
-    assert result is not None
-    assert result.documents[0].page_id is None
-    mock_client.search_cql.assert_not_called()
-
-
-@pytest.mark.asyncio
-async def test_parse_project_page_extracts_plain_text_bitbucket_links(parser, mock_client):
-    page_id = "99999"
-    html = """
-    <table>
-        <tr>
-            <th>Vai trò</th>
-            <th>Loại tài liệu</th>
-            <th>Link tài liệu</th>
-        </tr>
-        <tr>
-            <td>DEV</td>
-            <td>8. Source code</td>
-            <td>
-                <span class="nolink">http://bitbucket.digital.vn/projects/WEBAPPV2/repos/miniapp-core/browse</span>
-                http://bitbucket.digital.vn/projects/WEBAPPV2/repos/miniapp-lib/browse
-            </td>
-        </tr>
-    </table>
-    """
-    mock_client.get_page.return_value = {
-        "id": page_id,
-        "title": "Mini App",
-        "body": {"storage": {"value": html}},
-        "_links": {"base": "http://confluence.digital.vn", "webui": "/pages/viewpage.action?pageId=99999"},
-    }
-
-    result = await parser.parse_project_page(page_id, "Mini App")
-
-    assert result is not None
-    assert len(result.bitbucket_links) == 2
-    assert "http://bitbucket.digital.vn/projects/WEBAPPV2/repos/miniapp-core/browse" in result.bitbucket_links
-    assert "http://bitbucket.digital.vn/projects/WEBAPPV2/repos/miniapp-lib/browse" in result.bitbucket_links
-
-
-# Phase 24: Tests for checklist seed discovery (TSK-240)
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_discovers_checklist_page(parser, mock_client):
-    """Registry parser should discover and populate checklist seed metadata."""
-    root_id = "88716667"
-
-    # Mock child pages including a checklist page
-    mock_client.get_child_pages.return_value = [
-        {
-            "id": "88716673",
-            "title": "3.1 Checklist đánh giá chất lượng",
-            "_links": {
-                "base": "http://confluence.digital.vn",
-                "webui": "/pages/viewpage.action?pageId=88716673",
-            },
-        },
-        {
-            "id": "88716675",
-            "title": "3.2 Các hệ thống, nền tảng sản phẩm",
-            "_links": {
-                "base": "http://confluence.digital.vn",
-                "webui": "/pages/viewpage.action?pageId=88716675",
-            },
-        },
-    ]
-
-    registry = await parser.parse_registry(root_id)
-
-    assert registry.checklist_page_id == "88716673"
-    assert registry.checklist_title == "3.1 Checklist đánh giá chất lượng"
-    assert registry.checklist_page_url == "http://confluence.digital.vn/pages/viewpage.action?pageId=88716673"
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_without_checklist_page(parser, mock_client):
-    """Registry parser should handle missing checklist page gracefully."""
-    root_id = "88716667"
-
-    # Mock child pages without a checklist page
-    mock_client.get_child_pages.return_value = [
-        {
-            "id": "88716675",
-            "title": "3.2 Các hệ thống, nền tảng sản phẩm",
-            "_links": {
-                "base": "http://confluence.digital.vn",
-                "webui": "/pages/viewpage.action?pageId=88716675",
-            },
-        },
-    ]
-
-    registry = await parser.parse_registry(root_id)
-
-    assert registry.checklist_page_id is None
-    assert registry.checklist_title is None
-    assert registry.checklist_page_url is None
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_checklist_fallback_detection(parser, mock_client):
-    """Registry parser should detect checklist via fallback when no 3.1 prefix."""
-    root_id = "88716667"
-
-    # Mock child pages with checklist in title but no 3.1 prefix
-    mock_client.get_child_pages.return_value = [
-        {
-            "id": "99999",
-            "title": "Audit Checklist Template",
-            "_links": {
-                "base": "http://confluence.digital.vn",
-                "webui": "/pages/viewpage.action?pageId=99999",
-            },
-        },
-        {
-            "id": "88716675",
-            "title": "3.2 Các hệ thống, nền tảng sản phẩm",
-            "_links": {
-                "base": "http://confluence.digital.vn",
-                "webui": "/pages/viewpage.action?pageId=88716675",
-            },
-        },
-    ]
-
-    registry = await parser.parse_registry(root_id)
-
-    assert registry.checklist_page_id == "99999"
-    assert registry.checklist_title == "Audit Checklist Template"
-
-
-@pytest.mark.asyncio
-async def test_find_projects_root_and_checklist_deterministic_returns_both(parser, mock_client):
-    """Deterministic root-child discovery should return projects root and checklist info."""
-    root_id = "88716667"
-
-    mock_client.get_child_pages.return_value = [
-        {
-            "id": "88716673",
-            "title": "3.1 Checklist đánh giá",
-            "_links": {
-                "self": "http://confluence.digital.vn/rest/api/content/88716673",
-                "webui": "/pages/viewpage.action?pageId=88716673",
-            },
-        },
-        {
-            "id": "88716675",
-            "title": "3.2 Các hệ thống",
-            "_links": {
-                "self": "http://confluence.digital.vn/rest/api/content/88716675",
-                "webui": "/pages/viewpage.action?pageId=88716675",
-            },
-        },
-    ]
-
-    projects_root_id, checklist_candidates = await parser._find_projects_root_and_checklist_deterministic(root_id)
-
-    assert projects_root_id == "88716675"
-    assert checklist_candidates
-    assert checklist_candidates[0]["id"] == "88716673"
-    assert checklist_candidates[0]["title"] == "3.1 Checklist đánh giá"
-
-
-# Phase 24 TSK-241: Deterministic root-child classification tests
-
-
-class TestClassifyRootChild:
-    """Tests for deterministic root-child classification (TSK-241.2.1)."""
-
-    def test_classify_checklist_with_3_1_prefix(self):
-        """3.1 prefix should classify as CHECKLIST."""
-        assert RegistryPageParser.classify_root_child("3.1 Checklist đánh giá") == RootChildType.CHECKLIST
-        assert RegistryPageParser.classify_root_child("3.1 Some other title") == RootChildType.CHECKLIST
-        assert RegistryPageParser.classify_root_child("3.1") == RootChildType.CHECKLIST
-
-    def test_classify_checklist_with_keyword(self):
-        """'checklist' keyword should classify as CHECKLIST."""
-        assert RegistryPageParser.classify_root_child("Audit Checklist Template") == RootChildType.CHECKLIST
-        assert RegistryPageParser.classify_root_child("My Checklist") == RootChildType.CHECKLIST
-        assert RegistryPageParser.classify_root_child("CHECKLIST") == RootChildType.CHECKLIST
-
-    def test_classify_project_container_with_3_2_prefix(self):
-        """3.2 prefix should classify as PROJECT_CONTAINER."""
-        assert RegistryPageParser.classify_root_child("3.2 Các hệ thống") == RootChildType.PROJECT_CONTAINER
-        assert RegistryPageParser.classify_root_child("3.2 Projects") == RootChildType.PROJECT_CONTAINER
-        assert RegistryPageParser.classify_root_child("3.2") == RootChildType.PROJECT_CONTAINER
-
-    def test_classify_project_container_with_vietnamese_keywords(self):
-        """Vietnamese keywords should classify as PROJECT_CONTAINER."""
-        assert RegistryPageParser.classify_root_child("Các hệ thống sản phẩm") == RootChildType.PROJECT_CONTAINER
-        assert RegistryPageParser.classify_root_child("Nền tảng dịch vụ") == RootChildType.PROJECT_CONTAINER
-        assert RegistryPageParser.classify_root_child("Hệ thống và nền tảng") == RootChildType.PROJECT_CONTAINER
-
-    def test_classify_audit_history(self):
-        """'audit history' should classify as AUDIT_HISTORY."""
-        assert RegistryPageParser.classify_root_child("Audit History") == RootChildType.AUDIT_HISTORY
-        assert RegistryPageParser.classify_root_child("audit history") == RootChildType.AUDIT_HISTORY
-        assert RegistryPageParser.classify_root_child("Project Audit History") == RootChildType.AUDIT_HISTORY
-
-    def test_classify_unknown(self):
-        """Unrecognized titles should classify as UNKNOWN."""
-        assert RegistryPageParser.classify_root_child("Random Page") == RootChildType.UNKNOWN
-        assert RegistryPageParser.classify_root_child("Documentation") == RootChildType.UNKNOWN
-        assert RegistryPageParser.classify_root_child("") == RootChildType.UNKNOWN
-        assert RegistryPageParser.classify_root_child("   ") == RootChildType.UNKNOWN
-
-    def test_classify_case_insensitive(self):
-        """Classification should be case-insensitive."""
-        assert RegistryPageParser.classify_root_child("CHECKLIST") == RootChildType.CHECKLIST
-        assert RegistryPageParser.classify_root_child("Checklist") == RootChildType.CHECKLIST
-        assert RegistryPageParser.classify_root_child("AUDIT HISTORY") == RootChildType.AUDIT_HISTORY
-
-
-class TestClassifyChecklistProfileId:
-    """Tests for checklist profile keyword classification (Phase 110)."""
-
-    def test_vietnamese_frontend_keyword_maps_to_frontend(self) -> None:
-        profile_id, match_count = RegistryPageParser._classify_checklist_profile_id("Checklist giao diện người dùng")
-        assert profile_id == "frontend"
-        assert match_count == 1
-
-    def test_english_frontend_keyword_maps_to_frontend(self) -> None:
-        profile_id, match_count = RegistryPageParser._classify_checklist_profile_id("Frontend Architecture Checklist")
-        assert profile_id == "frontend"
-        assert match_count == 1
-
-    def test_space_separated_front_end_keyword_maps_to_frontend(self) -> None:
-        """Regression: actual Confluence title uses 'Front end' (space-separated)."""
-        profile_id, match_count = RegistryPageParser._classify_checklist_profile_id(
-            "3.2. Checklist đóng gói hệ thống - Front end"
-        )
-        assert profile_id == "frontend"
-        assert match_count == 1
-
-    def test_vietnamese_backend_keyword_maps_to_backend(self) -> None:
-        profile_id, match_count = RegistryPageParser._classify_checklist_profile_id("Checklist phía sau hệ thống")
-        assert profile_id == "backend"
-        assert match_count == 1
-
-    def test_ambiguous_profile_keywords_fall_back_to_default(self) -> None:
-        profile_id, match_count = RegistryPageParser._classify_checklist_profile_id(
-            "Backend frontend consolidated checklist"
-        )
-        assert profile_id == "default"
-        assert match_count == 2
-
-
-class TestExtractChecklistVersion:
-    """Tests for _extract_checklist_version (Phase 112 version-aware dedup)."""
-
-    def test_version_suffix_extracted(self) -> None:
-        base, ver = RegistryPageParser._extract_checklist_version("3.1 Checklist đánh giá các hệ thống nền tảng v1.1")
-        assert base == "3.1 Checklist đánh giá các hệ thống nền tảng"
-        assert ver == (1, 1)
-
-    def test_no_version_suffix_returns_zero(self) -> None:
-        base, ver = RegistryPageParser._extract_checklist_version("3.1 Checklist đánh giá các hệ thống nền tảng")
-        assert base == "3.1 Checklist đánh giá các hệ thống nền tảng"
-        assert ver == (0,)
-
-    def test_major_only_version(self) -> None:
-        base, ver = RegistryPageParser._extract_checklist_version("Checklist v2")
-        assert base == "Checklist"
-        assert ver == (2,)
-
-    def test_three_part_version(self) -> None:
-        base, ver = RegistryPageParser._extract_checklist_version("Checklist v2.3.1")
-        assert base == "Checklist"
-        assert ver == (2, 3, 1)
-
-    def test_case_insensitive_v(self) -> None:
-        base, ver = RegistryPageParser._extract_checklist_version("Checklist V1.0")
-        assert base == "Checklist"
-        assert ver == (1, 0)
-
-    def test_empty_title(self) -> None:
-        base, ver = RegistryPageParser._extract_checklist_version("")
-        assert base == ""
-        assert ver == (0,)
-
-    def test_version_ordering(self) -> None:
-        """v1.1 should sort higher than implicit v0 (no suffix)."""
-        _, v0 = RegistryPageParser._extract_checklist_version("Checklist đánh giá")
-        _, v11 = RegistryPageParser._extract_checklist_version("Checklist đánh giá v1.1")
-        assert v11 > v0
-
-
-class TestBuildChecklistProfilesVersionDedup:
-    """Tests for version-aware deduplication in _build_checklist_profiles (Phase 112).
-
-    Regression: the live registry (88716667) contains both legacy 88716673
-    ("3.1 Checklist đánh giá các hệ thống nền tảng") and current 88722450
-    ("3.1 Checklist đánh giá các hệ thống nền tảng v1.1").  Both classify as
-    profile_id=default.  Only 88722450 (v1.1) should survive dedup.
-    """
-
-    def test_legacy_page_superseded_by_versioned_successor(self) -> None:
-        """88716673 (no version) should be superseded by 88722450 (v1.1)."""
-        candidates = [
-            {
-                "id": "88716673",
-                "title": "3.1 Checklist đánh giá các hệ thống nền tảng",
-                "url": "/pages/viewpage.action?pageId=88716673",
-                "profile_id": "default",
-            },
-            {
-                "id": "88722450",
-                "title": "3.1 Checklist đánh giá các hệ thống nền tảng v1.1",
-                "url": "/pages/viewpage.action?pageId=88722450",
-                "profile_id": "default",
-            },
-        ]
-        profiles, diag = RegistryPageParser._build_checklist_profiles(candidates)
-        default_profiles = [p for p in profiles if p.profile_id == "default"]
-        assert len(default_profiles) == 1
-        assert default_profiles[0].page_ids == ["88722450"]
-        assert "88716673" not in default_profiles[0].page_ids
-        assert diag["superseded_count"] == 1
-
-    def test_full_registry_produces_two_profiles(self) -> None:
-        """Simulates the actual 88716667 registry with 3 checklist pages."""
-        candidates = [
-            {
-                "id": "88716673",
-                "title": "3.1 Checklist đánh giá các hệ thống nền tảng",
-                "url": "/pages/viewpage.action?pageId=88716673",
-                "profile_id": "default",
-            },
-            {
-                "id": "88722450",
-                "title": "3.1 Checklist đánh giá các hệ thống nền tảng v1.1",
-                "url": "/pages/viewpage.action?pageId=88722450",
-                "profile_id": "default",
-            },
-            {
-                "id": "88729031",
-                "title": "3.2. Checklist đóng gói hệ thống - Front end",
-                "url": "/pages/viewpage.action?pageId=88729031",
-                "profile_id": "frontend",
-            },
-        ]
-        profiles, diag = RegistryPageParser._build_checklist_profiles(candidates)
-        profile_ids = [p.profile_id for p in profiles]
-        assert "frontend" in profile_ids
-        assert "default" in profile_ids
-        assert len(profiles) == 2
-
-        default_p = next(p for p in profiles if p.profile_id == "default")
-        frontend_p = next(p for p in profiles if p.profile_id == "frontend")
-        # Default profile should contain only v1.1, not legacy
-        assert default_p.page_ids == ["88722450"]
-        assert frontend_p.page_ids == ["88729031"]
-        assert diag["superseded_count"] == 1
-
-    def test_no_dedup_when_titles_differ(self) -> None:
-        """Pages with genuinely different base titles should all be kept."""
-        candidates = [
-            {
-                "id": "100",
-                "title": "Backend Quality Checklist",
-                "url": "/pages/viewpage.action?pageId=100",
-                "profile_id": "default",
-            },
-            {
-                "id": "200",
-                "title": "Security Audit Checklist",
-                "url": "/pages/viewpage.action?pageId=200",
-                "profile_id": "default",
-            },
-        ]
-        profiles, diag = RegistryPageParser._build_checklist_profiles(candidates)
-        default_p = next(p for p in profiles if p.profile_id == "default")
-        assert len(default_p.page_ids) == 2
-        assert "100" in default_p.page_ids
-        assert "200" in default_p.page_ids
-        assert diag["superseded_count"] == 0
-
-    def test_single_candidate_no_dedup(self) -> None:
-        """Single candidate should pass through with no dedup."""
-        candidates = [
-            {
-                "id": "88722450",
-                "title": "3.1 Checklist đánh giá v1.1",
-                "url": "/pages/viewpage.action?pageId=88722450",
-                "profile_id": "default",
-            },
-        ]
-        profiles, diag = RegistryPageParser._build_checklist_profiles(candidates)
-        assert len(profiles) == 1
-        assert profiles[0].page_ids == ["88722450"]
-        assert diag["superseded_count"] == 0
-
-    def test_higher_version_wins(self) -> None:
-        """When v1.1 and v2.0 exist, v2.0 wins."""
-        candidates = [
-            {
-                "id": "AAA",
-                "title": "Checklist đánh giá v1.1",
-                "url": "",
-                "profile_id": "default",
-            },
-            {
-                "id": "BBB",
-                "title": "Checklist đánh giá v2.0",
-                "url": "",
-                "profile_id": "default",
-            },
-        ]
-        profiles, diag = RegistryPageParser._build_checklist_profiles(candidates)
-        default_p = next(p for p in profiles if p.profile_id == "default")
-        assert default_p.page_ids == ["BBB"]
-        assert diag["superseded_count"] == 1
-
-    def test_empty_candidates(self) -> None:
-        profiles, diag = RegistryPageParser._build_checklist_profiles([])
-        assert profiles == []
-        assert diag["superseded_count"] == 0
-
-
-class TestParserConfiguration:
-    """Tests for parser configuration (TSK-241.2.2)."""
-
-    def test_parser_initializes_with_defaults(self, mock_client):
-        parser = RegistryPageParser(mock_client)
-        assert parser.adaptive_depth is True
-        assert parser.adaptive_max_depth == 2
-
-    def test_checklist_page_override(self, mock_client):
-        """Should store checklist page override."""
-        parser = RegistryPageParser(mock_client, checklist_page="12345")
-        assert parser.checklist_page_override == "12345"
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_checklist_first_mode(parser_checklist_first, mock_client):
-    """Checklist-first mode should use deterministic classification."""
-    root_id = "88716667"
-
-    mock_client.get_child_pages.return_value = [
-        {
-            "id": "88716673",
-            "title": "3.1 Checklist đánh giá chất lượng",
-            "_links": {
-                "base": "http://confluence.digital.vn",
-                "webui": "/pages/viewpage.action?pageId=88716673",
-            },
-        },
-        {
-            "id": "88716675",
-            "title": "3.2 Các hệ thống, nền tảng sản phẩm",
-            "_links": {
-                "base": "http://confluence.digital.vn",
-                "webui": "/pages/viewpage.action?pageId=88716675",
-            },
-        },
-    ]
-
-    registry = await parser_checklist_first.parse_registry(root_id)
-    assert registry.checklist_page_id == "88716673"
-    assert registry.checklist_title == "3.1 Checklist đánh giá chất lượng"
-
-
-@pytest.mark.asyncio
-async def test_checklist_first_uses_metadata_only_discovery(mock_client):
-    """Checklist-first should keep root discovery lightweight and expand only candidate level."""
-    parser = RegistryPageParser(
-        mock_client,
-        recursive_depth=1,
-    )
-    root_id = "88716667"
-    expand_calls: list[tuple[str, str | None]] = []
-
-    async def mock_get_child_pages(page_id, expand=None):
-        expand_calls.append((str(page_id), expand))
-        if page_id == root_id:
-            return [
-                {"id": "88716673", "title": "3.1 Checklist đánh giá", "_links": {}},
-                {"id": "88716675", "title": "3.2 Các hệ thống", "_links": {}},
-            ]
-        if page_id == "88716675":
-            return [
-                {
-                    "id": "proj_1",
-                    "title": "Project 1",
-                    "body": {
-                        "storage": {
-                            "value": "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com/doc'>Doc</a></td></tr></table>"
-                        }
-                    },
-                    "_links": {"base": "http://confluence.digital.vn", "webui": "/pages/viewpage.action?pageId=proj_1"},
-                },
-                {"id": "audit", "title": "Audit History", "_links": {}},
-            ]
-        return []
-
-    mock_client.get_child_pages.side_effect = mock_get_child_pages
-    registry = await parser.parse_registry(root_id)
-
-    assert len(registry.projects) == 1
-    assert registry.projects[0].page_id == "proj_1"
-    assert expand_calls == [(root_id, None), ("88716675", "body.storage")]
-    mock_client.get_page.assert_not_called()
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_persists_checklist_mode(parser, mock_client):
-    """Registry output should persist checklist-first mode."""
-    root_id = "88716667"
-
-    mock_client.get_child_pages.return_value = [
-        {
-            "id": "88716675",
-            "title": "3.2 Các hệ thống",
-            "_links": {},
-        },
-    ]
-
-    registry = await parser.parse_registry(root_id)
-    assert registry.mapping_version is not None
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_derives_department_from_ancestry_lineage(mock_client):
-    parser = RegistryPageParser(mock_client, recursive_depth=3)
-    root_id = "88716667"
-    valid_html = """
-    <table>
-        <tr><th>Link</th></tr>
-        <tr><td><a href='http://example.com/doc'>Doc</a></td></tr>
-    </table>
-    """
-
-    async def mock_get_child_pages(page_id, expand=None):
-        if page_id == root_id:
-            return [{"id": "projects_root", "title": "3.2 Các hệ thống", "_links": {}}]
-        if page_id == "projects_root":
-            return [{"id": "dept_a", "title": "Payments Department", "_links": {}}]
-        if page_id == "dept_a":
-            return [
-                {
-                    "id": "proj_1",
-                    "title": "Project 1",
-                    "body": {"storage": {"value": valid_html}},
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=proj_1",
-                    },
-                }
-            ]
-        return []
-
-    mock_client.get_child_pages.side_effect = mock_get_child_pages
-    mock_client.get_page.return_value = None
-
-    registry = await parser.parse_registry(root_id)
-
-    assert len(registry.projects) == 1
-    project = registry.projects[0]
-    assert project.department == "Payments Department"
-    assert project.department_page_id == "dept_a"
-    assert project.department_storage_key == "payments-department"
-    assert project.department_assignment_reason == "derived_from_projects_root_lineage"
-    assert [node.page_id for node in project.confluence_ancestry_path] == ["projects_root", "dept_a", "proj_1"]
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_marks_unassigned_when_department_node_missing(mock_client):
-    parser = RegistryPageParser(mock_client, recursive_depth=2)
-    root_id = "88716667"
-    valid_html = """
-    <table>
-        <tr><th>Link</th></tr>
-        <tr><td><a href='http://example.com/doc'>Doc</a></td></tr>
-    </table>
-    """
-
-    async def mock_get_child_pages(page_id, expand=None):
-        if page_id == root_id:
-            return [{"id": "projects_root", "title": "3.2 Các hệ thống", "_links": {}}]
-        if page_id == "projects_root":
-            return [
-                {
-                    "id": "proj_1",
-                    "title": "Project 1",
-                    "body": {"storage": {"value": valid_html}},
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=proj_1",
-                    },
-                }
-            ]
-        return []
-
-    async def mock_get_page(page_id, expand=None):
-        if page_id == "projects_root":
-            return {"id": "projects_root", "title": "3.2 Các hệ thống", "_links": {}}
-        return None
-
-    mock_client.get_child_pages.side_effect = mock_get_child_pages
-    mock_client.get_page.side_effect = mock_get_page
-
-    registry = await parser.parse_registry(root_id)
-
-    assert len(registry.projects) == 1
-    project = registry.projects[0]
-    assert project.department == "3.2 Các hệ thống"
-    assert project.department_page_id == "projects_root"
-    assert project.department_storage_key == "3-2-cac-he-thong"
-    assert project.department_assignment_reason == "derived_from_projects_root_anchor"
-    assert [node.page_id for node in project.confluence_ancestry_path] == ["projects_root", "proj_1"]
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_derives_department_from_registry_root_anchor_when_root_is_project_container(mock_client):
-    parser = RegistryPageParser(mock_client, recursive_depth=2)
-    root_id = "88716694"
-    valid_html = """
-    <table>
-        <tr><th>Link</th></tr>
-        <tr><td><a href='http://bitbucket.digital.vn/projects/PAY'>Repo</a></td></tr>
-    </table>
-    """
-
-    async def mock_get_child_pages(page_id, expand=None):
-        if page_id == root_id:
-            return [
-                {
-                    "id": "proj_1",
-                    "title": "Core Payment",
-                    "body": {"storage": {"value": valid_html}},
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=proj_1",
-                    },
-                }
-            ]
-        return []
-
-    async def mock_get_page(page_id, expand=None):
-        if page_id == root_id:
-            return {
-                "id": root_id,
-                "title": "3.2.4 Nền tảng thanh toán",
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": f"/pages/viewpage.action?pageId={root_id}",
-                },
-            }
-        return None
-
-    mock_client.get_child_pages.side_effect = mock_get_child_pages
-    mock_client.get_page.side_effect = mock_get_page
-
-    registry = await parser.parse_registry(root_id)
-
-    assert len(registry.projects) == 1
-    project = registry.projects[0]
-    assert project.department == "3.2.4 Nền tảng thanh toán"
-    assert project.department_page_id == "88716694"
-    assert project.root_page_id == "88716694"
-    assert project.root_title == "3.2.4 Nền tảng thanh toán"
-    assert project.root_assignment_reason == "derived_from_registry_root_lineage_head"
-    assert project.department_storage_key == "3-2-4-nen-tang-thanh-toan"
-    assert project.department_assignment_reason == "derived_from_registry_root_anchor"
-    assert [node.page_id for node in project.confluence_ancestry_path] == ["88716694", "proj_1"]
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_atomic_project_entry_collects_repository_child_pages(mock_client, monkeypatch):
-    parser = RegistryPageParser(mock_client, recursive_depth=1)
-    root_id = "88727304"
-    monkeypatch.setattr(RegistryPageParser, "_local_repo_path_for_slug", staticmethod(lambda **_kwargs: None))
-
-    async def mock_get_page(page_id, expand=None):
-        if page_id == root_id:
-            return {
-                "id": root_id,
-                "title": "PAR",
-                "ancestors": [
-                    {
-                        "id": "88716667",
-                        "title": "Khối CNTT",
-                        "_links": {"webui": "/pages/viewpage.action?pageId=88716667"},
-                    },
-                    {
-                        "id": "88716694",
-                        "title": "3.2.4 Nền tảng thanh toán",
-                        "_links": {"webui": "/pages/viewpage.action?pageId=88716694"},
-                    },
-                ],
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": f"/pages/viewpage.action?pageId={root_id}",
-                },
-            }
-        return None
-
-    async def mock_get_child_pages(page_id, expand=None):
-        if page_id == root_id:
-            return [
-                {
-                    "id": "91337278",
-                    "title": "Repository - par-merchant-report",
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=91337278",
-                    },
-                },
-                {
-                    "id": "91337281",
-                    "title": "Repository - par-merchant-transaction",
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=91337281",
-                    },
-                },
-            ]
-        return []
-
-    mock_client.get_page.side_effect = mock_get_page
-    mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-    registry = await parser.parse_registry(root_id)
-
-    assert len(registry.projects) == 1
-    project = registry.projects[0]
-    assert project.page_id == root_id
-    assert project.department_page_id == "88716694"
-    assert project.root_page_id == "88716667"
-    assert [child.page_id for child in project.child_pages] == ["91337278", "91337281"]
-    assert project.bitbucket_projects == [
-        {
-            "bitbucket_project_key": "PAR",
-            "display_name": "PAR",
-            "source": "registry_child_repository_pages",
-            "repos": [
-                {
-                    "default_branch": "main",
-                    "fetch_reason": "registry_child_repository_page",
-                    "local_code_path": None,
-                    "path": "http://confluence.digital.vn/pages/viewpage.action?pageId=91337278",
-                    "repo_slug": "merchant-report",
-                    "repo_storage_key": "par:merchant-report",
-                    "repo_url": None,
-                    "source_page_id": "91337278",
-                    "source_title": "Repository - par-merchant-report",
-                    "status": "discovered",
-                },
-                {
-                    "default_branch": "main",
-                    "fetch_reason": "registry_child_repository_page",
-                    "local_code_path": None,
-                    "path": "http://confluence.digital.vn/pages/viewpage.action?pageId=91337281",
-                    "repo_slug": "merchant-transaction",
-                    "repo_storage_key": "par:merchant-transaction",
-                    "repo_url": None,
-                    "source_page_id": "91337281",
-                    "source_title": "Repository - par-merchant-transaction",
-                    "status": "discovered",
-                },
-            ],
-        }
-    ]
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_prefers_nearest_department_container_under_top_level_root(mock_client):
-    parser = RegistryPageParser(mock_client, recursive_depth=3)
-    root_id = "88716667"
-    valid_html = """
-    <table>
-        <tr><th>Link</th></tr>
-        <tr><td><a href='http://bitbucket.digital.vn/projects/PAY'>Repo</a></td></tr>
-    </table>
-    """
-
-    async def mock_get_page(page_id, expand=None):
-        if page_id == root_id:
-            return {
-                "id": root_id,
-                "title": "3.2 Các hệ thống, nền tảng sản phẩm",
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": f"/pages/viewpage.action?pageId={root_id}",
-                },
-            }
-        if page_id == "88716677":
-            return {
-                "id": "88716677",
-                "title": "3.2.1 Sản phẩm quản trị",
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": "/pages/viewpage.action?pageId=88716677",
-                },
-            }
-        return None
-
-    async def mock_get_child_pages(page_id, expand=None):
-        if page_id == root_id:
-            return [{"id": "88716675", "title": "3.2 Các hệ thống", "_links": {}}]
-        if page_id == "88716675":
-            return [{"id": "88716694", "title": "3.2.4 Nền tảng thanh toán", "_links": {}}]
-        if page_id == "88716694":
-            return [
-                {
-                    "id": "88718977",
-                    "title": "Auto Payment",
-                    "body": {"storage": {"value": valid_html}},
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=88718977",
-                    },
-                }
-            ]
-        return []
-
-    mock_client.get_page.side_effect = mock_get_page
-    mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-    registry = await parser.parse_registry(root_id)
-
-    assert len(registry.projects) == 1
-    project = registry.projects[0]
-    assert project.department == "3.2.4 Nền tảng thanh toán"
-    assert project.department_page_id == "88716694"
-    assert project.root_page_id == root_id
-    assert project.root_title == "3.2 Các hệ thống, nền tảng sản phẩm"
-    assert project.root_assignment_reason == "derived_from_registry_root_lineage_head"
-    assert project.department_storage_key == "3-2-4-nen-tang-thanh-toan"
-    assert project.department_assignment_reason == "derived_from_projects_root_lineage"
-    assert [node.page_id for node in project.confluence_ancestry_path] == [root_id, "88716675", "88716694", "88718977"]
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_skips_container_page_as_atomic_project_leaf(mock_client):
-    parser = RegistryPageParser(mock_client, recursive_depth=1)
-    root_id = "88716675"
-    valid_html = """
-    <table>
-        <tr><th>Link</th></tr>
-        <tr><td><a href='http://bitbucket.digital.vn/projects/PAR'>Repo</a></td></tr>
-    </table>
-    """
-
-    async def mock_get_page(page_id, expand=None):
-        if page_id == root_id:
-            return {
-                "id": root_id,
-                "title": "3.2 Các hệ thống, nền tảng sản phẩm",
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": f"/pages/viewpage.action?pageId={root_id}",
-                },
-            }
-        return None
-
-    async def mock_get_child_pages(page_id, expand=None):
-        if page_id == root_id:
-            return [{"id": "88716677", "title": "3.2.1 Sản phẩm quản trị", "_links": {}}]
-        if page_id == "88716677":
-            return [
-                {
-                    "id": "88727304",
-                    "title": "PAR",
-                    "body": {"storage": {"value": valid_html}},
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=88727304",
-                    },
-                }
-            ]
-        return []
-
-    mock_client.get_page.side_effect = mock_get_page
-    mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-    registry = await parser.parse_registry(root_id)
-
-    assert [project.page_id for project in registry.projects] == ["88727304"]
-    project = registry.projects[0]
-    assert project.root_page_id == root_id
-    assert project.page_id != "88716677"
-    assert any(node.reason == SkippedNodeReason.PROJECT_CONTAINER for node in registry.skipped_nodes)
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_project_container_filter_uses_candidate_page_lineage(mock_client):
-    parser = RegistryPageParser(mock_client, recursive_depth=2)
-    root_id = "88716675"
-    valid_html = """
-    <table>
-        <tr><th>Link</th></tr>
-        <tr><td><a href='http://bitbucket.digital.vn/projects/PAR'>Repo</a></td></tr>
-    </table>
-    """
-
-    async def mock_get_page(page_id, expand=None):
-        payloads = {
-            root_id: {
-                "id": root_id,
-                "title": "3.2 Các hệ thống",
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": f"/pages/viewpage.action?pageId={root_id}",
-                },
-            },
-            "88716677": {
-                "id": "88716677",
-                "title": "3.2.1 Sản phẩm quản trị",
-                "parentId": root_id,
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": "/pages/viewpage.action?pageId=88716677",
-                },
-            },
-            "88716679": {
-                "id": "88716679",
-                "title": "3.2.2 Nền tảng ứng dụng",
-                "parentId": root_id,
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": "/pages/viewpage.action?pageId=88716679",
-                },
-            },
-            "88727304": {
-                "id": "88727304",
-                "title": "PAR",
-                "parentId": "88716679",
-                "body": {"storage": {"value": valid_html}},
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": "/pages/viewpage.action?pageId=88727304",
-                },
-            },
-        }
-        return payloads.get(page_id)
-
-    async def mock_get_child_pages(page_id, expand=None):
-        if page_id == root_id:
-            return [
-                {"id": "88716677", "title": "3.2.1 Sản phẩm quản trị", "_links": {}},
-                {"id": "88716679", "title": "3.2.2 Nền tảng ứng dụng", "_links": {}},
-            ]
-        if page_id == "88716677":
-            return []
-        if page_id == "88716679":
-            return [
-                {
-                    "id": "88727304",
-                    "title": "PAR",
-                    "body": {"storage": {"value": valid_html}},
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=88727304",
-                    },
-                }
-            ]
-        return []
-
-    mock_client.get_page.side_effect = mock_get_page
-    mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-    registry = await parser.parse_registry(root_id)
-
-    assert [project.page_id for project in registry.projects] == ["88727304"]
-    skipped_container_ids = {
-        node.page_id for node in registry.skipped_nodes if node.reason == SkippedNodeReason.PROJECT_CONTAINER
-    }
-    assert "88716677" in skipped_container_ids
-    assert "88727304" not in skipped_container_ids
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_direct_project_page_reconstructs_department_from_parent_chain(mock_client):
-    parser = RegistryPageParser(mock_client, recursive_depth=2)
-    project_id = "88718977"
-    valid_html = """
-    <table>
-        <tr><th>Link</th></tr>
-        <tr><td><a href='http://bitbucket.digital.vn/projects/PAY'>Repo</a></td></tr>
-    </table>
-    """
-
-    async def mock_get_page(page_id, expand=None):
-        if page_id == project_id:
-            return {
-                "id": project_id,
-                "title": "pay",
-                "parentId": "88716694",
-                "body": {"storage": {"value": valid_html}},
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": f"/pages/viewpage.action?pageId={project_id}",
-                },
-            }
-        if page_id == "88716694":
-            return {
-                "id": "88716694",
-                "title": "3.2.4 Nền tảng thanh toán",
-                "parentId": "88716675",
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": "/pages/viewpage.action?pageId=88716694",
-                },
-            }
-        if page_id == "88716675":
-            return {
-                "id": "88716675",
-                "title": "3.2 Các hệ thống",
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": "/pages/viewpage.action?pageId=88716675",
-                },
-            }
-        return None
-
-    async def mock_get_child_pages(page_id, expand=None):
-        if page_id == project_id:
-            return []
-        return []
-
-    mock_client.get_page.side_effect = mock_get_page
-    mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-    registry = await parser.parse_registry(project_id)
-
-    assert len(registry.projects) == 1
-    project = registry.projects[0]
-    assert project.page_id == project_id
-    assert project.department == "3.2.4 Nền tảng thanh toán"
-    assert project.department_page_id == "88716694"
-    assert project.root_page_id == "88716675"
-    assert project.root_title == "3.2 Các hệ thống"
-    assert project.root_assignment_reason == "derived_from_registry_root_lineage_head"
-    assert project.department_storage_key == "3-2-4-nen-tang-thanh-toan"
-    assert project.department_assignment_reason == "derived_from_candidate_root_anchor"
-    assert [node.page_id for node in project.confluence_ancestry_path] == ["88716675", "88716694", project_id]
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_department_page_reconstructs_parent_root_from_parent_chain(mock_client):
-    parser = RegistryPageParser(mock_client, recursive_depth=2)
-    department_id = "88716694"
-    valid_html = """
-    <table>
-        <tr><th>Link</th></tr>
-        <tr><td><a href='http://bitbucket.digital.vn/projects/PAY'>Repo</a></td></tr>
-    </table>
-    """
-
-    async def mock_get_page(page_id, expand=None):
-        if page_id == department_id:
-            return {
-                "id": department_id,
-                "title": "3.2.4 Nền tảng thanh toán",
-                "parentId": "88716675",
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": f"/pages/viewpage.action?pageId={department_id}",
-                },
-            }
-        if page_id == "88716675":
-            return {
-                "id": "88716675",
-                "title": "3.2 Các hệ thống",
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": "/pages/viewpage.action?pageId=88716675",
-                },
-            }
-        return None
-
-    async def mock_get_child_pages(page_id, expand=None):
-        if page_id == department_id:
-            return [
-                {
-                    "id": "88718977",
-                    "title": "Auto Payment",
-                    "body": {"storage": {"value": valid_html}},
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=88718977",
-                    },
-                }
-            ]
-        return []
-
-    mock_client.get_page.side_effect = mock_get_page
-    mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-    registry = await parser.parse_registry(department_id)
-
-    assert len(registry.projects) == 1
-    project = registry.projects[0]
-    assert project.page_id == "88718977"
-    assert project.department == "3.2.4 Nền tảng thanh toán"
-    assert project.department_page_id == department_id
-    assert project.root_page_id == "88716675"
-    assert project.root_title == "3.2 Các hệ thống"
-    assert project.root_assignment_reason == "derived_from_registry_root_lineage_head"
-    assert [node.page_id for node in project.confluence_ancestry_path] == ["88716675", department_id, "88718977"]
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_department_page_reconstructs_parent_root_from_ancestors_expand(mock_client):
-    parser = RegistryPageParser(mock_client, recursive_depth=2)
-    department_id = "88716694"
-    valid_html = """
-    <table>
-        <tr><th>Link</th></tr>
-        <tr><td><a href='http://bitbucket.digital.vn/projects/PAY'>Repo</a></td></tr>
-    </table>
-    """
-
-    async def mock_get_page(page_id, expand=None):
-        if page_id == department_id and expand == "ancestors":
-            return {
-                "id": department_id,
-                "title": "3.2.4 Nền tảng thanh toán",
-                "ancestors": [
-                    {
-                        "id": "88716667",
-                        "title": "3. TTCN - Đóng gói nền tảng Sản phẩm",
-                        "_links": {
-                            "webui": "/pages/viewpage.action?pageId=88716667",
-                            "base": "http://confluence.digital.vn",
-                        },
-                    },
-                    {
-                        "id": "88716675",
-                        "title": "3.2 Các hệ thống",
-                        "_links": {
-                            "webui": "/pages/viewpage.action?pageId=88716675",
-                            "base": "http://confluence.digital.vn",
-                        },
-                    },
-                ],
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": f"/pages/viewpage.action?pageId={department_id}",
-                },
-            }
-        if page_id == department_id:
-            return {
-                "id": department_id,
-                "title": "3.2.4 Nền tảng thanh toán",
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": f"/pages/viewpage.action?pageId={department_id}",
-                },
-            }
-        return None
-
-    async def mock_get_child_pages(page_id, expand=None):
-        if page_id == department_id:
-            return [
-                {
-                    "id": "88718977",
-                    "title": "Auto Payment",
-                    "body": {"storage": {"value": valid_html}},
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=88718977",
-                    },
-                }
-            ]
-        return []
-
-    mock_client.get_page.side_effect = mock_get_page
-    mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-    registry = await parser.parse_registry(department_id)
-
-    assert len(registry.projects) == 1
-    project = registry.projects[0]
-    assert project.department_page_id == department_id
-    assert project.root_page_id == "88716675"
-    assert project.root_title == "3.2 Các hệ thống"
-    assert [node.page_id for node in project.confluence_ancestry_path] == ["88716675", department_id, "88718977"]
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_with_checklist_override(mock_client):
-    """Explicit checklist override should take precedence."""
-    parser = RegistryPageParser(
-        mock_client,
-        checklist_page="99999",
-    )
-    root_id = "88716667"
-
-    mock_client.get_child_pages.return_value = [
-        {
-            "id": "88716673",
-            "title": "3.1 Checklist đánh giá",
-            "_links": {
-                "base": "http://confluence.digital.vn",
-                "webui": "/pages/viewpage.action?pageId=88716673",
-            },
-        },
-        {
-            "id": "88716675",
-            "title": "3.2 Các hệ thống",
-            "_links": {},
-        },
-    ]
-
-    registry = await parser.parse_registry(root_id)
-
-    # Override should take precedence over discovered checklist.
-    assert registry.checklist_page_id == "99999"
-    assert registry.checklist_title == "Explicit override"
-
-
-@pytest.mark.asyncio
-async def test_find_projects_root_and_checklist_deterministic(parser_checklist_first, mock_client):
-    """Deterministic discovery should classify root children correctly."""
-    root_id = "88716667"
-
-    mock_client.get_child_pages.return_value = [
-        {
-            "id": "11111",
-            "title": "Audit History",
-            "_links": {},
-        },
-        {
-            "id": "88716673",
-            "title": "3.1 Checklist đánh giá",
-            "_links": {
-                "self": "http://confluence.digital.vn/rest/api/content/88716673",
-                "webui": "/pages/viewpage.action?pageId=88716673",
-            },
-        },
-        {
-            "id": "88716675",
-            "title": "3.2 Các hệ thống",
-            "_links": {
-                "self": "http://confluence.digital.vn/rest/api/content/88716675",
-                "webui": "/pages/viewpage.action?pageId=88716675",
-            },
-        },
-        {
-            "id": "22222",
-            "title": "Random Documentation",
-            "_links": {},
-        },
-    ]
-
-    (
-        projects_root_id,
-        checklist_candidates,
-    ) = await parser_checklist_first._find_projects_root_and_checklist_deterministic(root_id)
-
-    assert projects_root_id == "88716675"
-    assert checklist_candidates
-    assert checklist_candidates[0]["id"] == "88716673"
-    assert checklist_candidates[0]["title"] == "3.1 Checklist đánh giá"
-
-
-@pytest.mark.asyncio
-async def test_deterministic_discovery_without_checklist(parser_checklist_first, mock_client):
-    """Deterministic discovery should handle missing checklist gracefully."""
-    root_id = "88716667"
-
-    mock_client.get_child_pages.return_value = [
-        {
-            "id": "88716675",
-            "title": "3.2 Các hệ thống",
-            "_links": {},
-        },
-    ]
-
-    (
-        projects_root_id,
-        checklist_candidates,
-    ) = await parser_checklist_first._find_projects_root_and_checklist_deterministic(root_id)
-
-    assert projects_root_id == "88716675"
-    assert checklist_candidates == []
-
-
-@pytest.mark.asyncio
-async def test_deterministic_discovery_without_projects_root(parser_checklist_first, mock_client):
-    """Deterministic discovery should handle missing projects root gracefully."""
-    root_id = "88716667"
-
-    mock_client.get_child_pages.return_value = [
-        {
-            "id": "88716673",
-            "title": "3.1 Checklist đánh giá",
-            "_links": {
-                "base": "http://confluence.digital.vn",
-                "webui": "/pages/viewpage.action?pageId=88716673",
-            },
-        },
-    ]
-
-    (
-        projects_root_id,
-        checklist_candidates,
-    ) = await parser_checklist_first._find_projects_root_and_checklist_deterministic(root_id)
-
-    assert projects_root_id is None
-    assert checklist_candidates
-    assert checklist_candidates[0]["id"] == "88716673"
-
-
-# Phase 24 TSK-242: Project link extraction hardening tests
-
-
-class TestProjectCandidateFiltering:
-    """Tests for enhanced project candidate filtering (TSK-242.3.1)."""
-
-    def test_filter_audit_history_exact(self):
-        """Audit history pages should be filtered."""
-        is_candidate, reason = RegistryPageParser._is_project_candidate_title("Audit History")
-        assert not is_candidate
-        assert reason == SkippedNodeReason.AUDIT_HISTORY
-
-    def test_filter_audit_history_vietnamese(self):
-        """Vietnamese audit history pages should be filtered."""
-        is_candidate, reason = RegistryPageParser._is_project_candidate_title("Lịch sử audit")
-        assert not is_candidate
-        assert reason == SkippedNodeReason.AUDIT_HISTORY
-
-        is_candidate, reason = RegistryPageParser._is_project_candidate_title("Lịch sử đánh giá")
-        assert not is_candidate
-        assert reason == SkippedNodeReason.AUDIT_HISTORY
-
-    def test_filter_checklist_pages(self):
-        """Checklist pages should be filtered."""
-        is_candidate, reason = RegistryPageParser._is_project_candidate_title("Checklist đánh giá")
-        assert not is_candidate
-        assert reason == SkippedNodeReason.CHECKLIST_NODE
-
-        is_candidate, reason = RegistryPageParser._is_project_candidate_title("Template audit")
-        assert not is_candidate
-        assert reason == SkippedNodeReason.CHECKLIST_NODE
-
-    def test_filter_empty_title(self):
-        """Empty titles should be filtered."""
-        is_candidate, reason = RegistryPageParser._is_project_candidate_title("")
-        assert not is_candidate
-        assert reason == SkippedNodeReason.EMPTY_TITLE
-
-        is_candidate, reason = RegistryPageParser._is_project_candidate_title("   ")
-        assert not is_candidate
-        assert reason == SkippedNodeReason.EMPTY_TITLE
-
-    def test_valid_project_titles(self):
-        """Valid project titles should pass filtering."""
-        is_candidate, reason = RegistryPageParser._is_project_candidate_title("Insurance Core Service")
-        assert is_candidate
-        assert reason is None
-
-        is_candidate, reason = RegistryPageParser._is_project_candidate_title("Merchant Profile Service")
-        assert is_candidate
-        assert reason is None
-
-        is_candidate, reason = RegistryPageParser._is_project_candidate_title("Dịch vụ thanh toán")
-        assert is_candidate
-        assert reason is None
-
-
-class TestUrlNormalization:
-    """Tests for URL normalization (TSK-242.3.2)."""
-
-    def test_normalize_trailing_slashes(self):
-        """Trailing slashes should be removed."""
-        assert RegistryPageParser.normalize_url("http://example.com/path/") == "http://example.com/path"
-        assert RegistryPageParser.normalize_url("http://example.com/path///") == "http://example.com/path"
-
-    def test_normalize_confluence_pageid_url(self):
-        """Confluence pageId URLs should be normalized."""
-        url = "http://confluence.digital.vn/pages/viewpage.action?pageId=12345&extra=param"
-        normalized = RegistryPageParser.normalize_url(url)
-        assert normalized == "http://confluence.digital.vn/pages/viewpage.action?pageid=12345"
-
-    def test_normalize_confluence_display_url(self):
-        """Confluence display URLs should be normalized."""
-        url = "http://confluence.digital.vn/display/SPACE/Page+Title?param=value"
-        normalized = RegistryPageParser.normalize_url(url)
-        assert normalized == "http://confluence.digital.vn/display/space/page+title"
-
-    def test_normalize_bitbucket_url(self):
-        """Bitbucket URLs should be normalized."""
-        url = "http://bitbucket.digital.vn/projects/INS/repos/insurance-core/browse"
-        normalized = RegistryPageParser.normalize_url(url)
-        assert normalized == "http://bitbucket.digital.vn/projects/ins/repos/insurance-core"
-
-    def test_normalize_empty_url(self):
-        """Empty URLs should return empty string."""
-        assert RegistryPageParser.normalize_url("") == ""
-        assert RegistryPageParser.normalize_url("   ") == ""
-
-    def test_normalize_case_insensitive(self):
-        """URLs should be normalized to lowercase."""
-        url = "HTTP://EXAMPLE.COM/PATH"
-        normalized = RegistryPageParser.normalize_url(url)
-        assert normalized == "http://example.com/path"
-
-
-class TestExtractConfluenceTinyId:
-    """Tests for the _extract_confluence_tiny_id static method."""
-
-    def test_extracts_tiny_id_from_absolute_short_url(self):
-        result = RegistryPageParser._extract_confluence_tiny_id("http://confluence.digital.vn/x/J2Q1")
-        assert result == "J2Q1"
-
-    def test_extracts_tiny_id_from_relative_short_url(self):
-        result = RegistryPageParser._extract_confluence_tiny_id("/x/J2Q1")
-        assert result == "J2Q1"
-
-    def test_returns_none_for_pageid_url(self):
-        result = RegistryPageParser._extract_confluence_tiny_id(
-            "http://confluence.digital.vn/pages/viewpage.action?pageId=12345"
-        )
-        assert result is None
-
-    def test_returns_none_for_display_url(self):
-        result = RegistryPageParser._extract_confluence_tiny_id(
-            "http://confluence.digital.vn/display/TTCN24/Core+Transfer"
-        )
-        assert result is None
-
-    def test_returns_none_for_empty_string(self):
-        assert RegistryPageParser._extract_confluence_tiny_id("") is None
-
-    def test_returns_none_for_non_confluence_url(self):
-        assert RegistryPageParser._extract_confluence_tiny_id("http://example.com/x/abc") == "abc"
-
-    def test_handles_alphanumeric_and_hyphen_and_underscore(self):
-        for tiny_id in ("abc123", "Ab-Cd_Ef", "ZZZZ", "a1-b2_c3"):
-            result = RegistryPageParser._extract_confluence_tiny_id(f"http://confluence.digital.vn/x/{tiny_id}")
-            assert result == tiny_id
-
-
-class TestLinkDeduplication:
-    """Tests for link deduplication (TSK-242.3.2)."""
-
-    def test_deduplicate_exact_duplicates(self, parser):
-        """Exact duplicate links should be removed."""
-        from vds_audit_orchestrator.models.registry import DocumentLink, DocumentRole, LinkSource
-
-        links = [
-            DocumentLink(
-                role=DocumentRole.PO,
-                doc_type="BRD",
-                url="http://confluence.digital.vn/pages/viewpage.action?pageId=12345",
-                source=LinkSource.CONFLUENCE,
-            ),
-            DocumentLink(
-                role=DocumentRole.BA,
-                doc_type="SRS",
-                url="http://confluence.digital.vn/pages/viewpage.action?pageId=12345",
-                source=LinkSource.CONFLUENCE,
-            ),
-        ]
-
-        deduplicated = parser.deduplicate_links(links)
-        assert len(deduplicated) == 1
-        assert deduplicated[0].role == DocumentRole.PO  # First occurrence kept
-
-    def test_deduplicate_normalized_duplicates(self, parser):
-        """Links that normalize to the same URL should be deduplicated."""
-        from vds_audit_orchestrator.models.registry import DocumentLink, DocumentRole, LinkSource
-
-        links = [
-            DocumentLink(
-                role=DocumentRole.PO,
-                doc_type="BRD",
-                url="http://confluence.digital.vn/pages/viewpage.action?pageId=12345",
-                source=LinkSource.CONFLUENCE,
-            ),
-            DocumentLink(
-                role=DocumentRole.BA,
-                doc_type="SRS",
-                url="http://confluence.digital.vn/pages/viewpage.action?pageId=12345&extra=param",
-                source=LinkSource.CONFLUENCE,
-            ),
-        ]
-
-        deduplicated = parser.deduplicate_links(links)
-        assert len(deduplicated) == 1
-
-    def test_deduplicate_preserves_unique_links(self, parser):
-        """Unique links should be preserved."""
-        from vds_audit_orchestrator.models.registry import DocumentLink, DocumentRole, LinkSource
-
-        links = [
-            DocumentLink(
-                role=DocumentRole.PO,
-                doc_type="BRD",
-                url="http://confluence.digital.vn/pages/viewpage.action?pageId=12345",
-                source=LinkSource.CONFLUENCE,
-            ),
-            DocumentLink(
-                role=DocumentRole.DEV,
-                doc_type="Source Code",
-                url="http://bitbucket.digital.vn/projects/INS/repos/core",
-                source=LinkSource.BITBUCKET,
-            ),
-        ]
-
-        deduplicated = parser.deduplicate_links(links)
-        assert len(deduplicated) == 2
-
-
-class TestSkippedNodeTelemetry:
-    """Tests for skipped-node telemetry (TSK-242.3.3)."""
-
-    @pytest.mark.asyncio
-    async def test_skipped_nodes_tracked_for_audit_history(self, parser, mock_client):
-        """Audit history pages should be tracked in skipped_nodes."""
-        root_id = "88716667"
-
-        # Mock get_child_pages to return different results for different calls
-        async def mock_get_child_pages(page_id, expand=None):
-            if page_id == root_id:
-                return [
-                    {
-                        "id": "88716675",
-                        "title": "3.2 Các hệ thống",
-                        "_links": {},
-                    },
-                ]
-            elif page_id == "88716675":
-                return [
-                    {
-                        "id": "11111",
-                        "title": "Audit History",
-                        "body": {"storage": {"value": "<table></table>"}},
-                        "_links": {},
-                    },
-                    {
-                        "id": "22222",
-                        "title": "Valid Project",
-                        "body": {
-                            "storage": {
-                                "value": "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com'>Link</a></td></tr></table>"
-                            }
-                        },
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": "/pages/viewpage.action?pageId=22222",
-                        },
-                    },
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-        registry = await parser.parse_registry(root_id)
-
-        # Should have skipped the audit history page
-        audit_history_skipped = [n for n in registry.skipped_nodes if n.reason == SkippedNodeReason.AUDIT_HISTORY]
-        assert len(audit_history_skipped) == 1
-        assert audit_history_skipped[0].page_id == "11111"
-        assert audit_history_skipped[0].title == "Audit History"
-
-    @pytest.mark.asyncio
-    async def test_skipped_nodes_tracked_for_checklist(self, parser, mock_client):
-        """Checklist pages should be tracked in skipped_nodes."""
-        root_id = "88716667"
-
-        async def mock_get_child_pages(page_id, expand=None):
-            if page_id == root_id:
-                return [
-                    {
-                        "id": "88716675",
-                        "title": "3.2 Các hệ thống",
-                        "_links": {},
-                    },
-                ]
-            elif page_id == "88716675":
-                return [
-                    {
-                        "id": "33333",
-                        "title": "Checklist Template",
-                        "body": {"storage": {"value": "<table></table>"}},
-                        "_links": {},
-                    },
-                    {
-                        "id": "44444",
-                        "title": "Valid Project",
-                        "body": {
-                            "storage": {
-                                "value": "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com'>Link</a></td></tr></table>"
-                            }
-                        },
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": "/pages/viewpage.action?pageId=44444",
-                        },
-                    },
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-        registry = await parser.parse_registry(root_id)
-
-        checklist_skipped = [n for n in registry.skipped_nodes if n.reason == SkippedNodeReason.CHECKLIST_NODE]
-        assert len(checklist_skipped) >= 1
-        assert any(n.page_id == "33333" for n in checklist_skipped)
-
-    @pytest.mark.asyncio
-    async def test_skipped_nodes_tracked_for_no_links(self, parser, mock_client):
-        """Pages with no links should be tracked in skipped_nodes."""
-        root_id = "88716667"
-
-        async def mock_get_child_pages(page_id, expand=None):
-            if page_id == root_id:
-                return [
-                    {
-                        "id": "88716675",
-                        "title": "3.2 Các hệ thống",
-                        "_links": {},
-                    },
-                ]
-            elif page_id == "88716675":
-                return [
-                    {
-                        "id": "44444",
-                        "title": "Empty Project",
-                        "body": {"storage": {"value": "<p>No tables here</p>"}},
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": "/pages/viewpage.action?pageId=44444",
-                        },
-                    },
-                    {
-                        "id": "55555",
-                        "title": "Valid Project",
-                        "body": {
-                            "storage": {
-                                "value": "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com'>Link</a></td></tr></table>"
-                            }
-                        },
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": "/pages/viewpage.action?pageId=55555",
-                        },
-                    },
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-        registry = await parser.parse_registry(root_id)
-
-        no_links_skipped = [n for n in registry.skipped_nodes if n.reason == SkippedNodeReason.NO_LINKS]
-        assert len(no_links_skipped) >= 1
-        assert any(n.page_id == "44444" for n in no_links_skipped)
-
-
-class TestMixedVnEnTableHeaders:
-    """Tests for mixed Vietnamese/English table headers (TSK-242.3.4)."""
-
-    def test_extract_links_mixed_vn_en_headers(self, parser):
-        """Should handle tables with mixed VN/EN headers."""
-        html = """
-        <table>
-            <tr>
-                <th>Vai trò</th>
-                <th>Loại tài liệu</th>
-                <th>Doc Type EN</th>
-                <th>Link tài liệu</th>
-            </tr>
-            <tr>
-                <td>PO</td>
-                <td>1. Tài liệu BRD</td>
-                <td>BRD Document</td>
-                <td><a href="/display/SPACE/BRD">BRD Link</a></td>
-            </tr>
-        </table>
-        """
-        base_url = "http://confluence.digital.vn"
-
-        links = parser._extract_links_from_html(html, base_url)
-
-        assert len(links) == 1
-        assert links[0].role == DocumentRole.PO
-        assert links[0].doc_type == "Tài liệu BRD"
-        assert links[0].doc_type_en == "BRD Document"
-
-    def test_extract_links_english_only_headers(self, parser):
-        """Should handle tables with English-only headers."""
-        html = """
-        <table>
-            <tr>
-                <th>Role</th>
-                <th>Document Type</th>
-                <th>Link</th>
-            </tr>
-            <tr>
-                <td>Developer</td>
-                <td>Source Code</td>
-                <td><a href="http://bitbucket.digital.vn/projects/INS">Repo</a></td>
-            </tr>
-        </table>
-        """
-        base_url = "http://confluence.digital.vn"
-
-        links = parser._extract_links_from_html(html, base_url)
-
-        assert len(links) == 1
-        assert links[0].role == DocumentRole.DEV
-        assert links[0].source == LinkSource.BITBUCKET
-
-    def test_extract_links_vietnamese_only_headers(self, parser):
-        """Should handle tables with Vietnamese-only headers."""
-        html = """
-        <table>
-            <tr>
-                <th>Phụ trách</th>
-                <th>Mô tả</th>
-                <th>Link</th>
-            </tr>
-            <tr>
-                <td>BA</td>
-                <td>Tài liệu phân tích</td>
-                <td><a href="/pages/viewpage.action?pageId=12345">Link</a></td>
-            </tr>
-        </table>
-        """
-        base_url = "http://confluence.digital.vn"
-
-        links = parser._extract_links_from_html(html, base_url)
-
-        assert len(links) == 1
-        assert links[0].role == DocumentRole.BA
-        assert links[0].source == LinkSource.CONFLUENCE
-        assert links[0].page_id == "12345"
-
-
-class TestLinkColumnFallback:
-    """Tests for link-column fallback behavior (TSK-242.3.4)."""
-
-    def test_fallback_to_all_cells_when_no_link_header(self, parser):
-        """Should search all cells for links when no 'Link' header is present."""
-        html = """
-        <table>
-            <tr>
-                <th>Vai trò</th>
-                <th>Tài liệu</th>
-            </tr>
-            <tr>
-                <td>PO</td>
-                <td><a href="/display/SPACE/Doc">Document</a></td>
-            </tr>
-        </table>
-        """
-        base_url = "http://confluence.digital.vn"
-
-        links = parser._extract_links_from_html(html, base_url)
-
-        assert len(links) == 1
-        assert links[0].url == "http://confluence.digital.vn/display/SPACE/Doc"
-
-    def test_link_column_takes_priority(self, parser):
-        """When 'Link' header exists, only that column should be searched."""
-        html = """
-        <table>
-            <tr>
-                <th>Vai trò</th>
-                <th>Tài liệu</th>
-                <th>Link</th>
-            </tr>
-            <tr>
-                <td><a href="/ignored">PO</a></td>
-                <td>BRD</td>
-                <td><a href="/display/SPACE/BRD">BRD Link</a></td>
-            </tr>
-        </table>
-        """
-        base_url = "http://confluence.digital.vn"
-
-        links = parser._extract_links_from_html(html, base_url)
-
-        # Should only find the link in the Link column
-        assert len(links) == 1
-        assert "/display/SPACE/BRD" in links[0].url
-
-    def test_multiple_links_in_link_column(self, parser):
-        """Should extract multiple links from the Link column."""
-        html = """
-        <table>
-            <tr>
-                <th>Vai trò</th>
-                <th>Link tài liệu</th>
-            </tr>
-            <tr>
-                <td>PO</td>
-                <td>
-                    <a href="/display/SPACE/BRD">BRD</a>
-                    <a href="/display/SPACE/PRD">PRD</a>
-                </td>
-            </tr>
-        </table>
-        """
-        base_url = "http://confluence.digital.vn"
-
-        links = parser._extract_links_from_html(html, base_url)
-
-        assert len(links) == 2
-        urls = [link.url for link in links]
-        assert any("BRD" in url for url in urls)
-        assert any("PRD" in url for url in urls)
-
-    def test_extract_plain_text_urls_in_link_column(self, parser):
-        """Should extract plain-text URLs in link cells (nolink spans / raw text)."""
-        html = """
-        <table>
-            <tr>
-                <th>Vai trò</th>
-                <th>Loại tài liệu</th>
-                <th>Link tài liệu</th>
-            </tr>
-            <tr>
-                <td>DEV</td>
-                <td>8. Source code</td>
-                <td>
-                    <span class="nolink">http://bitbucket.digital.vn/projects/MAP</span>
-                    http://bitbucket.digital.vn/projects/SUPERAPP/repos/miniapp-webplatform-android/browse
-                </td>
-            </tr>
-        </table>
-        """
-        base_url = "http://confluence.digital.vn"
-
-        links = parser._extract_links_from_html(html, base_url)
-
-        urls = {link.url for link in links}
-        assert "http://bitbucket.digital.vn/projects/MAP" in urls
-        assert "http://bitbucket.digital.vn/projects/SUPERAPP/repos/miniapp-webplatform-android/browse" in urls
-        assert all(link.source == LinkSource.BITBUCKET for link in links)
-
-
-# Phase 24 TSK-243: Timeout budgets and partial-success diagnostics tests
-
-
-class TestParserBudgetControls:
-    """Tests for parser budget controls (TSK-243.4.1)."""
-
-    def test_max_projects_parameter(self, mock_client):
-        """Parser should accept max_projects parameter."""
-        parser = RegistryPageParser(mock_client, max_projects=5)
-        assert parser.max_projects == 5
-
-    def test_max_projects_none_means_no_limit(self, mock_client):
-        """max_projects=None should mean no limit."""
-        parser = RegistryPageParser(mock_client, max_projects=None)
-        assert parser.max_projects is None
-
-    def test_step_timeout_parameter(self, mock_client):
-        """Parser should accept step_timeout parameter."""
-        parser = RegistryPageParser(mock_client, step_timeout=30.0)
-        assert parser.step_timeout == 30.0
-
-    def test_step_timeout_none_means_no_limit(self, mock_client):
-        """step_timeout=None should mean no per-step timeout."""
-        parser = RegistryPageParser(mock_client, step_timeout=None)
-        assert parser.step_timeout is None
-
-
-class TestMaxProjectsLimit:
-    """Tests for max_projects limit behavior (TSK-243.4.1)."""
-
-    @pytest.mark.asyncio
-    async def test_max_projects_limits_parsing(self, mock_client):
-        """Parser should stop after max_projects limit is reached."""
-        parser = RegistryPageParser(mock_client, max_projects=2)
-        root_id = "88716667"
-
-        async def mock_get_child_pages(page_id, expand=None):
-            if page_id == root_id:
-                return [
-                    {"id": "88716675", "title": "3.2 Các hệ thống", "_links": {}},
-                ]
-            elif page_id == "88716675":
-                # Return 5 project candidates
-                return [
-                    {
-                        "id": f"proj_{i}",
-                        "title": f"Project {i}",
-                        "body": {
-                            "storage": {
-                                "value": f"<table><tr><th>Link</th></tr><tr><td><a href='http://example.com/{i}'>Link</a></td></tr></table>"
-                            }
-                        },
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": f"/pages/viewpage.action?pageId=proj_{i}",
-                        },
-                    }
-                    for i in range(5)
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-        registry = await parser.parse_registry(root_id)
-
-        # Should only have 2 projects due to limit
-        assert len(registry.projects) == 2
-        # Should have diagnostics indicating max_projects was reached
-        assert registry.diagnostics is not None
-        assert registry.diagnostics.max_projects_reached is True
-        # Should have skipped nodes for the remaining projects
-        max_projects_skipped = [n for n in registry.skipped_nodes if n.reason == SkippedNodeReason.MAX_PROJECTS_REACHED]
-        assert len(max_projects_skipped) == 3
-
-    @pytest.mark.asyncio
-    async def test_no_limit_when_max_projects_none(self, mock_client):
-        """Parser should parse all projects when max_projects is None."""
-        parser = RegistryPageParser(mock_client, max_projects=None)
-        root_id = "88716667"
-
-        async def mock_get_child_pages(page_id, expand=None):
-            if page_id == root_id:
-                return [
-                    {"id": "88716675", "title": "3.2 Các hệ thống", "_links": {}},
-                ]
-            elif page_id == "88716675":
-                return [
-                    {
-                        "id": f"proj_{i}",
-                        "title": f"Project {i}",
-                        "body": {
-                            "storage": {
-                                "value": f"<table><tr><th>Link</th></tr><tr><td><a href='http://example.com/{i}'>Link</a></td></tr></table>"
-                            }
-                        },
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": f"/pages/viewpage.action?pageId=proj_{i}",
-                        },
-                    }
-                    for i in range(5)
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-        registry = await parser.parse_registry(root_id)
-
-        # Should have all 5 projects
-        assert len(registry.projects) == 5
-        assert registry.diagnostics is not None
-        assert registry.diagnostics.max_projects_reached is False
-
-
-class TestParseDiagnostics:
-    """Tests for parse diagnostics (TSK-243.4.2)."""
-
-    @pytest.mark.asyncio
-    async def test_diagnostics_populated_on_success(self, mock_client):
-        """Diagnostics should be populated even on successful parse."""
-        parser = RegistryPageParser(mock_client)
-        root_id = "88716667"
-
-        async def mock_get_child_pages(page_id, expand=None):
-            if page_id == root_id:
-                return [
-                    {"id": "88716675", "title": "3.2 Các hệ thống", "_links": {}},
-                ]
-            elif page_id == "88716675":
-                return [
-                    {
-                        "id": "proj_1",
-                        "title": "Project 1",
-                        "body": {
-                            "storage": {
-                                "value": "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com'>Link</a></td></tr></table>"
-                            }
-                        },
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": "/pages/viewpage.action?pageId=proj_1",
-                        },
-                    },
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-        registry = await parser.parse_registry(root_id)
-
-        assert registry.diagnostics is not None
-        # Duration may be 0 for very fast tests, so just check it's non-negative
-        assert registry.diagnostics.parse_duration_ms >= 0
-        assert registry.diagnostics.total_pages_attempted == 1
-        assert registry.diagnostics.total_pages_succeeded == 1
-        assert registry.diagnostics.timed_out_pages == []
-        assert registry.diagnostics.failed_pages == []
-        assert registry.diagnostics.partial_success is False
-
-    @pytest.mark.asyncio
-    async def test_diagnostics_tracks_failed_pages(self, mock_client):
-        """Diagnostics should track failed pages when parse_project_page raises an exception."""
-        parser = RegistryPageParser(mock_client)
-        root_id = "88716667"
-
-        async def mock_get_child_pages(page_id, expand=None):
-            if page_id == root_id:
-                return [
-                    {"id": "88716675", "title": "3.2 Các hệ thống", "_links": {}},
-                ]
-            elif page_id == "88716675":
-                return [
-                    {
-                        "id": "proj_1",
-                        "title": "Project 1",
-                        "body": {
-                            "storage": {
-                                "value": "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com'>Link</a></td></tr></table>"
-                            }
-                        },
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": "/pages/viewpage.action?pageId=proj_1",
-                        },
-                    },
-                    {
-                        "id": "proj_2",
-                        "title": "Project 2",
-                        # No body.storage - will need to fetch via get_page
-                        "_links": {},
-                    },
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = mock_get_child_pages
-        # Make get_page raise an exception to simulate failure
-        mock_client.get_page.side_effect = Exception("Simulated failure")
-
-        registry = await parser.parse_registry(root_id)
-
-        assert registry.diagnostics is not None
-        assert registry.diagnostics.total_pages_attempted == 2
-        # proj_2 should be in failed_pages since get_page raises an exception
-        assert len(registry.diagnostics.failed_pages) == 1
-        assert "proj_2" in registry.diagnostics.failed_pages
-        assert registry.diagnostics.partial_success is True
-
-
-class TestPartialSuccessBehavior:
-    """Tests for partial-success behavior (TSK-243.4.3)."""
-
-    @pytest.mark.asyncio
-    async def test_returns_partial_results_on_timeout(self, mock_client):
-        """Parser should return partial results when some pages timeout."""
-        # Use a very short step_timeout to trigger timeouts
-        parser = RegistryPageParser(mock_client, step_timeout=0.001)
-        root_id = "88716667"
-
-        async def mock_get_child_pages(page_id, expand=None):
-            if page_id == root_id:
-                return [
-                    {"id": "88716675", "title": "3.2 Các hệ thống", "_links": {}},
-                ]
-            elif page_id == "88716675":
-                return [
-                    {
-                        "id": "proj_fast",
-                        "title": "Fast Project",
-                        "body": {
-                            "storage": {
-                                "value": "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com'>Link</a></td></tr></table>"
-                            }
-                        },
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": "/pages/viewpage.action?pageId=proj_fast",
-                        },
-                    },
-                    {
-                        "id": "proj_slow",
-                        "title": "Slow Project",
-                        # No body - will need to fetch via get_page
-                        "_links": {},
-                    },
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-        # Make get_page slow to trigger timeout
-        async def slow_get_page(*args, **kwargs):
-            import asyncio
-
-            await asyncio.sleep(1.0)  # Much longer than step_timeout
-
-        mock_client.get_page.side_effect = slow_get_page
-
-        registry = await parser.parse_registry(root_id)
-
-        # Should have at least the fast project
-        assert registry.diagnostics is not None
-        # The slow project should be in timed_out_pages
-        assert "proj_slow" in registry.diagnostics.timed_out_pages
-        assert registry.diagnostics.partial_success is True
-
-    @pytest.mark.asyncio
-    async def test_returns_partial_results_on_failure(self, mock_client):
-        """Parser should return partial results when some pages fail with exceptions."""
-        parser = RegistryPageParser(mock_client)
-        root_id = "88716667"
-
-        async def mock_get_child_pages(page_id, expand=None):
-            if page_id == root_id:
-                return [
-                    {"id": "88716675", "title": "3.2 Các hệ thống", "_links": {}},
-                ]
-            elif page_id == "88716675":
-                return [
-                    {
-                        "id": "proj_good",
-                        "title": "Good Project",
-                        "body": {
-                            "storage": {
-                                "value": "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com'>Link</a></td></tr></table>"
-                            }
-                        },
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": "/pages/viewpage.action?pageId=proj_good",
-                        },
-                    },
-                    {
-                        "id": "proj_bad",
-                        "title": "Bad Project",
-                        # No body.storage - will need to fetch via get_page
-                        "_links": {},
-                    },
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = mock_get_child_pages
-        # Make get_page raise an exception to simulate failure
-        mock_client.get_page.side_effect = Exception("Simulated failure")
-
-        registry = await parser.parse_registry(root_id)
-
-        # Should have the good project
-        assert len(registry.projects) == 1
-        assert registry.projects[0].project_name == "Good Project"
-        # Bad project should be in failed_pages
-        assert registry.diagnostics is not None
-        assert "proj_bad" in registry.diagnostics.failed_pages
-        assert registry.diagnostics.partial_success is True
-
-
-class TestTimeoutSkippedNodeReason:
-    """Tests for TIMEOUT skipped node reason (TSK-243)."""
-
-    @pytest.mark.asyncio
-    async def test_timeout_creates_skipped_node(self, mock_client):
-        """Timed out pages should create skipped nodes with TIMEOUT reason."""
-        parser = RegistryPageParser(mock_client, step_timeout=0.001)
-        root_id = "88716667"
-
-        async def mock_get_child_pages(page_id, expand=None):
-            if page_id == root_id:
-                return [
-                    {"id": "88716675", "title": "3.2 Các hệ thống", "_links": {}},
-                ]
-            elif page_id == "88716675":
-                return [
-                    {
-                        "id": "proj_slow",
-                        "title": "Slow Project",
-                        # No body.storage - will need to fetch via get_page
-                        "_links": {},
-                    },
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-        async def slow_get_page(*args, **kwargs):
-            import asyncio
-
-            await asyncio.sleep(1.0)
-
-        mock_client.get_page.side_effect = slow_get_page
-
-        registry = await parser.parse_registry(root_id)
-
-        timeout_skipped = [
-            n for n in registry.skipped_nodes if n.reason == SkippedNodeReason.TIMEOUT and n.page_id == "proj_slow"
-        ]
-        # Should have at least one timeout for proj_slow
-        assert len(timeout_skipped) >= 1
-        assert timeout_skipped[0].title == "Slow Project"
-
-
-class TestRetryWithTimeout:
-    """Tests for retry behavior with timeout (TSK-243)."""
-
-    @pytest.mark.asyncio
-    async def test_retry_respects_step_timeout(self, mock_client):
-        """Retry should respect step_timeout for each attempt."""
-        parser = RegistryPageParser(mock_client, step_timeout=0.1, retries=1)
-
-        call_count = 0
-
-        async def slow_fn():
-            nonlocal call_count
-            call_count += 1
-            import asyncio
-
-            await asyncio.sleep(0.5)  # Longer than step_timeout
-            return "result"
-
-        result = await parser._retry(slow_fn, test_context="test")
-
-        # Should have tried twice (initial + 1 retry) and both timed out
-        assert call_count == 2
-        assert result is None
-
-    @pytest.mark.asyncio
-    async def test_retry_succeeds_within_timeout(self, mock_client):
-        """Retry should succeed if function completes within timeout."""
-        parser = RegistryPageParser(mock_client, step_timeout=1.0, retries=1)
-
-        async def fast_fn():
-            return "result"
-
-        result = await parser._retry(fast_fn, test_context="test")
-
-        assert result == "result"
-
-    @pytest.mark.asyncio
-    async def test_retry_with_explicit_timeout_override(self, mock_client):
-        """Explicit timeout parameter should override step_timeout."""
-        parser = RegistryPageParser(mock_client, step_timeout=10.0, retries=0)
-
-        call_count = 0
-
-        async def slow_fn():
-            nonlocal call_count
-            call_count += 1
-            import asyncio
-
-            await asyncio.sleep(0.5)
-            return "result"
-
-        # Use explicit timeout that's shorter than step_timeout
-        result = await parser._retry(slow_fn, timeout=0.1, test_context="test")
-
-        assert call_count == 1
-        assert result is None  # Should timeout
-
-    @pytest.mark.asyncio
-    async def test_retry_tracks_rate_limit_and_retry_after(self, mock_client):
-        parser = RegistryPageParser(mock_client, retries=1, backoff=0.0)
-        call_count = 0
-
-        async def flaky_fn():
-            nonlocal call_count
-            call_count += 1
-            if call_count == 1:
-                raise DataSourceError(
-                    "rate limited",
-                    context={"stderr": "HTTP 429 Too Many Requests\nRetry-After: 7"},
-                )
-            return "ok"
-
-        result = await parser._retry(flaky_fn, test_context="test")
-
-        assert result == "ok"
-        assert parser._diag_retry_count == 1
-        assert parser._diag_rate_limit_events == 1
-        assert parser._diag_retry_after_seconds == 7
-
-    @pytest.mark.asyncio
-    async def test_retry_honors_retry_after_delay(self, mock_client, monkeypatch):
-        parser = RegistryPageParser(mock_client, retries=1, backoff=0.1)
-        call_count = 0
-        sleep_delays: list[float] = []
-
-        async def fake_sleep(delay: float):
-            sleep_delays.append(delay)
-
-        monkeypatch.setattr("vds_audit_orchestrator.collectors.registry_parser.asyncio.sleep", fake_sleep)
-
-        async def flaky_fn():
-            nonlocal call_count
-            call_count += 1
-            if call_count == 1:
-                raise DataSourceError(
-                    "rate limited",
-                    context={"stderr": "HTTP 429 Too Many Requests\nRetry-After: 3"},
-                )
-            return "ok"
-
-        result = await parser._retry(flaky_fn, test_context="test")
-
-        assert result == "ok"
-        assert sleep_delays == [3.0]
-        assert parser._diag_retry_count == 1
-        assert parser._diag_rate_limit_events == 1
-        assert parser._diag_retry_after_seconds == 3
-
-    @pytest.mark.asyncio
-    async def test_retry_5xx_retries_without_rate_limit_event(self, mock_client):
-        parser = RegistryPageParser(mock_client, retries=1, backoff=0.0)
-        call_count = 0
-
-        async def flaky_5xx():
-            nonlocal call_count
-            call_count += 1
-            if call_count == 1:
-                raise DataSourceError("upstream error", context={"stderr": "HTTP 503 Service Unavailable"})
-            return "ok"
-
-        result = await parser._retry(flaky_5xx, test_context="test")
-
-        assert result == "ok"
-        assert parser._diag_retry_count == 1
-        assert parser._diag_rate_limit_events == 0
-        assert parser._diag_retry_after_seconds is None
-
-
-class TestDiagnosticsModel:
-    """Tests for ParseDiagnostics model (TSK-243)."""
-
-    def test_parse_diagnostics_defaults(self):
-        """ParseDiagnostics should have sensible defaults."""
-        from vds_audit_orchestrator.models.registry import ParseDiagnostics
-
-        diag = ParseDiagnostics()
-
-        assert diag.parse_duration_ms == 0
-        assert diag.timed_out_pages == []
-        assert diag.failed_pages == []
-        assert diag.total_pages_attempted == 0
-        assert diag.total_pages_succeeded == 0
-        assert diag.max_projects_reached is False
-        assert diag.partial_success is False
-        assert diag.prefetch_hits == 0
-        assert diag.prefetch_misses == 0
-        assert diag.network_fetches == 0
-        assert diag.fallback_fetches == 0
-        assert diag.prefetch_pages_indexed == 0
-        assert diag.step_timings_ms == {}
-        assert diag.retry_count == 0
-        assert diag.rate_limit_events == 0
-        assert diag.retry_after_seconds is None
-        assert diag.prefetch_insufficient_coverage is False
-        assert diag.prefetch_hint is None
-        assert diag.result_status == "success"
-        assert diag.result_message is None
-        assert diag.can_retry is False
-        assert diag.effective_retries == 0
-        assert diag.effective_backoff_seconds == 0.0
-        assert diag.max_backoff_seconds == 0.0
-        assert diag.effective_step_timeout_seconds is None
-
-    def test_parse_diagnostics_serialization(self):
-        """ParseDiagnostics should serialize correctly."""
-        from vds_audit_orchestrator.models.registry import ParseDiagnostics
-
-        diag = ParseDiagnostics(
-            parse_duration_ms=1500,
-            timed_out_pages=["page1", "page2"],
-            failed_pages=["page3"],
-            total_pages_attempted=10,
-            total_pages_succeeded=7,
-            max_projects_reached=True,
-            partial_success=True,
-            prefetch_hits=5,
-            prefetch_misses=1,
-            network_fetches=3,
-            fallback_fetches=2,
-            prefetch_pages_indexed=12,
-            step_timings_ms={"discover_root_and_checklist": 40, "find_projects": 80},
-            retry_count=3,
-            rate_limit_events=1,
-            retry_after_seconds=9,
-            prefetch_insufficient_coverage=True,
-            prefetch_hint="Prefetch artifacts may be too shallow.",
-            result_status="partial_success",
-            result_message="Registry parsed partially.",
-            can_retry=True,
-            effective_retries=2,
-            effective_backoff_seconds=1.0,
-            max_backoff_seconds=60.0,
-            effective_step_timeout_seconds=20.0,
-        )
-
-        data = diag.model_dump()
-
-        assert data["parse_duration_ms"] == 1500
-        assert data["timed_out_pages"] == ["page1", "page2"]
-        assert data["failed_pages"] == ["page3"]
-        assert data["total_pages_attempted"] == 10
-        assert data["total_pages_succeeded"] == 7
-        assert data["max_projects_reached"] is True
-        assert data["partial_success"] is True
-        assert data["prefetch_hits"] == 5
-        assert data["prefetch_misses"] == 1
-        assert data["network_fetches"] == 3
-        assert data["fallback_fetches"] == 2
-        assert data["prefetch_pages_indexed"] == 12
-        assert data["step_timings_ms"]["discover_root_and_checklist"] == 40
-        assert data["retry_count"] == 3
-        assert data["rate_limit_events"] == 1
-        assert data["retry_after_seconds"] == 9
-        assert data["prefetch_insufficient_coverage"] is True
-        assert data["prefetch_hint"] == "Prefetch artifacts may be too shallow."
-        assert data["result_status"] == "partial_success"
-        assert data["result_message"] == "Registry parsed partially."
-        assert data["can_retry"] is True
-        assert data["effective_retries"] == 2
-        assert data["effective_backoff_seconds"] == 1.0
-        assert data["max_backoff_seconds"] == 60.0
-        assert data["effective_step_timeout_seconds"] == 20.0
-
-
-class TestRegistryWithDiagnostics:
-    """Tests for ProjectRegistry with diagnostics field (TSK-243)."""
-
-    def test_registry_includes_diagnostics(self):
-        """ProjectRegistry should include diagnostics field."""
-        from vds_audit_orchestrator.models.registry import ParseDiagnostics, ProjectRegistry
-
-        diag = ParseDiagnostics(parse_duration_ms=1000)
-        registry = ProjectRegistry(
-            registry_url="/pages/viewpage.action?pageId=12345",
-            registry_page_id="12345",
-            diagnostics=diag,
-        )
-
-        assert registry.diagnostics is not None
-        assert registry.diagnostics.parse_duration_ms == 1000
-
-    def test_registry_diagnostics_serialization(self):
-        """Registry with diagnostics should serialize correctly."""
-        from vds_audit_orchestrator.models.registry import ParseDiagnostics, ProjectRegistry
-
-        diag = ParseDiagnostics(
-            parse_duration_ms=2000,
-            partial_success=True,
-            timed_out_pages=["page1"],
-        )
-        registry = ProjectRegistry(
-            registry_url="/pages/viewpage.action?pageId=12345",
-            registry_page_id="12345",
-            diagnostics=diag,
-        )
-
-        data = registry.model_dump()
-
-        assert data["diagnostics"]["parse_duration_ms"] == 2000
-        assert data["diagnostics"]["partial_success"] is True
-        assert data["diagnostics"]["timed_out_pages"] == ["page1"]
-
-    def test_registry_diagnostics_optional(self):
-        """Registry diagnostics should be optional for backward compatibility."""
-        from vds_audit_orchestrator.models.registry import ProjectRegistry
-
-        registry = ProjectRegistry(
-            registry_url="/pages/viewpage.action?pageId=12345",
-            registry_page_id="12345",
-        )
-
-        assert registry.diagnostics is None
-
-
-# Phase 24 TSK-243.4.5: Prefetch path tests
-
-
-class TestPrefetchArtifacts:
-    """Tests for prefetch artifact loading (TSK-243.4.5)."""
-
-    def test_prefetch_dir_parameter(self, mock_client, tmp_path):
-        """Parser should accept prefetch_dir parameter."""
-        parser = RegistryPageParser(mock_client, prefetch_dir=tmp_path)
-        assert parser.prefetch_dir == tmp_path
-
-    def test_prefetch_dir_none_by_default(self, mock_client):
-        """prefetch_dir should be None by default."""
-        parser = RegistryPageParser(mock_client)
-        assert parser.prefetch_dir is None
-
-    def test_load_prefetch_artifacts_returns_false_when_no_dir(self, mock_client):
-        """_load_prefetch_artifacts should return False when no prefetch_dir."""
-        parser = RegistryPageParser(mock_client)
-        assert parser._load_prefetch_artifacts() is False
-
-    def test_load_prefetch_artifacts_returns_false_when_dir_missing(self, mock_client, tmp_path):
-        """_load_prefetch_artifacts should return False when dir doesn't exist."""
-        parser = RegistryPageParser(mock_client, prefetch_dir=tmp_path / "nonexistent")
-        assert parser._load_prefetch_artifacts() is False
-
-    def test_load_prefetch_artifacts_returns_false_when_manifest_missing(self, mock_client, tmp_path):
-        """_load_prefetch_artifacts should return False when manifest is missing."""
-        parser = RegistryPageParser(mock_client, prefetch_dir=tmp_path)
-        assert parser._load_prefetch_artifacts() is False
-
-    def test_load_prefetch_artifacts_loads_manifest(self, mock_client, tmp_path):
-        """_load_prefetch_artifacts should load manifest and index pages."""
-        import json
-
-        manifest = {
-            "root_page_id": "12345",
-            "page": {"id": "12345", "title": "Root Page"},
-            "child_pages": [
-                {"id": "11111", "title": "Child 1", "parent_id": "12345"},
-                {"id": "22222", "title": "Child 2", "parent_id": "12345"},
-            ],
-        }
-        (tmp_path / "crawl_manifest.json").write_text(json.dumps(manifest))
-
-        parser = RegistryPageParser(mock_client, prefetch_dir=tmp_path)
-        result = parser._load_prefetch_artifacts()
-
-        assert result is True
-        assert parser._prefetch_manifest is not None
-        assert parser._prefetch_manifest["root_page_id"] == "12345"
-        assert len(parser._prefetch_pages) == 3  # root + 2 children
-
-    def test_get_prefetch_page_returns_page(self, mock_client, tmp_path):
-        """_get_prefetch_page should return page data from cache."""
-        import json
-
-        manifest = {
-            "root_page_id": "12345",
-            "page": {"id": "12345", "title": "Root Page"},
-            "child_pages": [
-                {"id": "11111", "title": "Child 1", "parent_id": "12345"},
-            ],
-        }
-        (tmp_path / "crawl_manifest.json").write_text(json.dumps(manifest))
-
-        parser = RegistryPageParser(mock_client, prefetch_dir=tmp_path)
-        parser._load_prefetch_artifacts()
-
-        page = parser._get_prefetch_page("11111")
-        assert page is not None
-        assert page["title"] == "Child 1"
-
-    def test_get_prefetch_page_returns_none_for_unknown(self, mock_client, tmp_path):
-        """_get_prefetch_page should return None for unknown page ID."""
-        import json
-
-        manifest = {
-            "root_page_id": "12345",
-            "page": {"id": "12345", "title": "Root Page"},
-            "child_pages": [],
-        }
-        (tmp_path / "crawl_manifest.json").write_text(json.dumps(manifest))
-
-        parser = RegistryPageParser(mock_client, prefetch_dir=tmp_path)
-        parser._load_prefetch_artifacts()
-
-        page = parser._get_prefetch_page("99999")
-        assert page is None
-
-    def test_get_prefetch_children_returns_children_for_root(self, mock_client, tmp_path):
-        """_get_prefetch_children should return all children for root page."""
-        import json
-
-        manifest = {
-            "root_page_id": "12345",
-            "page": {"id": "12345", "title": "Root Page"},
-            "child_pages": [
-                {"id": "11111", "title": "Child 1", "parent_id": "12345"},
-                {"id": "22222", "title": "Child 2", "parent_id": "12345"},
-            ],
-        }
-        (tmp_path / "crawl_manifest.json").write_text(json.dumps(manifest))
-
-        parser = RegistryPageParser(mock_client, prefetch_dir=tmp_path)
-        parser._load_prefetch_artifacts()
-
-        children = parser._get_prefetch_children("12345")
-        assert children is not None
-        assert len(children) == 2
-
-    def test_get_prefetch_children_returns_none_when_no_manifest(self, mock_client):
-        """_get_prefetch_children should return None when no manifest loaded."""
-        parser = RegistryPageParser(mock_client)
-        children = parser._get_prefetch_children("12345")
-        assert children is None
-
-    def test_get_prefetch_children_returns_empty_for_known_leaf(self, mock_client, tmp_path):
-        """Known leaf pages in manifest should return empty list, not None."""
-        import json
-
-        manifest = {
-            "root_page_id": "12345",
-            "page": {"page_id": "12345", "title": "Root Page"},
-            "child_pages": [
-                {"page_id": "11111", "title": "Leaf", "parent_page_id": "12345"},
-            ],
-        }
-        (tmp_path / "crawl_manifest.json").write_text(json.dumps(manifest))
-
-        parser = RegistryPageParser(mock_client, prefetch_dir=tmp_path)
-        parser._load_prefetch_artifacts()
-
-        children = parser._get_prefetch_children("11111")
-        assert children == []
-
-
-class TestPrefetchIntegration:
-    """Integration tests for prefetch path (TSK-243.4.5)."""
-
-    @pytest.mark.asyncio
-    async def test_parse_registry_uses_prefetch_when_available(self, mock_client, tmp_path):
-        """Parser should use prefetch artifacts instead of network calls for root children."""
-        import json
-
-        manifest = {
-            "root_page_id": "88716667",
-            "page": {"id": "88716667", "title": "Root"},
-            "child_pages": [
-                {
-                    "id": "88716673",
-                    "title": "3.1 Checklist đánh giá",
-                    "parent_id": "88716667",
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=88716673",
-                    },
-                },
-                {
-                    "id": "88716675",
-                    "title": "3.2 Các hệ thống",
-                    "parent_id": "88716667",
-                    "_links": {},
-                },
-                {
-                    "id": "proj_1",
-                    "title": "Project 1",
-                    "parent_id": "88716675",
-                    "body": {
-                        "storage": {
-                            "value": "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com'>Link</a></td></tr></table>"
-                        }
-                    },
-                    "_links": {"base": "http://confluence.digital.vn", "webui": "/pages/viewpage.action?pageId=proj_1"},
-                },
-            ],
-        }
-        (tmp_path / "crawl_manifest.json").write_text(json.dumps(manifest))
-
-        # Mock get_child_pages to return empty for any calls (for nested traversal)
-        mock_client.get_child_pages.return_value = []
-
-        parser = RegistryPageParser(mock_client, prefetch_dir=tmp_path)
-        registry = await parser.parse_registry("88716667")
-
-        # Should have discovered checklist and projects from prefetch
-        assert registry.checklist_page_id == "88716673"
-        assert len(registry.projects) == 1
-        assert registry.projects[0].project_name == "Project 1"
-
-        # The parser uses prefetch for root children discovery, but may still
-        # make network calls for nested traversal (depth > 1). With recursive_depth=1
-        # (default), it should only traverse direct children which are in prefetch.
-        assert registry.diagnostics is not None
-        assert registry.diagnostics.prefetch_hits >= 2
-        assert registry.diagnostics.network_fetches == 0
-        assert registry.diagnostics.fallback_fetches == 0
-        assert registry.diagnostics.prefetch_pages_indexed == 4
-        assert "prefetch_load" in registry.diagnostics.step_timings_ms
-        mock_client.get_child_pages.assert_not_called()
-        mock_client.get_page.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_parse_registry_prefetch_schema_fallbacks_work(self, mock_client, tmp_path):
-        """Prefetch-only parse should support page_id/id and page_url/url variants."""
-        import json
-
-        manifest = {
-            "root_page_id": "88716667",
-            "page": {
-                "page_id": "88716667",
-                "title": "Root",
-                "url": "http://confluence.digital.vn/pages/viewpage.action?pageId=88716667",
-            },
-            "child_pages": [
-                {
-                    "page_id": "88716673",
-                    "title": "3.1 Checklist đánh giá",
-                    "parent_page_id": "88716667",
-                    "page_url": "http://confluence.digital.vn/pages/viewpage.action?pageId=88716673",
-                },
-                {
-                    "id": "88716675",
-                    "title": "3.2 Các hệ thống",
-                    "parent_id": "88716667",
-                    "url": "http://confluence.digital.vn/pages/viewpage.action?pageId=88716675",
-                },
-                {
-                    "page_id": "proj_1",
-                    "title": "Project 1",
-                    "parent_page_id": "88716675",
-                    "page_url": "http://confluence.digital.vn/pages/viewpage.action?pageId=proj_1",
-                    "body": {
-                        "storage": {
-                            "value": "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com/doc'>Doc</a></td></tr></table>"
-                        }
-                    },
-                },
-            ],
-        }
-        (tmp_path / "crawl_manifest.json").write_text(json.dumps(manifest))
-
-        parser = RegistryPageParser(
-            mock_client,
-            prefetch_dir=tmp_path,
-            recursive_depth=1,
-        )
-        mock_client.get_page.return_value = {
-            "id": "88716675",
-            "title": "3.2 Các hệ thống",
-            "body": {"storage": {"value": ""}},
-        }
-        registry = await parser.parse_registry("88716667")
-
-        assert registry.checklist_page_id == "88716673"
-        assert registry.checklist_page_url == "http://confluence.digital.vn/pages/viewpage.action?pageId=88716673"
-        assert len(registry.projects) == 1
-        assert registry.projects[0].page_id == "proj_1"
-        assert registry.projects[0].page_url == "http://confluence.digital.vn/pages/viewpage.action?pageId=proj_1"
-        assert registry.diagnostics is not None
-        assert registry.diagnostics.network_fetches == 0
-        assert registry.diagnostics.fallback_fetches == 0
-        mock_client.get_child_pages.assert_not_called()
-        mock_client.get_page.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_parse_registry_prefetch_insufficient_coverage_hint(self, mock_client, tmp_path):
-        """Emit actionable hint when prefetch artifacts are too shallow for project discovery."""
-        import json
-
-        manifest = {
-            "root_page_id": "88716667",
-            "page": {"id": "88716667", "title": "Root"},
-            "child_pages": [
-                {"id": "88716673", "title": "3.1 Checklist đánh giá", "parent_id": "88716667"},
-                {"id": "88716675", "title": "3.2 Các hệ thống", "parent_id": "88716667"},
-            ],
-        }
-        (tmp_path / "crawl_manifest.json").write_text(json.dumps(manifest))
-
-        parser = RegistryPageParser(
-            mock_client,
-            prefetch_dir=tmp_path,
-            recursive_depth=1,
-        )
-        registry = await parser.parse_registry("88716667")
-
-        assert registry.projects == []
-        assert registry.diagnostics is not None
-        assert registry.diagnostics.prefetch_pages_indexed == 3
-        assert registry.diagnostics.prefetch_insufficient_coverage is True
-        assert registry.diagnostics.prefetch_hint is not None
-        assert "depth>=2" in registry.diagnostics.prefetch_hint
-
-    @pytest.mark.asyncio
-    async def test_parse_project_page_uses_prefetch_html_path_without_network(self, mock_client, tmp_path):
-        """Project parse should use prefetch html_path without get_page fallback."""
-        project_html = (
-            "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com/spec'>Spec</a></td></tr></table>"
-        )
-        project_html_path = tmp_path / "proj_1.html"
-        project_html_path.write_text(project_html, encoding="utf-8")
-
-        parser = RegistryPageParser(
-            mock_client,
-            prefetch_dir=tmp_path,
-            recursive_depth=1,
-        )
-        material = await parser.parse_project_page(
-            "proj_1",
-            "Project 1",
-            page_payload={
-                "page_id": "proj_1",
-                "title": "Project 1",
-                "page_url": "http://confluence.digital.vn/pages/viewpage.action?pageId=proj_1",
-                "html_path": str(project_html_path),
-            },
-        )
-
-        assert material is not None
-        assert material.page_id == "proj_1"
-        assert material.documents
-        assert material.documents[0].url == "http://example.com/spec"
-        mock_client.get_page.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_parse_registry_falls_back_to_network_when_no_prefetch(self, mock_client):
-        """Parser should fall back to network when no prefetch available."""
-        root_id = "88716667"
-
-        async def mock_get_child_pages(page_id, expand=None):
-            if page_id == root_id:
-                return [
-                    {"id": "88716675", "title": "3.2 Các hệ thống", "_links": {}},
-                ]
-            elif page_id == "88716675":
-                return [
-                    {
-                        "id": "proj_1",
-                        "title": "Project 1",
-                        "body": {
-                            "storage": {
-                                "value": "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com'>Link</a></td></tr></table>"
-                            }
-                        },
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": "/pages/viewpage.action?pageId=proj_1",
-                        },
-                    },
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = mock_get_child_pages
-
-        parser = RegistryPageParser(mock_client)  # No prefetch_dir
-        registry = await parser.parse_registry(root_id)
-
-        # Should have made network calls
-        assert mock_client.get_child_pages.call_count >= 1
-        assert len(registry.projects) == 1
-
-
-class TestAdaptiveDepthPhase35:
-    """Phase 35 adaptive-depth traversal tests."""
-
-    @staticmethod
-    def _require_adaptive_depth_support() -> None:
-        sig = inspect.signature(RegistryPageParser.__init__)
-        missing = [name for name in ("adaptive_depth", "adaptive_max_depth") if name not in sig.parameters]
-        if missing:
-            pytest.xfail(f"Phase 35 parser options not available yet: {', '.join(missing)}")
-
-    @staticmethod
-    def _hierarchy_html() -> str:
-        return (
-            "<table><tr><th>Vai trò</th><th>Loại tài liệu</th><th>Link</th></tr>"
-            "<tr><td>PO</td><td>1. Tài liệu BRD</td><td>"
-            "<a href='http://confluence.digital.vn/display/INS/BRD'>BRD</a>"
-            "</td></tr></table>"
-        )
-
-    @staticmethod
-    def _mock_hierarchy(mock_client: AsyncMock, html: str) -> None:
-        root_id = "88716667"
-        projects_root_id = "88716675"
-        department_id = "dep-1"
-        project_id = "proj-1"
-
-        async def _get_child_pages(page_id: str, expand: str | None = None):
-            if page_id == root_id:
-                return [
-                    {"id": "88716673", "title": "3.1 Checklist đánh giá", "_links": {}},
-                    {"id": projects_root_id, "title": "3.2 Các hệ thống", "_links": {}},
-                ]
-            if page_id == projects_root_id:
-                return [{"id": department_id, "title": "Checklist Department", "_links": {}}]
-            if page_id == department_id:
-                return [
-                    {
-                        "id": project_id,
-                        "title": "Project Alpha",
-                        "body": {"storage": {"value": html}},
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": "/pages/viewpage.action?pageId=proj-1",
-                        },
-                    }
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = _get_child_pages
-
-    @staticmethod
-    def _mock_mixed_hierarchy(mock_client: AsyncMock, html: str) -> None:
-        root_id = "88716667"
-        projects_root_id = "88716675"
-        department_id = "dep-1"
-        direct_project_id = "proj-direct"
-        nested_project_id = "proj-nested"
-
-        async def _get_child_pages(page_id: str, expand: str | None = None):
-            if page_id == root_id:
-                return [
-                    {"id": "88716673", "title": "3.1 Checklist đánh giá", "_links": {}},
-                    {"id": projects_root_id, "title": "3.2 Các hệ thống", "_links": {}},
-                ]
-            if page_id == projects_root_id:
-                return [
-                    {
-                        "id": direct_project_id,
-                        "title": "Project Direct",
-                        "body": {"storage": {"value": html}},
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": "/pages/viewpage.action?pageId=proj-direct",
-                        },
-                    },
-                    {"id": department_id, "title": "Department A", "_links": {}},
-                ]
-            if page_id == department_id:
-                return [
-                    {
-                        "id": nested_project_id,
-                        "title": "Project Nested",
-                        "body": {"storage": {"value": html}},
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": "/pages/viewpage.action?pageId=proj-nested",
-                        },
-                    }
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = _get_child_pages
-
-    @pytest.mark.asyncio
-    async def test_adaptive_depth_discovers_department_nested_project(self, mock_client):
-        self._require_adaptive_depth_support()
-        self._mock_hierarchy(mock_client, self._hierarchy_html())
-
-        parser = RegistryPageParser(
-            mock_client,
-            recursive_depth=1,
-            adaptive_depth=True,
-            adaptive_max_depth=3,
-        )
-        registry = await parser.parse_registry("88716667")
-
-        assert len(registry.projects) == 1
-        assert registry.projects[0].page_id == "proj-1"
-
-    @pytest.mark.asyncio
-    async def test_adaptive_depth_triggers_when_first_pass_has_zero_candidates(self, mock_client):
-        self._require_adaptive_depth_support()
-        root_id = "88716667"
-        checklist_id = "88716673"
-        projects_root_id = "88716675"
-        department_id = "dep-1"
-        project_id = "proj-1"
-        project_html = "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com/doc'>Doc</a></td></tr></table>"
-
-        async def _get_child_pages(page_id: str, expand: str | None = None):
-            if page_id == root_id:
-                return [
-                    {"id": checklist_id, "title": "3.1 Checklist đánh giá", "_links": {}},
-                    {"id": projects_root_id, "title": "3.2 Template container", "_links": {}},
-                ]
-            if page_id == projects_root_id:
-                return [{"id": department_id, "title": "", "_links": {}}]
-            if page_id == department_id:
-                return [
-                    {
-                        "id": project_id,
-                        "title": "3.2.1 CEP",
-                        "body": {"storage": {"value": project_html}},
-                        "_links": {
-                            "base": "http://confluence.digital.vn",
-                            "webui": "/pages/viewpage.action?pageId=proj-1",
-                        },
-                    }
-                ]
-            return []
-
-        mock_client.get_child_pages.side_effect = _get_child_pages
-
-        async def _get_page(page_id: str, expand: str | None = None):
-            if page_id == project_id:
-                return {
-                    "id": project_id,
-                    "title": "3.2.1 CEP",
-                    "body": {"storage": {"value": project_html}},
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=proj-1",
-                    },
-                }
-            return {
-                "id": page_id,
-                "title": f"Node {page_id}",
-                "body": {"storage": {"value": "<p>no links</p>"}},
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": f"/pages/viewpage.action?pageId={page_id}",
-                },
-            }
-
-        mock_client.get_page.side_effect = _get_page
-
-        parser = RegistryPageParser(
-            mock_client,
-            recursive_depth=1,
-            adaptive_depth=True,
-            adaptive_max_depth=3,
-        )
-        registry = await parser.parse_registry(root_id)
-
-        assert [project.page_id for project in registry.projects] == [project_id]
-        assert registry.diagnostics is not None
-        assert registry.diagnostics.adaptive_depth_applied is True
-        assert registry.diagnostics.adaptive_trigger_reason == "zero_projects_with_zero_candidates"
-
-    @pytest.mark.asyncio
-    async def test_adaptive_depth_can_be_disabled(self, mock_client):
-        self._require_adaptive_depth_support()
-        self._mock_hierarchy(mock_client, self._hierarchy_html())
-
-        parser = RegistryPageParser(
-            mock_client,
-            recursive_depth=1,
-            adaptive_depth=False,
-            adaptive_max_depth=3,
-        )
-        registry = await parser.parse_registry("88716667")
-
-        assert registry.projects == []
-
-    @pytest.mark.asyncio
-    async def test_adaptive_depth_respects_max_depth_bound(self, mock_client):
-        self._require_adaptive_depth_support()
-        self._mock_hierarchy(mock_client, self._hierarchy_html())
-
-        parser = RegistryPageParser(
-            mock_client,
-            recursive_depth=1,
-            adaptive_depth=True,
-            adaptive_max_depth=1,
-        )
-        registry = await parser.parse_registry("88716667")
-
-        assert registry.projects == []
-
-    @pytest.mark.asyncio
-    async def test_adaptive_depth_discovers_mixed_topology_without_duplicates(self, mock_client):
-        self._require_adaptive_depth_support()
-        self._mock_mixed_hierarchy(mock_client, self._hierarchy_html())
-
-        parser = RegistryPageParser(
-            mock_client,
-            recursive_depth=1,
-            adaptive_depth=True,
-            adaptive_max_depth=3,
-        )
-        registry = await parser.parse_registry("88716667")
-
-        assert sorted(project.page_id for project in registry.projects) == ["proj-direct", "proj-nested"]
-        assert registry.diagnostics is not None
-        assert registry.diagnostics.adaptive_depth_applied is True
-        assert registry.diagnostics.adaptive_trigger_reason == "partial_projects_with_no_links_signal"
-
-    @pytest.mark.asyncio
-    async def test_adaptive_depth_prefetch_nested_projects_without_network(self, mock_client, tmp_path):
-        self._require_adaptive_depth_support()
-        manifest = {
-            "root_page_id": "88716667",
-            "page": {"id": "88716667", "title": "Root"},
-            "child_pages": [
-                {"id": "88716673", "title": "3.1 Checklist đánh giá", "parent_id": "88716667"},
-                {"id": "88716675", "title": "3.2 Các hệ thống", "parent_id": "88716667"},
-                {"id": "dep-1", "title": "Department A", "parent_id": "88716675"},
-                {
-                    "id": "proj-1",
-                    "title": "Project 1",
-                    "parent_id": "dep-1",
-                    "body": {
-                        "storage": {
-                            "value": "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com/doc'>Doc</a></td></tr></table>"
-                        }
-                    },
-                },
-            ],
-        }
-        (tmp_path / "crawl_manifest.json").write_text(json.dumps(manifest))
-
-        parser = RegistryPageParser(
-            mock_client,
-            prefetch_dir=tmp_path,
-            recursive_depth=1,
-            adaptive_depth=True,
-            adaptive_max_depth=2,
-        )
-        registry = await parser.parse_registry("88716667")
-
-        assert [project.page_id for project in registry.projects] == ["proj-1"]
-        assert registry.diagnostics is not None
-        assert registry.diagnostics.adaptive_depth_applied is True
-        assert registry.diagnostics.network_fetches == 0
-        assert registry.diagnostics.fallback_fetches == 0
-        mock_client.get_child_pages.assert_not_called()
-        mock_client.get_page.assert_not_called()
-
-
-@pytest.mark.asyncio
-async def test_parse_registry_robust_when_projects_root_not_classified(mock_client):
-    """Fallback candidate roots should still find root->container->department->project."""
-    root_id = "88716667"
-    checklist_id = "88716673"
-    container_id = "container-x"
-    department_id = "dep-1"
-    project_id = "proj-1"
-    project_html = "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com/doc'>Doc</a></td></tr></table>"
-
-    async def _get_child_pages(page_id: str, expand: str | None = None):
-        if page_id == root_id:
-            return [
-                {"id": checklist_id, "title": "3.1 Checklist đánh giá", "_links": {}},
-                {"id": container_id, "title": "Các sản phẩm bảo hiểm", "_links": {}},
-            ]
-        if page_id == container_id:
-            return [{"id": department_id, "title": "Department A", "_links": {}}]
-        if page_id == department_id:
-            return [
-                {
-                    "id": project_id,
-                    "title": "Project Alpha",
-                    "body": {"storage": {"value": project_html}},
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=proj-1",
-                    },
-                }
-            ]
-        if page_id == checklist_id:
-            pytest.fail("Checklist branch should be pruned from project traversal")
-        return []
-
-    mock_client.get_child_pages.side_effect = _get_child_pages
-
-    parser = RegistryPageParser(
-        mock_client,
-        recursive_depth=2,
-    )
-    registry = await parser.parse_registry(root_id)
-
-    assert [project.page_id for project in registry.projects] == [project_id]
-    assert registry.checklist_page_id == checklist_id
-    assert mock_client.get_child_pages.call_count == 3
-
-
-@pytest.mark.asyncio
-async def test_adaptive_depth_reuses_network_cache_for_children_and_pages(mock_client):
-    """Adaptive pass should avoid re-downloading already fetched children/page bodies."""
-    root_id = "88716667"
-    projects_root_id = "88716675"
-    direct_project_id = "proj-direct"
-    empty_project_id = "proj-empty"
-    department_id = "dep-1"
-    nested_project_id = "proj-nested"
-    project_html = "<table><tr><th>Link</th></tr><tr><td><a href='http://example.com/doc'>Doc</a></td></tr></table>"
-
-    async def _get_child_pages(page_id: str, expand: str | None = None):
-        if page_id == root_id:
-            return [
-                {"id": "88716673", "title": "3.1 Checklist đánh giá", "_links": {}},
-                {"id": projects_root_id, "title": "3.2 Các hệ thống", "_links": {}},
-            ]
-        if page_id == projects_root_id:
-            return [
-                {"id": direct_project_id, "title": "Project Direct", "_links": {}},
-                {
-                    "id": empty_project_id,
-                    "title": "Project Empty",
-                    "body": {"storage": {"value": "<p>No documents yet</p>"}},
-                    "_links": {},
-                },
-                {
-                    "id": department_id,
-                    "title": "Department A",
-                    "body": {"storage": {"value": "<p>Department container</p>"}},
-                    "_links": {},
-                },
-            ]
-        if page_id == department_id:
-            return [
-                {
-                    "id": nested_project_id,
-                    "title": "Project Nested",
-                    "body": {"storage": {"value": project_html}},
-                    "_links": {
-                        "base": "http://confluence.digital.vn",
-                        "webui": "/pages/viewpage.action?pageId=proj-nested",
-                    },
-                }
-            ]
-        return []
-
-    async def _get_page(page_id: str, expand: str | None = None):
-        if page_id == direct_project_id:
-            return {
-                "id": direct_project_id,
-                "title": "Project Direct",
-                "body": {"storage": {"value": project_html}},
-                "_links": {
-                    "base": "http://confluence.digital.vn",
-                    "webui": "/pages/viewpage.action?pageId=proj-direct",
-                },
-            }
-        return {"id": page_id, "title": page_id, "body": {"storage": {"value": ""}}, "_links": {}}
-
-    mock_client.get_child_pages.side_effect = _get_child_pages
-    mock_client.get_page.side_effect = _get_page
-
-    parser = RegistryPageParser(
-        mock_client,
-        recursive_depth=1,
-        adaptive_depth=True,
-        adaptive_max_depth=2,
-    )
-    registry = await parser.parse_registry(root_id)
-
-    assert sorted(project.page_id for project in registry.projects) == [direct_project_id, nested_project_id]
-    assert registry.diagnostics is not None
-    assert registry.diagnostics.adaptive_depth_applied is True
-    assert mock_client.get_page.call_count == 1
-    parent_call_counts = Counter(str(call.args[0]) for call in mock_client.get_child_pages.await_args_list)
-    assert parent_call_counts[root_id] == 1
-    assert parent_call_counts[projects_root_id] == 1