@@ -1101,6 +1101,7 @@ jobs:
     if: github.event_name == 'pull_request' || github.ref == 'refs/heads/main'
     permissions:
       contents: read
+      pull-requests: read # Read the current title/body when a check is rerun after an edit.
 
     steps:
       - uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6.1.0
@@ -1110,6 +1111,8 @@ jobs:
           persist-credentials: false
       - name: Validate PR source or every integrated main commit and breaking footer
         run: python3 -m scripts.check_main_policies conventional
+        env:
+          GH_TOKEN: ${{ github.token }}
 
   downstream-imports:
     needs: changes
 
@@ -56,11 +56,22 @@ To install everything this guide uses while developing: `pip install -e '.[dev,p
 
 ## Layout notes
 
-`adcp_reporting_row_sets` is the side table that records where a revision's rows live until the shared Core layout
-(persistence Stage 3). It matches the JavaScript table column for column except that `obligation_id` has no
+`adcp_reporting_row_sets` is the side table that records where a revision's rows live.
+It matches the JavaScript table column for column except that `obligation_id` has no
 foreign key: Python obligations live in `reporting_obligations`, not in the JavaScript
 `adcp_reporting_obligations` table. If the JavaScript migration created the table first, `ready_row_storage`
-refuses with the constraint name; apply this migration first, or drop that constraint.
+refuses with the constraint name and a schema-qualified, quoted statement to remove it.
+Apply the Python migration first, or, for an existing database with Python as its writer,
+remove the JavaScript foreign key before running readiness again. The default constraint name is:
+
+```sql
+ALTER TABLE adcp_reporting_row_sets
+    DROP CONSTRAINT adcp_reporting_row_sets_obligation_id_fkey;
+```
+
+Run this in the ledger schema. Use the exact statement from the refusal if the schema or
+constraint has a different name. This removes the cross-SDK foreign key; row integrity
+continues to be verified against the stored digests.
 
 A revision written before protocol-shape control totals (see the release notes) has a binding over `{name, value}`
 pairs. Its row set records the rows-only digest profile `rows_v1`, and its pair binding is verified against the
@@ -302,7 +313,9 @@ A period qualifies once the later of its period end and its newest revision or a
 `ledger_record_retention_days` is the generation's `status_retention_days`; a shorter value is ignored, because a row
 retention shorter than the advertised window is non-conformant.
 
-Python keeps revision headers and their records until the shared Core layout (persistence Stage 3). A pruned row set
+Python keeps revision headers and their records. Record retirement refuses periods with protected reconciliation
+or audit evidence, so production periods carrying those records remain retained; row-byte pruning still runs.
+A pruned row set
 stays as a small marker that makes reads answer as expired; the records are already outside the status projection,
 whose horizon excludes periods past retention. Versioned buckets, soft delete and retention locks are allowed as
 backstops, but a `pruned` period is not "erased" while they keep the old bytes.
@@ -346,12 +359,13 @@ either verify in the other. Three things must match between the two deployments:
 - **The same binding definitions.** A binding's identity digest is `sha256(JCS([kind, provider, identity_config]))`
   over the names the JavaScript SDK uses (`location`, `prefix`, `keyTemplate`), so an object binding that differs in
   location, prefix or key template is a different binding and is refused rather than silently redirected.
-- **The row-storage migration applied by this SDK first**, because the JavaScript `adcp_reporting_row_sets` has a
-  foreign key to its own obligations table that Python obligations can never satisfy. See "Layout notes".
+- **The row-storage migration applied by this SDK first**, or the JavaScript foreign key removed with
+  `ALTER TABLE adcp_reporting_row_sets DROP CONSTRAINT adcp_reporting_row_sets_obligation_id_fkey;`
+  in the ledger schema. Python obligations cannot satisfy that foreign key. See "Layout notes" for renamed constraints.
 
-Until the shared Core layout (persistence Stage 3) each SDK keeps its own revision headers, so what is shared today
+Each SDK keeps its own revision headers, so what is shared today
 is the row sets: JavaScript-written row sets verify through `ReportingRowStorageV1.find` and `read_all` here, and the
-other way around.
+other way around. A shared Core layout is no longer planned; keep one writer SDK per ledger database.
 
 The acceptance test runs both SDKs against one PostgreSQL schema and one filesystem bucket root, in both directions:
 
 
@@ -176,12 +176,21 @@ def event_context() -> tuple[str, str, dict[str, Any]]:
     return kind, target, event
 
 
-def conventional(kind: str, target: str, event: dict[str, Any]) -> dict[str, Any]:
+def conventional(
+    kind: str, target: str, event: dict[str, Any], *, api: GitHub | None = None
+) -> dict[str, Any]:
     if kind == "push":
         commits = main_commits(target)
     else:
         pr = event["pull_request"]
-        validate_message(pr["title"] + "\n\n" + (pr["body"] or ""))
+        # Reruns retain the original webhook payload, including an obsolete PR
+        # description. Read the editable message again without changing which
+        # checkout and commits this run is allowed to validate.
+        if api is None:
+            api = GitHub(os.environ["GH_TOKEN"])
+        current = api.repo(f"pulls/{pr['number']}")
+        require(current["head"]["sha"] == pr["head"]["sha"], "PR head changed; run current CI")
+        validate_message(current["title"] + "\n\n" + (current["body"] or ""))
         head, base = pr["head"]["sha"], pr["base"]["sha"]
         require(SHA.fullmatch(head) and SHA.fullmatch(base), "invalid PR source identities")
         fork = git("merge-base", base, head)
 
@@ -23,7 +23,8 @@
 
 #: Namespaces the snapshot covers: the two public surfaces an adopter imports
 #: from, the consolidated generated namespace behind them, and every generated
-#: domain module. Built on first use so this module imports nothing from
+#: domain module, plus the reporting and ledger public surfaces. Built on first
+#: use so this module imports nothing from
 #: ``adcp`` until asked.
 #:
 #: ``error_details`` is deliberately absent. Every name it carries is a class
@@ -39,6 +40,8 @@ def snapshot_modules() -> tuple[tuple[str, str], ...]:
         ("adcp", "adcp"),
         ("adcp.types", "adcp.types"),
         ("adcp.types._generated", "adcp.types._generated"),
+        ("adcp.reporting", "adcp.reporting"),
+        ("adcp.reporting.ledger", "adcp.reporting.ledger"),
         *(
             (f"adcp.types.domains.{domain}", f"adcp.types.domains.{domain}")
             for domain in adcp.types.domains.DOMAINS
 
@@ -9,7 +9,7 @@
 against digests committed in the database before a row is released.
 
 Row location lives in the ``adcp_reporting_row_sets`` side table, keyed by revision
-ID, until the shared Core layout. A revision without a row set still carries its
+ID. A revision without a row set still carries its
 rows in the legacy ``reporting_revision_rows`` table.
 
 Two binding kinds exist. ``postgres`` stores chunk bodies as ``BYTEA`` in the same
@@ -583,13 +583,13 @@ async def _refuse_foreign_core_keys(connection: Any) -> None:
         """Refuse a row-set table that another SDK created with a core-table foreign key.
 
         The JavaScript migration references ``adcp_reporting_obligations``, which
-        Python obligations never populate (they live in ``reporting_obligations``
-        until the shared Core layout). Writing here would fail at the first row
-        set, so refuse up front with the remedy.
+        Python obligations never populate (they live in ``reporting_obligations``).
+        Writing here would fail at the first row set, so refuse up front with the remedy.
         """
         row = await (
             await connection.execute(
-                "SELECT conname FROM pg_constraint WHERE conrelid ="
+                "SELECT conname, quote_ident(conname), quote_ident(current_schema())"
+                " FROM pg_constraint WHERE conrelid ="
                 " to_regclass(quote_ident(current_schema()) || '.adcp_reporting_row_sets')"
                 " AND contype = 'f' AND (SELECT relname FROM pg_class WHERE oid = confrelid)"
                 " <> ALL(%s::text[]) LIMIT 1",
@@ -601,7 +601,8 @@ async def _refuse_foreign_core_keys(connection: Any) -> None:
                 "STATE_UNAVAILABLE",
                 "adcp_reporting_row_sets has a foreign key to another SDK's core table "
                 f"({row[0]}); apply reporting_row_storage.sql before that SDK's migration, "
-                "or drop the constraint",
+                "or remove that foreign key with "
+                f"ALTER TABLE {row[2]}.adcp_reporting_row_sets DROP CONSTRAINT {row[1]};",
             )
 
     # -- providers --------------------------------------------------------
@@ -970,8 +971,10 @@ async def find_shareable(
         Identical rows are those with the same ``row_manifest_sha256``. Sharing
         never crosses an obligation, so it never crosses a consumer. A header-only
         revision references the existing chunks instead of storing them again.
-        Takes ``FOR SHARE`` on the row set so retention cannot retire it before the
-        caller's transaction commits.
+        Takes ``FOR SHARE`` for the lifetime of the caller's transaction. Object
+        staging releases that transaction before the ledger commit, so
+        ``persist_revision_row_set`` re-checks liveness and takes its own
+        ``FOR SHARE`` lock inside the commit transaction before sharing chunks.
         """
         if not prepared.encoded.chunks:
             return None
 
@@ -0,0 +1,34 @@
+"""Readiness failures supply a usable remedy for cross-SDK foreign keys."""
+
+from __future__ import annotations
+
+import pytest
+
+from adcp.reporting.ledger import PgReportingLedgerStore
+from adcp.reporting.ledger.row_storage import ReportingRowStorageV1, ReportingRowStoreError
+
+from ._generation_support import isolated_reporting_pool
+
+
+async def test_foreign_core_key_refusal_supplies_an_executable_quoted_remedy() -> None:
+    async with isolated_reporting_pool() as pool:
+        from psycopg import sql
+
+        store = PgReportingLedgerStore(pool=pool, row_storage=True)
+        await store.create_schema()
+        async with pool.connection() as connection:
+            await connection.execute("CREATE TABLE other_sdk_obligations (id TEXT PRIMARY KEY)")
+            await connection.execute(
+                sql.SQL(
+                    "ALTER TABLE adcp_reporting_row_sets ADD CONSTRAINT {} "
+                    "FOREIGN KEY (obligation_id) REFERENCES other_sdk_obligations (id)"
+                ).format(sql.Identifier('other SDK "obligation" key'))
+            )
+            with pytest.raises(ReportingRowStoreError) as caught:
+                await ReportingRowStorageV1._refuse_foreign_core_keys(connection)
+            assert caught.value.code == "STATE_UNAVAILABLE"
+            assert caught.value.detail is not None
+            remedy = caught.value.detail.split("with ", 1)[1]
+            assert 'DROP CONSTRAINT "other SDK ""obligation"" key";' in remedy
+            await connection.execute(remedy)
+            await ReportingRowStorageV1._refuse_foreign_core_keys(connection)