The Refine seam travels to this base, deliberately unwired

The seam that puts Festipod's persistence behind interchangeable Refine backends
was built on `festipod-refine`, over a base this one has since overtaken
everywhere else. Carrying the seam rather than the branch keeps the evolved data
layer intact and costs nothing: the backend contract, the registry and the
provider that mounts Refine depend only on the domain types, so they compile
here untouched once `@refinedev/core` is present — the one dependency this adds,
installed through pnpm as this project requires.

Nothing imports them and the registry is empty, which is the intended state.
Wiring the seam means rewriting `FestipodDataContext` against this base's
version of it — its own decision, with its own failure modes, and not one to
smuggle into a transfer. Landing the files first makes that decision reviewable
against real code instead of a diff between two branches.

The doctrine travels with the code, because the seam is unreadable without it:
the reconstructed observation of `@activitypods/refine-providers` — a package
that publishes no engagement at all, hence `type: reconstruct` and a pin on the
commit it was read at — our usage declaration beside it, and the brief that
arbitrates one data shape for two rights models. So the manifest grows a
`publish:` section: this repo still offers no interface, but it does now publish
what it consumes, which is the only channel a provider has for learning that.

The brief was written where three of the leaves it cites did not exist, and
named them in prose to say so. Here they exist, so it links them; and its open
deduplication point now reads against this repo's own `materializeAttendance`
instead of against a sibling branch. It stays open, and the finding is
unchanged: the active set is keyed per deposit, which buys replay idempotence
and not person identity, so the count counts deposits rather than people.

Two comment zones came over knowingly superseded — runtime hot-switching as what
shapes the provider, and a sign-in barrier waiting on something `AuthGate` no
longer does. They are recorded as data-layer doc-debt instead of being quietly
rewritten, so the rewrite lands with the wiring that settles what they should
say.

.project/contracts.yaml

@@ -1,7 +1,10 @@
-# Inter-repo contracts. Festipod is a CONSUMER only: it publishes no interface of its own,
-# and it consumes two — the SDK surface `@ng-eventually/polyfill` engages toward the
-# applications built on it, and the indexing layer `ng-helpers` engages toward the
-# applications that need to make things findable.
+# Inter-repo contracts. Festipod publishes no interface of its own — what it lists under
+# `publish:` is its own consumer-side DECLARATION, the channel a provider pulls to learn
+# what this app calls, what it needs and what blocks it. It consumes three — the SDK
+# surface `@ng-eventually/polyfill` engages toward the applications built on it, the
+# indexing layer `ng-helpers` engages toward the applications that need to make things
+# findable, and the Refine data providers `@activitypods/refine-providers`, which engage
+# nothing at all.
 #
 # The pulled copy under `into:` IS the specification Festipod codes against. An agent
 # working here reads that copy and never opens the provider's own source: a gap is raised
@@ -9,7 +12,7 @@
 #
 # Each interface gets its own FOLDER inside the concept that owns it, holding the pulled
 # engagement and — once Festipod actually consumes the interface — the `usage_festipod.md`
-# declaration beside it. Both interfaces land in `data-layer`: it is the concept that owns
+# declaration beside it. All three land in `data-layer`: it is the concept that owns
 # how Festipod uses an external data surface, including the machinery behind discovery
 # (`functional-domain` owns the product intent of discovery and explicitly delegates its
 # technical how to the data SDK).
@@ -19,6 +22,11 @@
 # access to a local checkout lives in `.project/contracts.local.yaml`, which is never
 # committed.
 
+publish:
+  # Key qualified by interface: a second declaration is coming for the NextGraph+polyfill
+  # backend, and publish keys must stay unique.
+  activitypods-providers--festipod: concepts/data-layer/activitypods-providers/usage_festipod.md
+
 consume:
   - contract: polyfill-surface
     into: concepts/data-layer/polyfill-surface/
@@ -43,3 +51,21 @@ consume:
     # Pinned on the TAG, never on a branch: a branch moves under us and the pin would stop
     # naming a state anyone can go back to. Re-pin to the next tag at each upgrade.
     ref: v1.0.1
+
+  - contract: activitypods-providers
+    into: concepts/data-layer/activitypods-providers/
+    # `@activitypods/refine-providers` publishes NO engagement: no contract document, no
+    # stated change policy, not even a git tag. So this entry is `type: reconstruct` — the
+    # one bounded crossing this protocol allows, made once at adoption time: the leaf under
+    # `into:` is OUR observation of that package, authored here and pinned to the commit it
+    # was read at. It is not a promise anyone made us, and every upgrade has to re-observe
+    # it. Once reconstructed, that leaf IS the specification this app codes against.
+    type: reconstruct
+    # Canonical identity: the package's git remote plus the repo-relative folder the
+    # observation was made from. Per-developer access to a checkout of it lives in
+    # `.project/contracts.local.yaml`, which is never committed.
+    reconstructFrom: https://github.com/activitypods/refine-providers.git/src
+    # The branch the observation was read from. A tag would be the better pin, but this
+    # repository publishes none — the resolver turns this into the commit actually read,
+    # which is what `built_version` records.
+    ref: master