@@ -328,3 +328,27 @@ await store.changes_after(account_id="acct_a", cursor=page.cursor)
 - A registered consumer holds back `prune_changes` until it has passed those changes in its own feed order, up to
   `max_feed_hold_days` (default 7) after its last update, so a dead consumer cannot block retention. Schedule
   `prune_changes(change_retention_days=30)` next to the other maintenance. Cursors are the same bytes in both SDKs.
+
+## Host reads
+
+In-process consumers such as pacing, alerts and a warehouse sink read the ledger directly. Both reads return revision
+headers; rows come from the verified paged reader.
+
+```python
+current = await store.get_current_revision(account_id="acct_a", reporting_obligation_id="robl_1")
+page = await store.list_current_revisions(
+    account_id="acct_a", period_start_from=start, period_start_to=end, delivery_config_id="daily", limit=100
+)
+while page.cursor:
+    page = await store.list_current_revisions(..., cursor=page.cursor)
+```
+
+The current revision is the official revision if one exists, otherwise the snapshot nothing supersedes yet.
+`list_current_revisions` pages obligations whose period starts in `[period_start_from, period_start_to)` in period order
+and omits obligations without a revision. Its cursor is the format the JavaScript SDK uses. A change-feed consumer
+that receives `CURSOR_EXPIRED` resynchronizes from this read.
+
+`list_current_revisions` pages by `(period_start, reporting_obligation_id)`. Enabling `change_feed` creates
+`reporting_obligations_account_period_idx` to back that order; a host without it can create the same index itself on
+`reporting_obligations (account_id, period_start, reporting_obligation_id)`. A cursor whose position is not a
+timestamp with a zone raises `ValueError`, never a driver error.
@@ -134,6 +134,7 @@
     issue_id_for_occurrence,
     project_obligation_health,
 )
