Changeset 88d7c8f in Klonkt for src/services/guardianship

Timestamp:

07/29/2026 07:15:16 AM (6 weeks ago)

Author:

Robin Genis <roboburr@…>

Branches:

main

Children:

e27b8db

Parents:

439f095

Message:

Een gated voorstel bereikte de andere guardians nooit

Op de vloot nagekeken waarom YouTube-voorbeelden bij beta uit blijven: het
voorstel van sound-fabrics staat er, met een ja van een van de drie guardians,
en het is stil verlopen. Niet omdat iemand bezwaar had, maar omdat niemand
anders het ooit gezien heeft.

Het voorstel wordt geadresseerd aan de server van het kind, want die telt en
handhaaft (5.6). Maar daarmee bereikt het alleen de voorsteller en het kind. De
twee guardians op andere servers weten van niets, kunnen dus niet antwoorden, en
een drempel van twee is onhaalbaar. Elk voorstel verloopt na een dag.

De ontbrekende schakel is het doorsturen, precies wat 5.3 al doet voor een
gated follow: de server van het kind kent de gezaghebbende guardian-lijst, dus
die stuurt het voorstel door. Elke guardian bewaart een kopie die hij kan
beantwoorden, en het antwoord reist terug naar het kind, dat telt.

Changed files:
src/config/database.js

• tabel ap_gated_reviews, de guardian-kopie (zelfde vorm als ap_follow_reviews)

src/services/guardianship/gated.js

• de kopie-opslag: bewaren, lezen, beantwoorden, opruimen

src/services/guardianship/handshake.js

• ward-kant: doorsturen naar de andere guardians zodra het voorstel openstaat
• guardian-kant: de doorgestuurde kopie bewaren om te kunnen antwoorden

src/routes/guardian.js

• gatedReviews in de dashboardstaat; POST /guardian/api/gated/:id stuurt het antwoord naar de inbox van het kind

src/assets/js/guardian.js, src/assets/css/guardian.css

• de voorstel-kaart met Eens/Oneens bij de aanvragen

src/services/i18n.js

• de teksten in nl, en, de

test/gated-settings.test.js

• de hele keten: voorstellen, doorsturen naar allebei de anderen, de kopie opslaan, antwoorden, en pas bij twee van drie gaat de gate open

remarks: dit forceert niets; het maakt alleen mogelijk wat de spec al bedoelde.
Twee van de drie guardians moeten nog steeds akkoord gaan, en het venster is
24 uur.

-robo
Co-Authored-By: Claude Opus 5 <noreply@…>

Location:

src/services/guardianship

Files:

• gated.js (modified) (2 diffs)
• handshake.js (modified) (1 diff)

src/services/guardianship/gated.js

@@ -145 +145 @@
 }
 
