@ngocsangairvds/vsaf 3.1.27 → 3.2.1

package/tools/vds-scripts/confluence_orchestrator/src/confluence_orchestrator/crawl_tree.py

@@ -0,0 +1,1835 @@
+"""Confluence tree crawling and on-disk export helpers.
+
+This module is intentionally dependency-light (std lib + BeautifulSoup) so the output
+can be used as input for downstream LLM/document analysis pipelines.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import time
+import zipfile
+from collections.abc import Callable
+from concurrent.futures import Future, ThreadPoolExecutor
+from dataclasses import dataclass, field
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from typing import Any
+from urllib.parse import parse_qs, unquote, urlparse
+
+from bs4 import BeautifulSoup
+
+from .http import ConfluenceClient
+
+_JIRA_KEY_RE = re.compile(r"\b[A-Z][A-Z0-9]+-\d+\b")
+_MIME_SUFFIX_MAP: dict[str, str] = {
+    "application/json": ".json",
+    "application/msword": ".doc",
+    "application/pdf": ".pdf",
+    "application/vnd.jgraph.mxfile": ".drawio",
+    "application/vnd.ms-excel": ".xls",
+    "application/vnd.ms-powerpoint": ".ppt",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+    "image/gif": ".gif",
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/svg+xml": ".svg",
+    "text/csv": ".csv",
+    "text/plain": ".txt",
+}
+def _now_iso() -> str:
+    return datetime.now(UTC).isoformat()
+
+
+def _sha256_bytes(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def _sha256_text(text: str) -> str:
+    return _sha256_bytes(text.encode("utf-8"))
+
+
+def _parse_iso_timestamp(value: str | None) -> datetime | None:
+    if not value:
+        return None
+    cleaned = value.strip()
+    if not cleaned:
+        return None
+    if cleaned.endswith("Z"):
+        cleaned = f"{cleaned[:-1]}+00:00"
+    try:
+        parsed = datetime.fromisoformat(cleaned)
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=UTC)
+    return parsed.astimezone(UTC)
+
+
+def _safe_filename(name: str) -> str:
+    # Preserve unicode for VN titles, but remove path separators + control chars.
+    cleaned = name.replace("/", "-").replace("\\", "-").replace("\0", "")
+    cleaned = re.sub(r"[\r\n\t]+", " ", cleaned).strip()
+    return cleaned or "untitled"
+
+
+def _normalise_suffix(value: str) -> str:
+    cleaned = (value or "").strip().lower()
+    if not cleaned:
+        return ""
+    return cleaned if cleaned.startswith(".") else f".{cleaned}"
+
+
+def _guess_attachment_suffix(attachment: dict[str, Any]) -> str | None:
+    extensions = attachment.get("extensions") or {}
+    metadata = attachment.get("metadata") or {}
+
+    if isinstance(extensions, dict):
+        ext = extensions.get("fileExtension") or extensions.get("file_extension")
+        if isinstance(ext, str) and ext.strip():
+            normalised = _normalise_suffix(ext)
+            return normalised if normalised else None
+
+    media_type = None
+    if isinstance(extensions, dict):
+        media_type = extensions.get("mediaType") or extensions.get("media_type")
+    if not media_type and isinstance(metadata, dict):
+        media_type = metadata.get("mediaType") or metadata.get("media_type")
+
+    if isinstance(media_type, str) and media_type.strip():
+        mapped = _MIME_SUFFIX_MAP.get(media_type.strip().lower())
+        if mapped:
+            return mapped
+    return None
+
+
+def _safe_attachment_filename(attachment_id: str, title: str, *, fallback_suffix: str | None = None) -> str:
+    safe_title = _safe_filename(title)
+    path = Path(safe_title)
+    stem = path.stem or "attachment"
+    suffix = path.suffix
+    if not suffix and fallback_suffix:
+        suffix = _normalise_suffix(fallback_suffix)
+
+    # Keep filenames under typical filesystem limits (255 bytes). We preserve the
+    # attachment id prefix for stability and trim the human title if needed.
+    max_stem_length = 180
+    if len(stem) > max_stem_length:
+        stem = stem[:max_stem_length].rstrip()
+    safe_title = f"{stem}{suffix}"
+    return f"{attachment_id}_{safe_title}"
+
+
+def _escape_cql(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def resolve_page_ref(page_ref: str, http: ConfluenceClient) -> str:
+    """Resolve a page reference to a numeric page ID.
+
+    Supported forms:
+    - numeric ID: "74014717"
+    - viewpage: ".../pages/viewpage.action?pageId=74014717"
+    - display URL: ".../display/TDOV/13.02.10.+BRD"
+    """
+    page_ref = (page_ref or "").strip()
+    if not page_ref:
+        raise ValueError("page_ref is empty")
+
+    if page_ref.isdigit():
+        return page_ref
+
+    parsed = urlparse(page_ref)
+    if parsed.query:
+        qs = parse_qs(parsed.query)
+        page_ids = qs.get("pageId") or qs.get("pageid")
+        if page_ids and page_ids[0].isdigit():
+            return page_ids[0]
+
+    # /display/<SPACE>/<TITLE>
+    match = re.search(r"/display/([^/]+)/(.+)$", parsed.path or "")
+    if match:
+        space = unquote(match.group(1))
+        # Confluence "display" URLs often encode spaces as '+'
+        title = unquote(match.group(2)).replace("+", " ").strip()
+        cql = f'space="{_escape_cql(space)}" and title="{_escape_cql(title)}" and type=page'
+        result = http.search_cql(cql, limit=5)
+        results = result.get("results", []) if isinstance(result, dict) else []
+        for item in results:
+            if not isinstance(item, dict):
+                continue
+            # Confluence CQL results usually wrap content under `content`.
+            raw_id = item.get("id")
+            if raw_id is None and isinstance(item.get("content"), dict):
+                raw_id = item["content"].get("id")
+            if raw_id is not None and str(raw_id).isdigit():
+                return str(raw_id)
+
+        raise ValueError(f"Unable to resolve display URL to page ID (space={space!r}, title={title!r})")
+
+    raise ValueError(f"Unsupported page reference: {page_ref}")
+
+
+@dataclass(slots=True)
+class CrawlOptions:
+    max_depth: int = 3
+    include_attachments: bool = True
+    emit_corpus: bool = False
+    emit_link_graph: bool = False
+    emit_tables: bool = False
+    emit_mentions: bool = False
+    body_format: str = "view"
+    chunk_max_chars: int | None = 4000
+    resume: bool = False
+    max_nodes: int | None = 500
+    bundle: bool = False
+    page_concurrency: int = 5
+    staged_mode: str = "off"
+    incremental_cql: bool = True
+    incremental_overlap_minutes: int = 5
+    full_reconciliation_interval_days: int = 7
+    rate_limit_budget: int = 50_000
+    runtime_event_sink: Callable[[str, dict[str, Any]], None] | None = None
+
+
+def _emit_runtime_event(options: CrawlOptions, event: str, **payload: Any) -> None:
+    if not callable(options.runtime_event_sink):
+        return
+    try:
+        options.runtime_event_sink(event, payload)
+    except Exception:
+        return
+
+
+def _create_bundle_zip(output_dir: Path, root_page_id: str, manifest_path: Path) -> Path:
+    """Create a zip bundle of all crawl artifacts for offline handoff (TSK-189)."""
+    timestamp = datetime.now(UTC).strftime("%Y%m%d_%H%M%S")
+    bundle_name = f"crawl_bundle_{root_page_id}_{timestamp}.zip"
+    bundle_path = output_dir / bundle_name
+
+    with zipfile.ZipFile(bundle_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        # Add all HTML files
+        for html_file in output_dir.glob("*.html"):
+            zf.write(html_file, html_file.name)
+
+        # Add attachments directory
+        attachments_dir = output_dir / "attachments"
+        if attachments_dir.exists():
+            for att_file in attachments_dir.iterdir():
+                if att_file.is_file():
+                    zf.write(att_file, f"attachments/{att_file.name}")
+
+        # Add artifact files
+        artifact_files = [
+            "corpus.jsonl",
+            "link-graph.json",
+            "tables.jsonl",
+            "mentions.jsonl",
+            "crawl_state.json",
+        ]
+        for artifact_name in artifact_files:
+            artifact_path = output_dir / artifact_name
+            if artifact_path.exists():
+                zf.write(artifact_path, artifact_name)
+
+        # Add manifest
+        if manifest_path.exists():
+            zf.write(manifest_path, manifest_path.name)
+
+    return bundle_path
+
+
+@dataclass(slots=True)
+class CrawlState:
+    """Persistent crawl state for resume/incremental crawling (TSK-188)."""
+
+    root_page_id: str
+    body_format: str
+    visited_pages: dict[str, dict[str, Any]]  # page_id -> {version, html_sha256, visited_at}
+    pending_queue: list[tuple[str, str | None, int]]  # [(page_id, parent_id, depth), ...]
+    started_at: str
+    last_updated_at: str
+    completed: bool = False
+    last_sync_timestamp: str | None = None
+    last_full_reconciliation_timestamp: str | None = None
+    run_diagnostics: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize state to JSON-compatible dict."""
+        return {
+            "root_page_id": self.root_page_id,
+            "body_format": self.body_format,
+            "visited_pages": self.visited_pages,
+            "pending_queue": [list(item) for item in self.pending_queue],
+            "started_at": self.started_at,
+            "last_updated_at": self.last_updated_at,
+            "completed": self.completed,
+            "last_sync_timestamp": self.last_sync_timestamp,
+            "last_full_reconciliation_timestamp": self.last_full_reconciliation_timestamp,
+            "run_diagnostics": self.run_diagnostics,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> CrawlState:
+        """Deserialize state from JSON-compatible dict."""
+        return cls(
+            root_page_id=data["root_page_id"],
+            body_format=data.get("body_format", "view"),
+            visited_pages=data.get("visited_pages", {}),
+            pending_queue=[tuple(item) for item in data.get("pending_queue", [])],
+            started_at=data.get("started_at", _now_iso()),
+            last_updated_at=data.get("last_updated_at", _now_iso()),
+            completed=data.get("completed", False),
+            last_sync_timestamp=data.get("last_sync_timestamp"),
+            last_full_reconciliation_timestamp=data.get("last_full_reconciliation_timestamp"),
+            run_diagnostics=data.get("run_diagnostics", {}),
+        )
+
+    def is_page_unchanged(self, page_id: str, version: int | None, html_sha256: str | None) -> bool:
+        """Check if a page is unchanged since last crawl."""
+        if page_id not in self.visited_pages:
+            return False
+        prev = self.visited_pages[page_id]
+        prev_version = prev.get("version")
+        prev_hash = prev.get("html_sha256")
+        # If both version and hash match, page is unchanged
+        if prev_version is not None and version is not None and prev_version == version:
+            return True
+        if prev_hash is not None and html_sha256 is not None and prev_hash == html_sha256:
+            return True
+        return False
+
+    def record_page(self, page_id: str, version: int | None, html_sha256: str | None) -> None:
+        """Record a visited page."""
+        self.visited_pages[page_id] = {
+            "version": version,
+            "html_sha256": html_sha256,
+            "visited_at": _now_iso(),
+        }
+        self.last_updated_at = _now_iso()
+
+
+@dataclass(slots=True)
+class _FetchedPage:
+    page_id: str
+    parent_id: str | None
+    depth: int
+    status: str  # fetched|unchanged|error
+    page_payload: dict[str, Any] | None = None
+    version_payload: dict[str, Any] | None = None
+    children: list[tuple[str, str | None, int]] = field(default_factory=list)
+    error: str | None = None
+
+
+def _load_crawl_state(state_path: Path) -> CrawlState | None:
+    """Load crawl state from disk if it exists."""
+    if not state_path.exists():
+        return None
+    try:
+        data = json.loads(state_path.read_text(encoding="utf-8"))
+        return CrawlState.from_dict(data)
+    except (json.JSONDecodeError, KeyError, TypeError):
+        return None
+
+
+def _save_crawl_state(state: CrawlState, state_path: Path) -> None:
+    """Persist crawl state to disk."""
+    state.last_updated_at = _now_iso()
+    state_path.write_text(json.dumps(state.to_dict(), ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def _normalise_body_format(value: str | None) -> str:
+    normalised = (value or "view").strip().lower().replace("-", "_")
+    if normalised in {"view", "storage", "export_view"}:
+        return normalised
+    raise ValueError(f"Unsupported body format: {value!r} (expected: view|export_view|storage)")
+
+
+def _normalise_page_concurrency(value: int | None) -> int:
+    if value is None:
+        return 5
+    return max(1, int(value))
+
+
+def _normalise_staged_mode(value: str | None) -> str:
+    normalised = (value or "off").strip().lower().replace("-", "_")
+    if normalised in {"off", "structure_first"}:
+        return normalised
+    raise ValueError(f"Unsupported staged mode: {value!r} (expected: off|structure_first)")
+
+
+def _split_text_preserving_words(text: str, max_chars: int) -> list[str]:
+    """Split a long string into <= max_chars chunks, preferring whitespace boundaries."""
+    stripped = (text or "").strip()
+    if not stripped:
+        return []
+    if max_chars <= 0:
+        return [stripped]
+    if len(stripped) <= max_chars:
+        return [stripped]
+
+    words = stripped.split()
+    parts: list[str] = []
+    current: list[str] = []
+    current_len = 0
+
+    def flush() -> None:
+        nonlocal current, current_len
+        if not current:
+            return
+        parts.append(" ".join(current))
+        current = []
+        current_len = 0
+
+    for word in words:
+        if not current:
+            current = [word]
+            current_len = len(word)
+        elif current_len + 1 + len(word) <= max_chars:
+            current.append(word)
+            current_len += 1 + len(word)
+        else:
+            flush()
+            if len(word) <= max_chars:
+                current = [word]
+                current_len = len(word)
+            else:
+                # Pathological case: a single token exceeds max_chars; hard-split.
+                for offset in range(0, len(word), max_chars):
+                    parts.append(word[offset : offset + max_chars])
+
+    flush()
+    return parts
+
+
+def _pack_segments(segments: list[str], max_chars: int) -> list[str]:
+    if max_chars <= 0:
+        joined = "\n".join([seg for seg in segments if seg.strip()]).strip()
+        return [joined] if joined else []
+
+    packed: list[str] = []
+    current: list[str] = []
+    current_len = 0
+
+    def flush() -> None:
+        nonlocal current, current_len
+        if not current:
+            return
+        packed.append("\n".join(current).strip())
+        current = []
+        current_len = 0
+
+    for seg in segments:
+        seg = (seg or "").strip()
+        if not seg:
+            continue
+        sep_len = 1 if current else 0  # newline
+        if not current or current_len + sep_len + len(seg) <= max_chars:
+            if current:
+                current_len += 1
+            current.append(seg)
+            current_len += len(seg)
+            continue
+
+        flush()
+        current = [seg]
+        current_len = len(seg)
+
+    flush()
+    return [chunk for chunk in packed if chunk.strip()]
+
+
+def _extract_target_page_id(target_url: str | None) -> str | None:
+    if not target_url:
+        return None
+
+    parsed = urlparse(target_url)
+    if parsed.query:
+        qs = parse_qs(parsed.query)
+        for key, values in qs.items():
+            if key.lower() != "pageid" or not values:
+                continue
+            candidate = values[0]
+            if isinstance(candidate, str) and candidate.isdigit():
+                return candidate
+
+    match = re.search(r"/pages/(\d+)(?:/|$)", parsed.path or "")
+    if match:
+        return match.group(1)
+    return None
+
+
+def _classify_target_type(target_url: str | None) -> str | None:
+    if not target_url:
+        return None
+
+    url = target_url.strip()
+    if not url:
+        return None
+    if url.startswith("mailto:"):
+        return "email"
+
+    parsed = urlparse(url)
+    host = (parsed.netloc or "").lower()
+    path = parsed.path or ""
+
+    if "/display/" in path or "viewpage.action" in path or re.search(r"/pages/\d+(?:/|$)", path):
+        return "confluence_page"
+    if "jira" in host or "/browse/" in path:
+        return "jira"
+    if "bitbucket" in host or "/scm/" in path:
+        return "bitbucket"
+    if parsed.scheme in {"http", "https"}:
+        return "external"
+    return "external"
+
+
+def _extract_jira_key_from_url(url: str) -> str | None:
+    parsed = urlparse(url)
+    match = re.search(r"/browse/([A-Z][A-Z0-9]+-\d+)", parsed.path or "")
+    if match:
+        return match.group(1)
+    return None
+
+
+def _extract_links(html: str, *, base_url: str | None = None) -> list[dict[str, Any]]:
+    soup = BeautifulSoup(html, "html.parser")
+    links: list[dict[str, Any]] = []
+    for a in soup.find_all("a"):
+        href = a.get("href")
+        if not href:
+            continue
+        href = str(href).strip()
+        if not href:
+            continue
+        text = a.get_text(" ", strip=True) or None
+        links.append({"href": href, "text": text})
+    if not base_url:
+        return links
+
+    normalized: list[dict[str, Any]] = []
+    base = base_url.rstrip("/")
+    for entry in links:
+        href = entry["href"]
+        if href.startswith("#"):
+            continue
+        if href.startswith(("http://", "https://")):
+            url = href
+        elif href.startswith("/"):
+            url = f"{base}{href}"
+        else:
+            # best-effort: keep as-is (could be relative to current page)
+            url = href
+        # Drop fragments for canonicalization
+        parsed = urlparse(url)
+        url = parsed._replace(fragment="").geturl()
+        normalized.append({"url": url, "text": entry.get("text")})
+    return normalized
+
+
+def _chunk_html_by_headings(html: str, *, max_chars: int | None = None) -> list[dict[str, Any]]:
+    """Chunk HTML into heading-scoped blocks for JSONL corpus output."""
+    soup = BeautifulSoup(html, "html.parser")
+
+    chunks: list[dict[str, Any]] = []
+    heading_stack: list[str] = []
+    buffer: list[str] = []
+
+    def flush() -> None:
+        nonlocal buffer
+        lines = [line for line in buffer if line.strip()]
+        buffer = []
+        if not lines:
+            return
+
+        segments: list[str] = []
+        max_limit = max_chars if isinstance(max_chars, int) and max_chars > 0 else None
+        for line in lines:
+            if max_limit and len(line) > max_limit:
+                segments.extend(_split_text_preserving_words(line, max_limit))
+            else:
+                segments.append(line.strip())
+
+        if max_limit is None:
+            text = "\n".join([seg for seg in segments if seg.strip()]).strip()
+            if text:
+                chunks.append({"heading_path": list(heading_stack), "text": text, "ordinal": 0})
+            return
+
+        for ordinal, text in enumerate(_pack_segments(segments, max_limit)):
+            chunks.append({"heading_path": list(heading_stack), "text": text, "ordinal": ordinal})
+
+    for el in soup.find_all(["h1", "h2", "h3", "h4", "h5", "h6", "p", "li", "pre"]):
+        name = el.name.lower()
+        if name.startswith("h"):
+            flush()
+            level = int(name[1])
+            title = el.get_text(" ", strip=True)
+            if not title:
+                continue
+            heading_stack[:] = heading_stack[: max(0, level - 1)]
+            heading_stack.append(title)
+            continue
+
+        text = el.get_text(" ", strip=True)
+        if not text:
+            continue
+        buffer.append(text)
+
+    flush()
+    return chunks
+
+
+def _extract_tables(html: str) -> list[dict[str, Any]]:
+    soup = BeautifulSoup(html, "html.parser")
+    extracted: list[dict[str, Any]] = []
+
+    for index, table in enumerate(soup.find_all("table")):
+        headers: list[str] | None = None
+        rows: list[list[str]] = []
+
+        # Prefer explicit <thead> headers when present.
+        thead = table.find("thead")
+        if thead:
+            head_row = thead.find("tr")
+            if head_row:
+                header_cells = head_row.find_all(["th", "td"])
+                header_texts = [cell.get_text(" ", strip=True) for cell in header_cells]
+                headers = [h for h in header_texts if h]
+
+        # Extract all row cells.
+        for tr in table.find_all("tr"):
+            cells = tr.find_all(["th", "td"])
+            if not cells:
+                continue
+            row = [cell.get_text(" ", strip=True) for cell in cells]
+            row = [cell for cell in row if cell]
+            if row:
+                rows.append(row)
+
+        # If we did not find a <thead>, treat the first row with <th> as headers.
+        if headers is None and rows:
+            first_tr = table.find("tr")
+            if first_tr and first_tr.find("th"):
+                headers = rows[0]
+                rows = rows[1:]
+
+        extracted.append(
+            {
+                "table_index": index,
+                "headers": headers,
+                "rows": rows,
+                "row_count": len(rows),
+                "col_count": max((len(row) for row in rows), default=0),
+            }
+        )
+
+    return extracted
+
+
+def _extract_mentions(html: str, *, base_url: str | None = None) -> list[dict[str, Any]]:
+    soup = BeautifulSoup(html, "html.parser")
+    extracted: list[dict[str, Any]] = []
+
+    # 1) Link-based mentions (already normalized by base_url when provided).
+    for link in _extract_links(html, base_url=base_url):
+        url = str(link.get("url") or "").strip()
+        if not url:
+            continue
+
+        mention_type = _classify_target_type(url)
+        if mention_type == "confluence_page":
+            value = _extract_target_page_id(url) or url
+        elif mention_type == "jira":
+            value = _extract_jira_key_from_url(url) or url
+        elif mention_type == "email":
+            value = url.removeprefix("mailto:").strip() or url
+        else:
+            value = url
+
+        extracted.append(
+            {
+                "type": mention_type or "external",
+                "value": value,
+                "url": url,
+                "anchor_text": link.get("text"),
+                "source": "link",
+            }
+        )
+
+    # 2) Plain-text Jira keys (best-effort).
+    plain_text = soup.get_text(" ", strip=True)
+    for key in sorted(set(_JIRA_KEY_RE.findall(plain_text or ""))):
+        extracted.append(
+            {
+                "type": "jira_key",
+                "value": key,
+                "url": None,
+                "anchor_text": None,
+                "source": "text",
+            }
+        )
+
+    # Deduplicate mentions by stable key and keep deterministic ordering.
+    seen: set[tuple[str, str, str | None]] = set()
+    unique: list[dict[str, Any]] = []
+    for entry in extracted:
+        mention_type = str(entry.get("type") or "").strip() or "external"
+        value = str(entry.get("value") or "").strip()
+        url = entry.get("url")
+        url = str(url).strip() if isinstance(url, str) else None
+        if not value:
+            continue
+        key = (mention_type, value, url)
+        if key in seen:
+            continue
+        seen.add(key)
+        unique.append({**entry, "type": mention_type, "value": value, "url": url})
+
+    unique.sort(key=lambda m: (m.get("type") or "", m.get("value") or "", m.get("url") or ""))
+    return unique
+
+
+def crawl_tree_to_disk(
+    *,
+    http: ConfluenceClient,
+    root_ref: str,
+    output_dir: Path,
+    options: CrawlOptions,
+    manifest_path: Path | None = None,
+) -> dict[str, Any]:
+    """Crawl a Confluence page tree and download content/attachments to disk.
+
+    Supports resume/incremental crawling (TSK-188):
+    - resume=True: Load state from previous run, skip unchanged pages
+    - max_nodes: Limit total pages processed (safety for large trees)
+    """
+    body_format = _normalise_body_format(options.body_format)
+    page_concurrency = _normalise_page_concurrency(options.page_concurrency)
+    staged_mode = _normalise_staged_mode(options.staged_mode)
+    use_structure_first = staged_mode == "structure_first"
+    chunk_max_chars = options.chunk_max_chars if isinstance(options.chunk_max_chars, int) else None
+    resolved_root_id = resolve_page_ref(root_ref, http)
+    output_dir = output_dir.resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+    attachments_dir = output_dir / "attachments"
+    attachments_dir.mkdir(exist_ok=True)
+    resolved_manifest_path = manifest_path or (output_dir / "crawl_manifest.json")
+
+    def _meta_from_existing_html(
+        *,
+        page_id: str,
+        parent_id: str | None,
+        depth: int,
+        page_payload: dict[str, Any] | None,
+    ) -> dict[str, Any]:
+        html_candidates = sorted(output_dir.glob(f"{page_id}_*.html"))
+        html_path = html_candidates[0] if html_candidates else None
+        title = None
+        page_url = None
+        page_version = None
+        page_updated = None
+        space_key = None
+        if isinstance(page_payload, dict):
+            raw_title = page_payload.get("title")
+            if raw_title:
+                title = str(raw_title)
+            links = page_payload.get("_links")
+            if isinstance(links, dict):
+                base_url = str(links.get("base") or "")
+                web_ui = str(links.get("webui") or "")
+                page_url = f"{base_url}{web_ui}" if base_url and web_ui else None
+            version = page_payload.get("version")
+            if isinstance(version, dict):
+                page_version = version.get("number")
+                page_updated = version.get("when")
+            space = page_payload.get("space")
+            if isinstance(space, dict):
+                raw_space = space.get("key")
+                if raw_space:
+                    space_key = str(raw_space)
+        if title is None and html_path is not None:
+            title = html_path.stem.split("_", 1)[1] if "_" in html_path.stem else html_path.stem
+
+        meta: dict[str, Any] = {
+            "page_id": page_id,
+            "title": title,
+            "page_url": page_url,
+            "parent_id": parent_id,
+            "depth": depth,
+            "status": "downloaded" if html_path is not None else "unchanged",
+            "html_path": str(html_path) if html_path is not None else None,
+            "html_sha256": None,
+            "html_size_bytes": None,
+            "source_format": "html-view",
+            "space_key": space_key,
+            "page_version": page_version,
+            "page_updated": page_updated,
+            "ancestor_ids": [],
+            "ancestor_titles": [],
+            "error": None,
+        }
+        if html_path is not None and html_path.exists():
+            html_bytes = html_path.read_bytes()
+            meta["html_sha256"] = _sha256_bytes(html_bytes)
+            meta["html_size_bytes"] = html_path.stat().st_size
+        return meta
+
+    previous_page_meta_by_id: dict[str, dict[str, Any]] = {}
+    previous_attachments_by_page: dict[str, list[dict[str, Any]]] = {}
+    if options.resume and resolved_manifest_path.exists():
+        try:
+            loaded = json.loads(resolved_manifest_path.read_text(encoding="utf-8"))
+            if isinstance(loaded, dict):
+                root_meta = loaded.get("page")
+                if isinstance(root_meta, dict):
+                    root_id = root_meta.get("page_id")
+                    if root_id:
+                        previous_page_meta_by_id[str(root_id)] = root_meta
+                raw_children = loaded.get("child_pages")
+                if isinstance(raw_children, list):
+                    for child in raw_children:
+                        if not isinstance(child, dict):
+                            continue
+                        child_id = child.get("page_id")
+                        if child_id:
+                            previous_page_meta_by_id[str(child_id)] = child
+                raw_attachments = loaded.get("attachments")
+                if isinstance(raw_attachments, list):
+                    for attachment in raw_attachments:
+                        if not isinstance(attachment, dict):
+                            continue
+                        page_id = attachment.get("page_id")
+                        if page_id is None:
+                            continue
+                        previous_attachments_by_page.setdefault(str(page_id), []).append(attachment)
+        except Exception:
+            previous_page_meta_by_id = {}
+            previous_attachments_by_page = {}
+
+    previous_corpus_chunks_by_page: dict[str, list[dict[str, Any]]] = {}
+    if options.resume and options.emit_corpus:
+        previous_corpus_path = output_dir / "corpus.jsonl"
+        if previous_corpus_path.exists():
+            try:
+                with previous_corpus_path.open("r", encoding="utf-8") as previous_corpus_fp:
+                    for raw_line in previous_corpus_fp:
+                        line = raw_line.strip()
+                        if not line:
+                            continue
+                        try:
+                            payload = json.loads(line)
+                        except json.JSONDecodeError:
+                            continue
+                        if not isinstance(payload, dict):
+                            continue
+                        page_id = str(payload.get("page_id") or "").strip()
+                        if not page_id:
+                            continue
+                        previous_corpus_chunks_by_page.setdefault(page_id, []).append(payload)
+            except Exception:
+                previous_corpus_chunks_by_page = {}
+
+    # State file for resume support (TSK-188)
+    state_path = output_dir / "crawl_state.json"
+    crawl_state: CrawlState | None = None
+    skipped_unchanged: int = 0
+    skipped_already_visited: int = 0
+    nodes_processed: int = 0
+    pages_fetched: int = 0
+    pages_failed: int = 0
+    termination_reason = "queue_exhausted"
+    unchanged_page_ids: set[str] = set()
+
+    # Track previously visited pages for skip-unchanged logic (separate from current run)
+    previous_visited: dict[str, dict[str, Any]] = {}
+
+    if options.resume:
+        crawl_state = _load_crawl_state(state_path)
+        if crawl_state is not None:
+            # Validate state matches current crawl parameters
+            if crawl_state.root_page_id != resolved_root_id:
+                # Root changed, start fresh
+                crawl_state = None
+            elif crawl_state.body_format != body_format:
+                # Format changed, start fresh
+                crawl_state = None
+            elif crawl_state.completed:
+                # Previous crawl completed - keep visited_pages for skip-unchanged checks
+                # but reset queue to re-crawl from root
+                previous_visited = dict(crawl_state.visited_pages)
+                previous_sync_timestamp = crawl_state.last_sync_timestamp
+                previous_full_reconciliation_timestamp = crawl_state.last_full_reconciliation_timestamp
+                crawl_state = CrawlState(
+                    root_page_id=resolved_root_id,
+                    body_format=body_format,
+                    visited_pages=previous_visited,  # Keep for version checks
+                    pending_queue=[(resolved_root_id, None, 0)],
+                    started_at=_now_iso(),
+                    last_updated_at=_now_iso(),
+                    completed=False,
+                    last_sync_timestamp=previous_sync_timestamp,
+                    last_full_reconciliation_timestamp=previous_full_reconciliation_timestamp,
+                )
+            else:
+                # Incomplete crawl - restore visited pages for skip logic
+                previous_visited = dict(crawl_state.visited_pages)
+
+    # Initialize state if needed
+    if crawl_state is None:
+        crawl_state = CrawlState(
+            root_page_id=resolved_root_id,
+            body_format=body_format,
+            visited_pages={},
+            pending_queue=[(resolved_root_id, None, 0)],
+            started_at=_now_iso(),
+            last_updated_at=_now_iso(),
+            completed=False,
+        )
+
+    # For resume mode, track pages visited in current session to avoid re-processing
+    visited_pages: set[str] = set()
+    downloaded_attachments: set[str] = set()
+
+    queue: list[tuple[str, str | None, int]] = list(crawl_state.pending_queue)
+    discovered_page_ids: set[str] = {resolved_root_id}
+    for queued_page_id, _, _ in queue:
+        discovered_page_ids.add(queued_page_id)
+
+    root_meta: dict[str, Any] | None = None
+    child_pages: list[dict[str, Any]] = []
+    attachments: list[dict[str, Any]] = []
+    link_edges: list[dict[str, Any]] = []
+    corpus_chunks: list[dict[str, Any]] = []
+    tables: list[dict[str, Any]] = []
+    mentions: list[dict[str, Any]] = []
+    telemetry_getter = getattr(http, "get_runtime_telemetry", None)
+    configure_rate_limit_budget = getattr(http, "configure_rate_limit_budget", None)
+    if callable(configure_rate_limit_budget):
+        try:
+            configure_rate_limit_budget(int(options.rate_limit_budget))
+        except Exception:
+            pass
+
+    def _children_for(page_id: str, depth: int) -> list[tuple[str, str | None, int]]:
+        if options.max_depth >= 0 and depth >= options.max_depth:
+            return []
+        try:
+            child_payload = http.get_child_pages(page_id)
+        except Exception:
+            return []
+        collected: list[tuple[str, str | None, int]] = []
+        for child in child_payload:
+            if not isinstance(child, dict):
+                continue
+            child_id = child.get("id")
+            if child_id is None:
+                continue
+            collected.append((str(child_id), page_id, depth + 1))
+        return collected
+
+    body_expands: list[str]
+    if body_format == "export_view":
+        body_expands = ["body.export_view", "body.view", "body.storage"]
+    elif body_format == "storage":
+        body_expands = ["body.storage", "body.view"]
+    else:
+        body_expands = ["body.view", "body.storage"]
+
+    def _fetch_page(node: tuple[str, str | None, int]) -> _FetchedPage:
+        page_id, parent_id, depth = node
+        children: list[tuple[str, str | None, int]] = []
+        children_future: Future[list[tuple[str, str | None, int]]] | None = None
+        children_executor: ThreadPoolExecutor | None = None
+        if not use_structure_first and (options.max_depth < 0 or depth < options.max_depth):
+            children_executor = ThreadPoolExecutor(max_workers=1)
+            children_future = children_executor.submit(_children_for, page_id, depth)
+
+        try:
+            if options.resume and page_id in crawl_state.visited_pages:
+                try:
+                    version_check = http.get_page(page_id, expand=["version"])
+                except Exception as exc:
+                    if children_future is not None:
+                        children = children_future.result()
+                    return _FetchedPage(
+                        page_id=page_id,
+                        parent_id=parent_id,
+                        depth=depth,
+                        status="error",
+                        error=str(exc),
+                        children=children,
+                    )
+                check_version = (version_check.get("version") or {}).get("number")
+                if crawl_state.is_page_unchanged(page_id, check_version, None):
+                    if children_future is not None:
+                        children = children_future.result()
+                    return _FetchedPage(
+                        page_id=page_id,
+                        parent_id=parent_id,
+                        depth=depth,
+                        status="unchanged",
+                        version_payload=version_check,
+                        children=children,
+                    )
+
+            try:
+                page_payload = http.get_page(page_id, expand=[*body_expands, "version", "space", "ancestors"])
+            except Exception as exc:
+                if children_future is not None:
+                    children = children_future.result()
+                return _FetchedPage(
+                    page_id=page_id,
+                    parent_id=parent_id,
+                    depth=depth,
+                    status="error",
+                    error=str(exc),
+                    children=children,
+                )
+
+            if children_future is not None:
+                children = children_future.result()
+
+            return _FetchedPage(
+                page_id=page_id,
+                parent_id=parent_id,
+                depth=depth,
+                status="fetched",
+                page_payload=page_payload,
+                children=children,
+            )
+        finally:
+            if children_executor is not None:
+                children_executor.shutdown(wait=True)
+
+    def _extract_page_id_from_search_item(item: Any) -> str | None:
+        if not isinstance(item, dict):
+            return None
+        raw_id = item.get("id")
+        if raw_id is None and isinstance(item.get("content"), dict):
+            raw_id = item["content"].get("id")
+        if raw_id is None:
+            return None
+        page_id = str(raw_id).strip()
+        return page_id if page_id.isdigit() else None
+
+    search_by_space_and_type = getattr(http, "search_by_space_and_type", None)
+
+    def _search_space_page_ids(
+        *,
+        space_key: str,
+        last_modified_after: datetime | None = None,
+        overlap_minutes: int = 0,
+    ) -> tuple[set[str], bool]:
+        if not callable(search_by_space_and_type):
+            return set(), False
+
+        page_ids: set[str] = set()
+        start = 0
+        limit = 100
+        successful = False
+        max_pages = 500
+
+        for _ in range(max_pages):
+            response = search_by_space_and_type(
+                space_key=space_key,
+                content_type="page",
+                limit=limit,
+                start=start,
+                expand=["version"],
+                last_modified_after=last_modified_after,
+                overlap_minutes=overlap_minutes,
+            )
+            if not isinstance(response, dict):
+                break
+            successful = True
+            results = response.get("results")
+            if not isinstance(results, list) or not results:
+                break
+            for item in results:
+                page_id = _extract_page_id_from_search_item(item)
+                if page_id:
+                    page_ids.add(page_id)
+            if len(results) < limit:
+                break
+            start += limit
+
+        return page_ids, successful
+
+    def _resolve_known_space_key() -> str | None:
+        root_meta = previous_page_meta_by_id.get(resolved_root_id)
+        if not isinstance(root_meta, dict):
+            return None
+        raw_space_key = root_meta.get("space_key")
+        if not isinstance(raw_space_key, str):
+            return None
+        space_key = raw_space_key.strip()
+        return space_key or None
+
+    def _discover_structure_first_tree(
+        initial_queue: list[tuple[str, str | None, int]],
+    ) -> tuple[list[tuple[str, str | None, int]], list[tuple[str, str | None, int]], set[str]]:
+        ordered: list[tuple[str, str | None, int]] = []
+        pending: list[tuple[str, str | None, int]] = []
+        discovered: set[str] = set()
+        pending_ids: set[str] = set()
+        seen: set[str] = set()
+        current_level: list[tuple[str, str | None, int]] = list(initial_queue)
+        for page_id, _, _ in current_level:
+            discovered.add(page_id)
+
+        while current_level:
+            level_nodes: list[tuple[str, str | None, int]] = []
+            for page_id, parent_id, depth in current_level:
+                if page_id in seen:
+                    continue
+                if options.max_nodes is not None and len(ordered) >= options.max_nodes:
+                    if page_id not in pending_ids:
+                        pending.append((page_id, parent_id, depth))
+                        pending_ids.add(page_id)
+                    continue
+                seen.add(page_id)
+                ordered.append((page_id, parent_id, depth))
+                level_nodes.append((page_id, parent_id, depth))
+
+            if options.max_nodes is not None and len(ordered) >= options.max_nodes:
+                for page_id, parent_id, depth in current_level:
+                    if page_id in seen or page_id in pending_ids:
+                        continue
+                    pending.append((page_id, parent_id, depth))
+                    pending_ids.add(page_id)
+                break
+
+            parents_for_children: list[tuple[str, int]] = []
+            for page_id, _, depth in level_nodes:
+                if options.max_depth >= 0 and depth >= options.max_depth:
+                    continue
+                parents_for_children.append((page_id, depth))
+
+            if not parents_for_children:
+                current_level = []
+                continue
+
+            child_batches: list[list[tuple[str, str | None, int]]]
+            if len(parents_for_children) == 1:
+                parent_id, parent_depth = parents_for_children[0]
+                child_batches = [_children_for(parent_id, parent_depth)]
+            else:
+                max_workers = min(page_concurrency, len(parents_for_children))
+                with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                    futures: list[Future[list[tuple[str, str | None, int]]]] = [
+                        executor.submit(_children_for, parent_id, parent_depth)
+                        for parent_id, parent_depth in parents_for_children
+                    ]
+                    child_batches = [future.result() for future in futures]
+
+            next_level: list[tuple[str, str | None, int]] = []
+            next_level_ids: set[str] = set()
+            for children in child_batches:
+                for child_id, child_parent, child_depth in children:
+                    if child_id in seen or child_id in next_level_ids:
+                        continue
+                    discovered.add(child_id)
+                    next_level_ids.add(child_id)
+                    next_level.append((child_id, child_parent, child_depth))
+            current_level = next_level
+
+        return ordered, pending, discovered
+
+    incremental_candidate_ids: set[str] = set()
+    incremental_high_water_mark_ran = False
+    incremental_high_water_mark_skipped = False
+    incremental_high_water_mark_skip_reason: str | None = None
+    incremental_known_page_count = 0
+    full_reconciliation_deleted_ids: list[str] = []
+    full_reconciliation_ran = False
+    full_reconciliation_skipped = False
+    full_reconciliation_skip_reason: str | None = None
+    full_reconciliation_known_page_count = 0
+    space_key_for_incremental = _resolve_known_space_key()
+    if options.resume and options.incremental_cql and callable(search_by_space_and_type):
+        known_page_ids = set(crawl_state.visited_pages.keys())
+        incremental_known_page_count = len(known_page_ids)
+        last_sync_dt = _parse_iso_timestamp(crawl_state.last_sync_timestamp)
+        if space_key_for_incremental and last_sync_dt is not None:
+            if incremental_known_page_count <= 1:
+                incremental_high_water_mark_skipped = True
+                incremental_high_water_mark_skip_reason = "known_pages_lte_1"
+            else:
+                incremental_high_water_mark_ran = True
+                try:
+                    incremental_ids, incremental_ok = _search_space_page_ids(
+                        space_key=space_key_for_incremental,
+                        last_modified_after=last_sync_dt,
+                        overlap_minutes=max(0, int(options.incremental_overlap_minutes)),
+                    )
+                except Exception:
+                    incremental_ids, incremental_ok = set(), False
+                if incremental_ok:
+                    incremental_candidate_ids = {page_id for page_id in incremental_ids if page_id in known_page_ids}
+                    if incremental_candidate_ids:
+                        queued_ids = {queued_page_id for queued_page_id, _, _ in queue}
+                        for page_id in sorted(incremental_candidate_ids):
+                            if page_id in queued_ids:
+                                continue
+                            previous_meta = previous_page_meta_by_id.get(page_id) or {}
+                            parent_id = previous_meta.get("parent_id")
+                            if parent_id is not None:
+                                parent_id = str(parent_id)
+                            depth = previous_meta.get("depth")
+                            if not isinstance(depth, int) or depth < 0:
+                                depth = 0
+                            queue.append((page_id, parent_id, depth))
+                            queued_ids.add(page_id)
+                            discovered_page_ids.add(page_id)
+
+        full_reconciliation_due = False
+        last_full_reconciliation_dt = _parse_iso_timestamp(crawl_state.last_full_reconciliation_timestamp)
+        if last_full_reconciliation_dt is None:
+            full_reconciliation_due = True
+        else:
+            full_reconciliation_due = (
+                datetime.now(UTC)
+                - last_full_reconciliation_dt
+                >= timedelta(days=max(1, int(options.full_reconciliation_interval_days)))
+            )
+
+        if space_key_for_incremental and full_reconciliation_due:
+            known_page_ids = set(crawl_state.visited_pages.keys())
+            full_reconciliation_known_page_count = len(known_page_ids)
+            reconciliation_marker_timestamp = _now_iso()
+            if full_reconciliation_known_page_count <= 1:
+                full_reconciliation_skipped = True
+                full_reconciliation_skip_reason = "known_pages_lte_1"
+                crawl_state.last_full_reconciliation_timestamp = reconciliation_marker_timestamp
+            else:
+                try:
+                    remote_page_ids, reconciliation_ok = _search_space_page_ids(space_key=space_key_for_incremental)
+                except Exception:
+                    remote_page_ids, reconciliation_ok = set(), False
+                if reconciliation_ok:
+                    full_reconciliation_ran = True
+                    full_reconciliation_deleted_ids = sorted(known_page_ids - remote_page_ids)
+                    if full_reconciliation_deleted_ids:
+                        for page_id in full_reconciliation_deleted_ids:
+                            crawl_state.visited_pages.pop(page_id, None)
+                            previous_visited.pop(page_id, None)
+                            previous_page_meta_by_id.pop(page_id, None)
+                            previous_attachments_by_page.pop(page_id, None)
+                            discovered_page_ids.discard(page_id)
+                        _emit_runtime_event(
+                            options,
+                            "pages_deleted",
+                            root_page_id=resolved_root_id,
+                            deleted_count=len(full_reconciliation_deleted_ids),
+                            page_ids=full_reconciliation_deleted_ids,
+                        )
+                    crawl_state.last_full_reconciliation_timestamp = reconciliation_marker_timestamp
+
+    structure_first_pending_queue: list[tuple[str, str | None, int]] = []
+    structure_pre_discovered_nodes = 0
+    if use_structure_first:
+        queue, structure_first_pending_queue, structure_discovered_ids = _discover_structure_first_tree(queue)
+        structure_pre_discovered_nodes = len(queue) + len(structure_first_pending_queue)
+        discovered_page_ids.update(structure_discovered_ids)
+
+    crawl_started_at = time.perf_counter()
+    max_inflight_workers = 0
+    effective_page_concurrency = page_concurrency
+    effective_concurrency_signal: float | None = None
+    throttle_pressure_score: float | None = None
+
+    while queue:
+        if options.max_nodes is not None and nodes_processed >= options.max_nodes:
+            termination_reason = "max_nodes_reached"
+            break
+
+        if options.max_nodes is None:
+            remaining = len(queue)
+        else:
+            remaining = min(len(queue), options.max_nodes - nodes_processed)
+            if remaining <= 0:
+                termination_reason = "max_nodes_reached"
+                break
+        runtime_page_concurrency = page_concurrency
+        if callable(telemetry_getter):
+            try:
+                telemetry_snapshot = telemetry_getter()
+            except Exception:
+                telemetry_snapshot = None
+            if isinstance(telemetry_snapshot, dict):
+                throttle = telemetry_snapshot.get("adaptive_throttle")
+                if isinstance(throttle, dict):
+                    signal = throttle.get("effective_concurrency_signal")
+                    if isinstance(signal, (float, int)):
+                        effective_concurrency_signal = float(signal)
+                        scaled = int(round(page_concurrency * float(signal)))
+                        runtime_page_concurrency = max(1, min(page_concurrency, scaled))
+                    pressure_score = throttle.get("pressure_score")
+                    if isinstance(pressure_score, (float, int)):
+                        throttle_pressure_score = float(pressure_score)
+        effective_page_concurrency = runtime_page_concurrency
+        batch_size = min(runtime_page_concurrency, remaining)
+        max_inflight_workers = max(max_inflight_workers, batch_size)
+
+        batch: list[tuple[str, str | None, int]] = []
+        while queue and len(batch) < batch_size:
+            page_id, parent_id, depth = queue.pop(0)
+            if page_id in visited_pages:
+                skipped_already_visited += 1
+                continue
+            visited_pages.add(page_id)
+            nodes_processed += 1
+            batch.append((page_id, parent_id, depth))
+
+        crawl_state.pending_queue = list(queue)
+        if not batch:
+            continue
+
+        fetched: list[_FetchedPage] = []
+        if batch_size == 1:
+            fetched = [_fetch_page(node) for node in batch]
+        else:
+            with ThreadPoolExecutor(max_workers=batch_size) as executor:
+                futures: dict[Future[_FetchedPage], int] = {
+                    executor.submit(_fetch_page, node): idx for idx, node in enumerate(batch)
+                }
+                fetched_by_index: dict[int, _FetchedPage] = {}
+                for future, idx in futures.items():
+                    fetched_by_index[idx] = future.result()
+                fetched = [fetched_by_index[idx] for idx in range(len(batch))]
+
+        for result in fetched:
+            page_id = result.page_id
+            parent_id = result.parent_id
+            depth = result.depth
+
+            if result.status == "unchanged":
+                skipped_unchanged += 1
+                unchanged_page_ids.add(page_id)
+                previous_meta = previous_page_meta_by_id.get(page_id)
+                if previous_meta is None:
+                    previous_meta = _meta_from_existing_html(
+                        page_id=page_id,
+                        parent_id=parent_id,
+                        depth=depth,
+                        page_payload=result.version_payload if isinstance(result.version_payload, dict) else None,
+                    )
+                if previous_meta is not None:
+                    if depth == 0:
+                        root_meta = previous_meta
+                    else:
+                        child_pages.append(previous_meta)
+                    if options.include_attachments:
+                        for previous_attachment in previous_attachments_by_page.get(page_id, []):
+                            attachment_id = previous_attachment.get("attachment_id")
+                            if attachment_id is not None:
+                                downloaded_attachments.add(str(attachment_id))
+                            attachments.append(previous_attachment)
+                for child_id, child_parent, child_depth in result.children:
+                    if child_id in visited_pages:
+                        continue
+                    discovered_page_ids.add(child_id)
+                    queue.append((child_id, child_parent, child_depth))
+                continue
+
+            if result.status == "error":
+                pages_failed += 1
+                meta = {
+                    "page_id": page_id,
+                    "title": None,
+                    "page_url": None,
+                    "parent_id": parent_id,
+                    "depth": depth,
+                    "status": "error",
+                    "error": result.error,
+                }
+                if depth == 0:
+                    root_meta = meta
+                else:
+                    child_pages.append(meta)
+                continue
+
+            pages_fetched += 1
+            page = result.page_payload if isinstance(result.page_payload, dict) else {}
+            title = str(page.get("title") or "untitled")
+            safe_title = _safe_filename(title)
+            body_obj = page.get("body") or {}
+            view_html = (body_obj.get("view") or {}).get("value", "")
+            export_html = (body_obj.get("export_view") or {}).get("value", "")
+            storage_html = (body_obj.get("storage") or {}).get("value", "")
+            candidates = {
+                "view": view_html if isinstance(view_html, str) else "",
+                "export_view": export_html if isinstance(export_html, str) else "",
+                "storage": storage_html if isinstance(storage_html, str) else "",
+            }
+            chosen_html = candidates.get(body_format, "") or ""
+            chosen_format = body_format
+            if not chosen_html.strip():
+                fallback_order = (
+                    ["view", "storage", "export_view"]
+                    if body_format == "view"
+                    else ["storage", "view", "export_view"]
+                    if body_format == "storage"
+                    else ["export_view", "view", "storage"]
+                )
+                for fmt in fallback_order:
+                    candidate = candidates.get(fmt, "") or ""
+                    if isinstance(candidate, str) and candidate.strip():
+                        chosen_html = candidate
+                        chosen_format = fmt
+                        break
+
+            html = chosen_html if isinstance(chosen_html, str) else ""
+            source_format = f"html-{chosen_format.replace('_', '-')}"
+
+            links = page.get("_links", {}) if isinstance(page.get("_links"), dict) else {}
+            base_url = str(links.get("base") or "")
+            web_ui = str(links.get("webui") or "")
+            page_url = f"{base_url}{web_ui}" if base_url and web_ui else None
+
+            version = page.get("version") or {}
+            page_version = version.get("number") if isinstance(version, dict) else None
+            page_updated = version.get("when") if isinstance(version, dict) else None
+            space_key = (page.get("space") or {}).get("key") if isinstance(page.get("space"), dict) else None
+
+            ancestors = page.get("ancestors") or []
+            ancestor_ids: list[str] = []
+            ancestor_titles: list[str] = []
+            if isinstance(ancestors, list):
+                for entry in ancestors:
+                    if not isinstance(entry, dict):
+                        continue
+                    if entry.get("id") is not None:
+                        ancestor_ids.append(str(entry["id"]))
+                    if entry.get("title"):
+                        ancestor_titles.append(str(entry["title"]))
+
+            html_path = output_dir / f"{page_id}_{safe_title}.html"
+            html_path.write_text(html, encoding="utf-8")
+            html_bytes = html.encode("utf-8")
+            html_sha256 = _sha256_bytes(html_bytes)
+            crawl_state.record_page(page_id, page_version, html_sha256)
+
+            meta = {
+                "page_id": page_id,
+                "title": title,
+                "page_url": page_url,
+                "parent_id": parent_id,
+                "depth": depth,
+                "status": "downloaded",
+                "html_path": str(html_path),
+                "html_sha256": html_sha256,
+                "html_size_bytes": html_path.stat().st_size,
+                "source_format": source_format,
+                "space_key": space_key,
+                "page_version": page_version,
+                "page_updated": page_updated,
+                "ancestor_ids": ancestor_ids,
+                "ancestor_titles": ancestor_titles,
+                "error": None,
+            }
+            if depth == 0:
+                root_meta = meta
+            else:
+                child_pages.append(meta)
+
+            if options.emit_link_graph:
+                for link in _extract_links(html, base_url=base_url):
+                    target_url = link.get("url")
+                    target_type = _classify_target_type(str(target_url)) if target_url else None
+                    target_page_id = _extract_target_page_id(str(target_url)) if target_url else None
+                    edge: dict[str, Any] = {
+                        "source_page_id": page_id,
+                        "source_page_url": page_url,
+                        "target_url": target_url,
+                        "anchor_text": link.get("text"),
+                    }
+                    if target_type:
+                        edge["target_type"] = target_type
+                    if target_type == "confluence_page" and target_page_id:
+                        edge["target_page_id"] = target_page_id
+                    link_edges.append(edge)
+
+            if options.emit_corpus:
+                for chunk in _chunk_html_by_headings(html, max_chars=chunk_max_chars):
+                    heading_path = chunk.get("heading_path") or []
+                    ordinal = chunk.get("ordinal") if isinstance(chunk.get("ordinal"), int) else 0
+                    base_key = f"{page_id}|{'/'.join(heading_path)}"
+                    key = base_key if ordinal == 0 else f"{base_key}|{ordinal}"
+                    corpus_chunks.append(
+                        {
+                            "chunk_id": _sha256_text(key)[:16],
+                            "page_id": page_id,
+                            "page_url": page_url,
+                            "title": title,
+                            "depth": depth,
+                            "parent_id": parent_id,
+                            "ancestors": ancestor_ids,
+                            "ancestor_ids": ancestor_ids,
+                            "space_key": space_key,
+                            "page_version": page_version,
+                            "page_updated": page_updated,
+                            "ancestor_titles": ancestor_titles,
+                            "heading_path": heading_path,
+                            "chunk_ordinal": ordinal,
+                            "text": chunk.get("text"),
+                            "source_type": "confluence",
+                            "doc_class": "canonical_doc",
+                            "generated_flag": False,
+                            "historical_flag": False,
+                            "discovery": "confluence_crawl_page",
+                        }
+                    )
+
+            if options.emit_tables:
+                for table in _extract_tables(html):
+                    key = f"{page_id}|table|{table.get('table_index')}"
+                    tables.append(
+                        {
+                            "table_id": _sha256_text(key)[:16],
+                            "page_id": page_id,
+                            "page_url": page_url,
+                            "title": title,
+                            "depth": depth,
+                            "parent_id": parent_id,
+                            "space_key": space_key,
+                            "page_version": page_version,
+                            "page_updated": page_updated,
+                            "ancestor_titles": ancestor_titles,
+                            "table_index": table.get("table_index"),
+                            "headers": table.get("headers"),
+                            "rows": table.get("rows"),
+                            "row_count": table.get("row_count"),
+                            "col_count": table.get("col_count"),
+                        }
+                    )
+
+            if options.emit_mentions:
+                for index, mention in enumerate(_extract_mentions(html, base_url=base_url)):
+                    key = f"{page_id}|mention|{mention.get('type')}|{mention.get('value')}|{mention.get('url') or ''}"
+                    mentions.append(
+                        {
+                            "mention_id": _sha256_text(key)[:16],
+                            "page_id": page_id,
+                            "page_url": page_url,
+                            "title": title,
+                            "depth": depth,
+                            "parent_id": parent_id,
+                            "space_key": space_key,
+                            "page_version": page_version,
+                            "page_updated": page_updated,
+                            "ancestor_titles": ancestor_titles,
+                            "mention_index": index,
+                            **mention,
+                        }
+                    )
+
+            if options.include_attachments:
+                try:
+                    attachment_results = http.get_attachments(page_id)
+                except Exception as exc:
+                    attachments.append(
+                        {
+                            "attachment_id": None,
+                            "page_id": page_id,
+                            "title": None,
+                            "status": "error",
+                            "error": str(exc),
+                        }
+                    )
+                    attachment_results = []
+
+                for att in attachment_results:
+                    if not isinstance(att, dict):
+                        continue
+                    attachment_id = att.get("id") or att.get("attachment_id")
+                    if attachment_id is None:
+                        continue
+                    attachment_id = str(attachment_id)
+                    if attachment_id in downloaded_attachments:
+                        continue
+                    downloaded_attachments.add(attachment_id)
+
+                    att_title = str(att.get("title") or att.get("name") or f"attachment_{attachment_id}")
+                    out_path = attachments_dir / _safe_attachment_filename(
+                        attachment_id, att_title, fallback_suffix=_guess_attachment_suffix(att)
+                    )
+
+                    try:
+                        content = http.get_attachment_content(attachment_id)
+                        out_path.write_bytes(content)
+                        file_sha256 = _sha256_bytes(content)
+                        status = "downloaded"
+                        error = None
+                    except Exception as exc:
+                        file_sha256 = None
+                        status = "error"
+                        error = str(exc)
+
+                    version_obj = att.get("version") or {}
+                    attachment_version = version_obj.get("number") if isinstance(version_obj, dict) else None
+                    extensions = att.get("extensions") or {}
+                    attachment_size = None
+                    if isinstance(extensions, dict):
+                        attachment_size = extensions.get("fileSize") or extensions.get("size")
+
+                    attachments.append(
+                        {
+                            "attachment_id": attachment_id,
+                            "page_id": page_id,
+                            "title": att_title,
+                            "status": status,
+                            "file_path": str(out_path) if status == "downloaded" else None,
+                            "file_sha256": file_sha256,
+                            "file_size_bytes": out_path.stat().st_size
+                            if status == "downloaded" and out_path.exists()
+                            else None,
+                            "attachment_version": attachment_version,
+                            "attachment_size": attachment_size,
+                            "error": error,
+                        }
+                    )
+
+            for child_id, child_parent, child_depth in result.children:
+                if child_id in visited_pages:
+                    continue
+                discovered_page_ids.add(child_id)
+                queue.append((child_id, child_parent, child_depth))
+
+        _emit_runtime_event(
+            options,
+            "crawl_progress",
+            root_page_id=resolved_root_id,
+            pages_discovered=len(discovered_page_ids),
+            pages_fetched=pages_fetched,
+            pages_failed=pages_failed,
+            pages_skipped_unchanged=skipped_unchanged,
+            pages_skipped_total=skipped_unchanged + skipped_already_visited,
+            pending_queue_size=len(queue),
+            effective_page_concurrency=effective_page_concurrency,
+            effective_concurrency_signal=effective_concurrency_signal,
+            throttle_pressure_score=throttle_pressure_score,
+        )
+
+    if options.emit_corpus and previous_corpus_chunks_by_page:
+        should_merge_unchanged_corpus = pages_fetched > 0 or bool(full_reconciliation_deleted_ids)
+        if should_merge_unchanged_corpus:
+            emitted_chunk_ids = {
+                str(chunk.get("chunk_id") or "").strip()
+                for chunk in corpus_chunks
+                if isinstance(chunk, dict) and str(chunk.get("chunk_id") or "").strip()
+            }
+            for page_id in sorted(unchanged_page_ids):
+                for previous_chunk in previous_corpus_chunks_by_page.get(page_id, []):
+                    if not isinstance(previous_chunk, dict):
+                        continue
+                    chunk_id = str(previous_chunk.get("chunk_id") or "").strip()
+                    if chunk_id and chunk_id in emitted_chunk_ids:
+                        continue
+                    corpus_chunks.append(dict(previous_chunk))
+                    if chunk_id:
+                        emitted_chunk_ids.add(chunk_id)
+
+    if structure_first_pending_queue:
+        queued_page_ids = {queued_page_id for queued_page_id, _, _ in queue}
+        for pending_page_id, pending_parent_id, pending_depth in structure_first_pending_queue:
+            if pending_page_id in visited_pages or pending_page_id in queued_page_ids:
+                continue
+            queue.append((pending_page_id, pending_parent_id, pending_depth))
+            queued_page_ids.add(pending_page_id)
+        if queue:
+            termination_reason = "max_nodes_reached"
+
+    # Update and save crawl state (TSK-188)
+    http_telemetry: dict[str, Any] | None = None
+    if callable(telemetry_getter):
+        try:
+            telemetry_payload = telemetry_getter()
+            if isinstance(telemetry_payload, dict):
+                http_telemetry = telemetry_payload
+        except Exception:
+            http_telemetry = None
+    if http_telemetry is None:
+        http_telemetry = {}
+
+    elapsed_seconds = max(0.001, time.perf_counter() - crawl_started_at)
+    throughput_pages_per_second = round(nodes_processed / elapsed_seconds, 3)
+    latency_metrics = http_telemetry.get("latency_ms") if isinstance(http_telemetry, dict) else None
+    p95_page_latency_ms = None
+    if isinstance(latency_metrics, dict):
+        operation_latency = latency_metrics.get("operation")
+        if isinstance(operation_latency, dict):
+            p95_value = operation_latency.get("p95")
+            if isinstance(p95_value, (float, int)):
+                p95_page_latency_ms = round(float(p95_value), 3)
+
+    retry_events_total = None
+    if isinstance(http_telemetry, dict):
+        retry_events_list = http_telemetry.get("recent_retry_events")
+        if isinstance(retry_events_list, list):
+            retry_events_total = len(retry_events_list)
+
+    if isinstance(http_telemetry, dict):
+        http_telemetry["inflight_workers"] = max_inflight_workers
+        http_telemetry["queue_depth"] = len(queue)
+        http_telemetry["pages_per_second"] = throughput_pages_per_second
+        http_telemetry["retry_events"] = retry_events_total
+        http_telemetry["p95_page_latency_ms"] = p95_page_latency_ms
+        adaptive_throttle = http_telemetry.get("adaptive_throttle")
+        if isinstance(adaptive_throttle, dict):
+            signal_value = adaptive_throttle.get("effective_concurrency_signal")
+            if isinstance(signal_value, (float, int)):
+                effective_concurrency_signal = float(signal_value)
+            pressure_value = adaptive_throttle.get("pressure_score")
+            if isinstance(pressure_value, (float, int)):
+                throttle_pressure_score = float(pressure_value)
+
+    crawl_state.last_sync_timestamp = _now_iso()
+    pages_skipped = skipped_unchanged + skipped_already_visited
+    progress_event = {
+        "pages_discovered": len(discovered_page_ids),
+        "pages_fetched": pages_fetched,
+        "pages_failed": pages_failed,
+        "pages_skipped": pages_skipped,
+        "pages_skipped_unchanged": skipped_unchanged,
+        "throttle": {
+            "configured_page_concurrency": page_concurrency,
+            "effective_page_concurrency": effective_page_concurrency,
+            "effective_concurrency_signal": effective_concurrency_signal,
+            "pressure_score": throttle_pressure_score,
+        },
+    }
+
+    crawl_state.pending_queue = list(queue)
+    crawl_state.completed = len(queue) == 0
+    if crawl_state.completed:
+        termination_reason = "queue_exhausted"
+    crawl_state.run_diagnostics = {
+        "termination_reason": termination_reason,
+        "nodes_processed": nodes_processed,
+        "skipped_unchanged": skipped_unchanged,
+        "skipped_already_visited": skipped_already_visited,
+        "pages_fetched": pages_fetched,
+        "pages_failed": pages_failed,
+        "pages_discovered": len(discovered_page_ids),
+        "pages_skipped": pages_skipped,
+        "pending_queue_size": len(queue),
+        "page_concurrency": page_concurrency,
+        "staged_mode": staged_mode,
+        "incremental_cql": bool(options.incremental_cql),
+        "rate_limit_budget": int(options.rate_limit_budget),
+        "full_reconciliation_interval_days": max(1, int(options.full_reconciliation_interval_days)),
+        "last_sync_timestamp": crawl_state.last_sync_timestamp,
+        "last_full_reconciliation_timestamp": crawl_state.last_full_reconciliation_timestamp,
+        "incremental_overlap_minutes": max(0, int(options.incremental_overlap_minutes)),
+        "incremental_known_page_count": incremental_known_page_count,
+        "incremental_candidate_count": len(incremental_candidate_ids),
+        "incremental_high_water_mark_ran": incremental_high_water_mark_ran,
+        "incremental_high_water_mark_skipped": incremental_high_water_mark_skipped,
+        "incremental_high_water_mark_skip_reason": incremental_high_water_mark_skip_reason,
+        "full_reconciliation_ran": full_reconciliation_ran,
+        "full_reconciliation_deleted_ids": full_reconciliation_deleted_ids,
+        "full_reconciliation_skipped": full_reconciliation_skipped,
+        "full_reconciliation_skip_reason": full_reconciliation_skip_reason,
+        "full_reconciliation_known_page_count": full_reconciliation_known_page_count,
+        "structure_pre_discovered_nodes": structure_pre_discovered_nodes if use_structure_first else None,
+        "progress_event": progress_event,
+        "telemetry": http_telemetry,
+        "http_telemetry": http_telemetry,
+    }
+    _save_crawl_state(crawl_state, state_path)
+
+    payload: dict[str, Any] = {
+        "root_ref": root_ref,
+        "root_page_id": resolved_root_id,
+        "out_dir": str(output_dir),
+        "generated_at": _now_iso(),
+        "body_format": body_format,
+        "chunk_max_chars": chunk_max_chars,
+        "crawl_mode": {
+            "page_concurrency": page_concurrency,
+            "staged_mode": staged_mode,
+            "incremental_cql": bool(options.incremental_cql),
+            "rate_limit_budget": int(options.rate_limit_budget),
+            "incremental_overlap_minutes": max(0, int(options.incremental_overlap_minutes)),
+            "full_reconciliation_interval_days": max(1, int(options.full_reconciliation_interval_days)),
+        },
+        "page": root_meta,
+        "child_pages": child_pages,
+        "attachments": attachments,
+        "corpus_path": None,
+        "link_graph_path": None,
+        "tables_path": None,
+        "mentions_path": None,
+        "progress_event": progress_event,
+        "resume_state": {
+            "skipped_unchanged": skipped_unchanged,
+            "skipped_already_visited": skipped_already_visited,
+            "pages_fetched": pages_fetched,
+            "pages_failed": pages_failed,
+            "pages_discovered": len(discovered_page_ids),
+            "pages_skipped": pages_skipped,
+            "pages_skipped_unchanged": skipped_unchanged,
+            "nodes_processed": nodes_processed,
+            "completed": crawl_state.completed,
+            "termination_reason": termination_reason,
+            "pending_queue_size": len(queue),
+            "state_path": str(state_path),
+            "page_concurrency": page_concurrency,
+            "staged_mode": staged_mode,
+            "last_sync_timestamp": crawl_state.last_sync_timestamp,
+            "last_full_reconciliation_timestamp": crawl_state.last_full_reconciliation_timestamp,
+        },
+        "telemetry": http_telemetry,
+        "http_telemetry": http_telemetry,
+    }
+
+    if options.emit_corpus:
+        corpus_path = output_dir / "corpus.jsonl"
+        if corpus_chunks or not (options.resume and corpus_path.exists()):
+            with corpus_path.open("w", encoding="utf-8") as fp:
+                for item in corpus_chunks:
+                    fp.write(json.dumps(item, ensure_ascii=False) + "\n")
+        payload["corpus_path"] = str(corpus_path)
+
+    if options.emit_link_graph:
+        graph_path = output_dir / "link-graph.json"
+        if link_edges or not (options.resume and graph_path.exists()):
+            graph_payload = {
+                "generated_at": payload["generated_at"],
+                "root_page_id": resolved_root_id,
+                "edges": [edge for edge in link_edges if edge.get("target_url")],
+            }
+            graph_path.write_text(json.dumps(graph_payload, ensure_ascii=False, indent=2), encoding="utf-8")
+        payload["link_graph_path"] = str(graph_path)
+
+    if options.emit_tables:
+        tables_path = output_dir / "tables.jsonl"
+        if tables or not (options.resume and tables_path.exists()):
+            with tables_path.open("w", encoding="utf-8") as fp:
+                for item in tables:
+                    fp.write(json.dumps(item, ensure_ascii=False) + "\n")
+        payload["tables_path"] = str(tables_path)
+
+    if options.emit_mentions:
+        mentions_path = output_dir / "mentions.jsonl"
+        if mentions or not (options.resume and mentions_path.exists()):
+            with mentions_path.open("w", encoding="utf-8") as fp:
+                for item in mentions:
+                    fp.write(json.dumps(item, ensure_ascii=False) + "\n")
+        payload["mentions_path"] = str(mentions_path)
+
+    resolved_manifest_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    payload["manifest_path"] = str(resolved_manifest_path)
+
+    # Create bundle zip if requested (TSK-189)
+    if options.bundle:
+        bundle_path = _create_bundle_zip(output_dir, resolved_root_id, resolved_manifest_path)
+        payload["bundle_path"] = str(bundle_path)
+
+    return payload