+from adcp.reporting.ledger.host_reads import ReportingCurrentRevisionsPageV1
 from adcp.reporting.ledger.models import (
     ConsumerStatusRecord,
     ConsumerStatusValue,
@@ -268,6 +269,7 @@
     "ReportingConfigurationGenerationKey",
     "ReportingControlTotalRecord",
     "ReportingCurrencyError",
+    "ReportingCurrentRevisionsPageV1",
     "ReportingDefinitionBinding",
     "ReportingDeliveryEscalation",
     "ReportingDeliveryPrincipal",
 
@@ -0,0 +1,23 @@
+"""Serving-grade reads for in-process consumers (pacing, alerts, warehouse sinks).
+
+Shared SDK persistence spec, adcontextprotocol/adcp#7996, section 3.7. These return
+revision *headers*; rows are read separately through the verified paged reader, and
+nothing here reads from a warehouse. ``PgReportingLedgerStore.get_current_revision`` and
+``list_current_revisions`` implement them.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from adcp.reporting.ledger.models import ReportingRevisionRecord
+
+__all__ = ["ReportingCurrentRevisionsPageV1"]
+
+
+@dataclass(frozen=True, slots=True)
+class ReportingCurrentRevisionsPageV1:
+    """A page of current revision headers; ``cursor`` is ``None`` on the last page."""
+
+    revisions: tuple[ReportingRevisionRecord, ...]
+    cursor: str | None
@@ -73,6 +73,7 @@
 from __future__ import annotations
 
 import asyncio
+import base64
 import hashlib
 import json
 from collections.abc import AsyncIterator, Callable, Sequence
@@ -93,6 +94,7 @@
 from adcp.reporting.currency import require_frozen_currency
 from adcp.reporting.evidence import ReportingCanonicalDigest, ReportingControlTotalRecord
 from adcp.reporting.ledger.health import issue_id_for_occurrence
+from adcp.reporting.ledger.host_reads import ReportingCurrentRevisionsPageV1
 from adcp.reporting.ledger.models import (
     ConsumerStatusRecord,
     LedgerRecordKind,
@@ -1664,6 +1666,117 @@ async def get_revision(
             ).fetchone()
         return _revision_from_row(row) if row else None
 
+    async def get_current_revision(
+        self, *, account_id: str, reporting_obligation_id: str
+    ) -> ReportingRevisionRecord | None:
+        """The obligation's current revision header: the official revision if one exists,
+        otherwise the snapshot nothing supersedes yet.
+
+        One indexed lookup. Rows are read separately through the verified paged reader.
+        """
+        query = "".join(
+            (
+                "SELECT ",
+                _REVISION_COLUMNS,
+                " FROM reporting_revisions r WHERE r.account_id = %s",
+                " AND r.reporting_obligation_id = %s AND ",
+                _CURRENT_REVISION_FILTER,
+                _CURRENT_REVISION_ORDER,
+                " LIMIT 1",
+            )
+        )
+        async with self._connection() as connection:
+            row = await (
+                await connection.execute(query, (account_id, reporting_obligation_id))
+            ).fetchone()
+        return _revision_from_row(row) if row else None
+
+    async def list_current_revisions(
+        self,
+        *,
+        account_id: str,
+        period_start_from: datetime,
+        period_start_to: datetime,
+        delivery_config_id: str | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> ReportingCurrentRevisionsPageV1:
+        """Current revision headers for an account's obligations whose period starts in
+        ``[period_start_from, period_start_to)``, ordered by period start.
+
+        Obligations without a revision yet are omitted. Page with ``cursor``; the
+        cursor format matches the JavaScript SDK's. A change-feed consumer that
+        received ``CURSOR_EXPIRED`` resynchronizes from this read.
+        """
+        if type(limit) is not int or not 1 <= limit <= 1000:
+            raise ValueError("limit must be between 1 and 1000")
+        after: tuple[str, str] | None = None
+        if cursor is not None:
+            try:
+                padded = cursor + "=" * (-len(cursor) % 4)
+                parsed = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")))
+                start, identity = parsed["start"], parsed["id"]
+                if not isinstance(start, str) or not isinstance(identity, str):
+                    raise ValueError("invalid")
+                # A cursor the JavaScript SDK wrote or a corrupted one must fail as a
+                # cursor error here, not as a driver error from the timestamp cast.
+                moment = datetime.fromisoformat(start.replace("Z", "+00:00"))
+                if moment.tzinfo is None:
+                    raise ValueError("invalid")
+                after = (start, identity)
+            except (ValueError, KeyError, TypeError, UnicodeError, AttributeError):
+                raise ValueError("current revisions cursor is invalid") from None
+        query = "".join(
+            (
+                "SELECT ",
+                _OUTER_REVISION_COLUMNS,
+                ", to_char(o.period_start AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"')",
+                " FROM reporting_obligations o JOIN LATERAL (SELECT ",
+                _REVISION_COLUMNS,
+                " FROM reporting_revisions r WHERE r.account_id = o.account_id",
+                " AND r.reporting_obligation_id = o.reporting_obligation_id AND ",
+                _CURRENT_REVISION_FILTER,
+                _CURRENT_REVISION_ORDER,
+                " LIMIT 1) r ON TRUE",
+                " WHERE o.account_id = %s AND o.period_start >= %s AND o.period_start < %s",
+                " AND (%s::text IS NULL OR o.delivery_config_id = %s)",
+                " AND (%s::timestamptz IS NULL OR (o.period_start, o.reporting_obligation_id)",
+                "      > (%s::timestamptz, %s::text))",
+                " ORDER BY o.period_start, o.reporting_obligation_id LIMIT %s",
+            )
+        )
+        async with self._connection() as connection:
+            rows = await (
+                await connection.execute(
+                    query,
+                    (
+                        account_id,
+                        period_start_from,
+                        period_start_to,
+                        delivery_config_id,
+                        delivery_config_id,
+                        after[0] if after else None,
+                        after[0] if after else None,
+                        after[1] if after else None,
+                        limit + 1,
+                    ),
+                )
+            ).fetchall()
+        page = rows[:limit]
+        next_cursor = None
+        if len(rows) > limit:
+            last = page[-1]
+            next_cursor = (
+                base64.urlsafe_b64encode(
+                    json.dumps({"start": last[-1], "id": last[2]}, separators=(",", ":")).encode()
+                )
+                .rstrip(b"=")
+                .decode("ascii")
+            )
+        return ReportingCurrentRevisionsPageV1(
+            tuple(_revision_from_row(row[:-1]) for row in page), next_cursor
+        )
+
     async def read_revision_rows(
         self,
         *,
@@ -3064,6 +3177,17 @@ def _translate_integrity_error(error: Exception) -> LedgerConflictError:
     " canonical_content_digest, managed_control_totals"
 )
 
+_OUTER_REVISION_COLUMNS = ", ".join(f"r.{name.strip()}" for name in _REVISION_COLUMNS.split(","))
+# The current revision of an obligation is the official one if it exists, otherwise the
+# snapshot nothing supersedes yet. An official revision is terminal, so it is never superseded.
+_CURRENT_REVISION_FILTER = (
+    "NOT EXISTS (SELECT 1 FROM reporting_revisions s WHERE s.account_id = r.account_id"
+    " AND s.supersedes_reporting_revision_id = r.reporting_revision_id)"
+)
+_CURRENT_REVISION_ORDER = (
+    " ORDER BY (r.finality = 'official') DESC, r.created_at DESC, r.reporting_revision_id DESC"
+)
+
 _ADJUSTMENT_COLUMNS = (
     "reporting_adjustment_id, account_id, adjusts_reporting_revision_id, reason_code,"
     " reason_detail, accounting_period_start, accounting_period_end, control_total_deltas,"
 
@@ -18,6 +18,12 @@
 
 SELECT pg_advisory_xact_lock(hashtext('adcp.reporting.schema'), hashtext(current_schema()));
 
+-- Backs list_current_revisions: an account's obligations in (period_start, id) order. Kept out of
+-- the base ledger DDL, whose parent catalog objects are pinned; extra indexes are ignored by the
+-- catalog checks.
+CREATE INDEX IF NOT EXISTS reporting_obligations_account_period_idx
+  ON reporting_obligations (account_id, period_start, reporting_obligation_id);
+
 CREATE TABLE IF NOT EXISTS adcp_reporting_changes (
   seq BIGSERIAL PRIMARY KEY,
   xid xid8 NOT NULL DEFAULT pg_current_xact_id(),
 
@@ -0,0 +1,125 @@
+"""Current-revision reads for in-process consumers: one lookup per obligation, paged by period."""
+
+from __future__ import annotations
+
+import base64
+import json
+from datetime import timedelta
+from typing import Any
+
+import pytest
+
+from adcp.reporting.ledger import PgReportingLedgerStore
+
+from ._generation_support import START, configuration, isolated_reporting_pool, obligation_for
+from .test_reporting_row_storage_pg import fetch_all, many_rows, typed_revision
+
+
+async def obligations(store: PgReportingLedgerStore, count: int) -> list[Any]:
+    created = []
+    for index in range(count):
+        config = configuration("acct_a", consumer_id=f"buyer{index}")
+        await store.put_configuration(config)
+        created.append(await store.commit_obligation(obligation_for(config)))
+    return created
+
+
+async def test_the_current_revision_is_the_unsuperseded_snapshot_then_the_official_one() -> None:
+    async with isolated_reporting_pool() as pool:
+        store = PgReportingLedgerStore(pool=pool)
+        await store.create_schema()
+        config = configuration()
+        await store.put_configuration(config)
+        obligation = await store.commit_obligation(obligation_for(config))
+        key = {
+            "account_id": obligation.account_id,
+            "reporting_obligation_id": obligation.reporting_obligation_id,
+        }
+        assert await store.get_current_revision(**key) is None
+
+        rows = many_rows(2)
+        first = typed_revision(obligation, rows, suffix="a")
+        await store.commit_revision(first, rows)
+        assert (
+            await store.get_current_revision(**key)
+        ).reporting_revision_id == first.reporting_revision_id
+        second = typed_revision(
+            obligation, rows, suffix="b", supersedes=first.reporting_revision_id
+        )
+        await store.commit_revision(second, rows)
+        assert (
+            await store.get_current_revision(**key)
+        ).reporting_revision_id == second.reporting_revision_id
+
+        # Scoped to the account: another account's lookup finds nothing.
+        assert (
+            await store.get_current_revision(
+                account_id="acct_other", reporting_obligation_id=key["reporting_obligation_id"]
+            )
+            is None
+        )
+
+
+async def test_current_revisions_page_by_period_start_with_a_javascript_compatible_cursor() -> None:
+    async with isolated_reporting_pool() as pool:
+        store = PgReportingLedgerStore(pool=pool, change_feed=True)
+        await store.create_schema()
+        created = await obligations(store, 5)
+        rows = many_rows(1)
+        for index, obligation in enumerate(created[:4]):  # the fifth has no revision yet
+            await store.commit_revision(typed_revision(obligation, rows, suffix=f"s{index}"), rows)
+
+        window = {
+            "account_id": "acct_a",
+            "period_start_from": START - timedelta(days=1),
+            "period_start_to": START + timedelta(days=1),
+        }
+        first = await store.list_current_revisions(**window, limit=3)
+        assert len(first.revisions) == 3 and first.cursor is not None
+        # The cursor is the format the JavaScript SDK reads.
+        padded = first.cursor + "=" * (-len(first.cursor) % 4)
+        decoded = json.loads(base64.urlsafe_b64decode(padded))
+        assert set(decoded) == {"start", "id"} and decoded["start"].endswith("Z")
+        second = await store.list_current_revisions(**window, limit=3, cursor=first.cursor)
+        assert len(second.revisions) == 1 and second.cursor is None
+        seen = [r.reporting_revision_id for r in (*first.revisions, *second.revisions)]
+        assert len(set(seen)) == 4
+
+        outside = await store.list_current_revisions(
+            account_id="acct_a",
+            period_start_from=START + timedelta(days=1),
+            period_start_to=START + timedelta(days=2),
+        )
+        assert outside.revisions == () and outside.cursor is None
+        none = await store.list_current_revisions(**{**window, "account_id": "acct_z"})
+        assert none.revisions == ()
+        filtered = await store.list_current_revisions(**window, delivery_config_id="nope")
+        assert filtered.revisions == ()
+        for bad in (0, 1001):
+            with pytest.raises(ValueError):
+                await store.list_current_revisions(**window, limit=bad)
+        with pytest.raises(ValueError):
+            await store.list_current_revisions(**window, cursor="!!")
+
+        def cursor_of(body: object) -> str:
+            return base64.urlsafe_b64encode(json.dumps(body).encode()).rstrip(b"=").decode()
+
+        # Well-formed JSON that is not a usable position fails as a cursor error, never as a
+        # driver error from the timestamp cast.
+        for body in (
+            {"start": "garbage", "id": "x"},
+            {"start": "2026-09-01T00:00:00", "id": "x"},  # no zone
+            {"start": 5, "id": "x"},
+            {"start": "2026-09-01T00:00:00Z", "id": 7},
+            {"id": "x"},
+            ["start", "id"],
+        ):
+            with pytest.raises(ValueError, match="cursor is invalid"):
+                await store.list_current_revisions(**window, cursor=cursor_of(body))
+        # Hosts that enable the change feed get an index on the account's period
+        # starts behind the page order.
+        assert await fetch_all(
+            pool,
+            "SELECT 1 FROM pg_indexes WHERE schemaname = current_schema()"
+            " AND indexname = 'reporting_obligations_account_period_idx'",
+        ) == [(1,)]