+// ── The guardian-side copy (the missing leg of §5.6) ──────────────
+// A proposal addressed to the ward's server reaches only the proposer and the
+// ward. The other guardians never learn it exists, so a threshold of two can
+// never be met and every proposal expires unanswered. The ward's server
+// therefore FORWARDS it, exactly as it forwards a gated follow (§5.3): each
+// guardian stores a copy it can answer, and the answer travels back to the
+// ward, which tallies.
+
+let _rs = null;
+function rstmts() {
+  if (!_rs) {
+    _rs = {
+      ins: db.prepare(`INSERT INTO ap_gated_reviews (id, guardian_slug, ward_uri, ward_inbox, proposer, feature, value)
+                       VALUES (?,?,?,?,?,?,?)
+                       ON CONFLICT(guardian_slug, id) DO UPDATE SET value = excluded.value, ward_inbox = excluded.ward_inbox`),
+      get: db.prepare('SELECT * FROM ap_gated_reviews WHERE guardian_slug = ? AND id = ?'),
+      bySlug: db.prepare('SELECT * FROM ap_gated_reviews WHERE guardian_slug = ? ORDER BY created_at DESC'),
+      del: db.prepare('DELETE FROM ap_gated_reviews WHERE guardian_slug = ? AND id = ?'),
+      delAll: db.prepare('DELETE FROM ap_gated_reviews WHERE id = ?'),
+    };
+  }
+  return _rs;
+}
+
+export function recordGatedReview(guardianSlug, r) {
+  rstmts().ins.run(r.id, guardianSlug, r.wardUri, r.wardInbox || null, r.proposer || null, r.feature, r.value ? 1 : 0);
+  return rstmts().get.get(guardianSlug, r.id);
+}
+export function getGatedReview(guardianSlug, id) { return rstmts().get.get(guardianSlug, id); }
+export function listGatedReviews(guardianSlug) { return rstmts().bySlug.all(guardianSlug); }
+export function removeGatedReview(guardianSlug, id) { rstmts().del.run(guardianSlug, id); }
+/** Drop every guardian's copy once the decision has settled or lapsed. */
+export function clearGatedReviews(id) { rstmts().delAll.run(id); }
+
 export function rememberGatedOffer(offerId, slug, feature, value) {
   try {
@@ -160 +194 @@
   tallyGatedSetting, thresholdFor, featureColumn, recordGatedVote, gatedProgress, GATED_WINDOW_MS,
   parseGatedSetting, buildGatedOffer, rememberGatedOffer, recallGatedOffer,
+  recordGatedReview, getGatedReview, listGatedReviews, removeGatedReview, clearGatedReviews,
 };

src/services/guardianship/handshake.js

@@ -302 +302 @@
     const gs = gated.parseGatedSetting(activity.object);
     if (gs) {
-      if (gs.ward !== me) return false;                       // not our ward
-      gated.rememberGatedOffer(idOf(activity), site.slug, gs.feature, gs.value);
-      // The proposer's Offer carries its own agreement (§3.1's one-step clause).
-      const r = gated.recordGatedVote(site.slug, gs.feature, actor, gs.value);
-      notify(site.slug, { kind: 'gated_setting', feature: gs.feature, value: gs.value, state: r.state });
-      return true;
+      const offerId = idOf(activity);
+      // ── I am the WARD: record, tally, and forward to the other guardians.
+      if (gs.ward === me) {
+        gated.rememberGatedOffer(offerId, site.slug, gs.feature, gs.value);
+        // The proposer's Offer carries its own agreement (§3.1's one-step clause).
+        const r = gated.recordGatedVote(site.slug, gs.feature, actor, gs.value);
+        // The forward is the leg that was missing. A proposal addressed to the
+        // ward's server reaches only the proposer and the ward; the other
+        // guardians never learn it exists, so a threshold of two can never be
+        // met and every proposal expires unanswered. The ward's server is the
+        // one that knows the authoritative guardian list, which is exactly why
+        // §5.3 forwards a gated follow from here too.
+        if (r.state === 'open') {
+          for (const g of relations.listGuardians(site.slug).map((x) => x.other_uri)) {
+            if (g === actor) continue;   // the proposer already answered
+            deps.deliverTo(site, g, {
+              id: offerId, type: 'Offer', actor, to: [g], object: activity.object,
+            }).catch(() => { /* the delivery queue retries */ });
+          }
+        } else {
+          gated.clearGatedReviews(offerId);   // settled at once: nothing left to ask
+        }
+        notify(site.slug, { kind: 'gated_setting', feature: gs.feature, value: gs.value, state: r.state });
+        return true;
+      }
+      // ── I am one of the GUARDIANS: the forwarded copy. Store it so this
+      //    guardian can answer; the answer goes back to the ward, which tallies.
+      if (relations.getRelation(site.slug, 'guardian', gs.ward)) {
+        const wardDoc = await deps.fetchActor(gs.ward).catch(() => null);
+        gated.recordGatedReview(site.slug, {
+          id: offerId, wardUri: gs.ward, wardInbox: wardDoc && wardDoc.inbox,
+          proposer: actor, feature: gs.feature, value: gs.value,
+        });
+        notify(site.slug, { kind: 'gated_review', feature: gs.feature, value: gs.value, ward: gs.ward });
+        return true;
+      }
+      return false;   // not our ward, and not a ward we guard
     }
     // §3.6.3: a co-guardian proposes releasing a dormant guardian of THIS