Changeset d56d471 in Klonkt for src/services/guardianship

Timestamp:

07/29/2026 12:36:50 PM (6 weeks ago)

Author:

Robin <roboburr@…>

Branches:

main

Children:

7a93fcf

Parents:

6100ce9

Message:

Een voorstel krijgt een antwoord, een status en een zichtbare kring

Robin meldde drie dingen na de voorstelronde: er lijkt niets te gebeuren, de
status van een voorstel is nergens te volgen, en in /guardian zie je niet wie
de mede-guardians van een kind zijn. Onderzoek op beta wees de kern aan: de
ronde is aangekomen en geteld, maar elk voorstel was shaer:externalEmbeds, en
die stond al aan. Afspelen is nooit voorgesteld, en dat KON ook niet: de knop
"Afspelen voorstellen" verscheen alleen bij embeds === true, en voor een ward
op een andere server is die waarde onbekend, dus null, dus geen knop. Onbekend
is niet uit.

Drie reparaties, een per klacht.

Een: de lus sluit. De server van het kind beantwoordt de Offer die de
beslissing opende, terug naar de voorsteller: Accept als hij settelde op het
voorgestelde, Reject bij het tegendeel. Alleen de stem van het kind-account
telt als uitkomst; een vreemde die onze boeken wil sluiten wordt genegeerd.
Zonder dit kon het scherm van de voorsteller alleen maar eeuwig "wacht"
zeggen, wat er ook gebeurd was: de telling is het prive-grootboek van de
server van het kind.

Twee: de voorsteller houdt een eigen boek bij (ap_gated_sent) en het paneel
toont per ward de stand: wacht, aangenomen, afgewezen, of eerlijk verlopen als
het venster leegliep. Stilte na het venster is geen "loopt nog".

Drie: voor een ward op een andere server toont het paneel nu wel wie de
guardians zijn. Het lidmaatschap is publiek op het actordocument
(shaer:guardians, 2.1); de beschikbaarheid is en blijft het prive-grootboek
van hun server (3.6.1) en wordt alleen benoemd, niet getoond.

Changed files:
src/config/database.js

• tabel ap_gated_sent (het boek van de voorsteller)
• kolom proposer op ap_gated_offers, voor het antwoord naar huis

src/services/guardianship/gated.js

• recordSent/recallSent/settleSent/listSent en sentStatus (puur, getest)
• rememberGatedOffer onthoudt de voorsteller

src/services/guardianship/handshake.js

• answerGatedProposer: het settle-antwoord naar de voorsteller
• de inbox herkent dat antwoord en settelt het eigen boek; alleen het kind-account mag dat

src/routes/guardian.js

• proposeGated schrijft het boek; dashboardState serveert per ward de voorstellen met status
• GET /wards/guardians: lokaal met beschikbaarheid, remote de publieke lijst van hun actordocument

src/assets/js/guardian.js

• de afspeel-knop verschijnt ook bij onbekende embeds-stand (de bug)
• statusregels onder de instellingen-knoppen
• remote guardians opgehaald bij het openen van het paneel

src/assets/css/guardian.css

• g-prop-kleuren: de staat spreekt voor de woorden uit

src/services/i18n.js

• prop_*- en panel_guards_far-strings, NL/EN/DE

test/gated-settings.test.js

• de lus sluit: de voorsteller krijgt het antwoord, van alleen het kind
• het boek: open, aangenomen, afgewezen, verlopen

remarks: 334 tests groen, server start op een schone database. De guardian-kant
(sound-fabrics) en de ward-kant (beta) hebben allebei deze commit nodig: de
knop en de status leven bij de guardian, het antwoord bij het kind.

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

Location:

src/services/guardianship

Files:

• gated.js (modified) (3 diffs)
• handshake.js (modified) (5 diffs)

src/services/guardianship/gated.js

@@ -182 +182 @@
 export function clearGatedReviews(id) { rstmts().delAll.run(id); }
 
-export function rememberGatedOffer(offerId, slug, feature, value) {
+export function rememberGatedOffer(offerId, slug, feature, value, proposer) {
   try {
-    db.prepare('INSERT OR REPLACE INTO ap_gated_offers (offer_id, slug, feature, value) VALUES (?,?,?,?)')
-      .run(offerId, slug, feature, value ? 1 : 0);
+    db.prepare('INSERT OR REPLACE INTO ap_gated_offers (offer_id, slug, feature, value, proposer) VALUES (?,?,?,?,?)')
+      .run(offerId, slug, feature, value ? 1 : 0, proposer || null);
   } catch { /* non-fatal */ }
 }
@@ -192 +192 @@
   try { return db.prepare('SELECT * FROM ap_gated_offers WHERE offer_id = ?').get(offerId) || null; }
   catch { return null; }
+}
+
+// ── The proposer's own record (5.6) ───────────────────────────────
+// "Where did my proposal go?" had no answer: the status was a button caption
+// that did not survive a refresh. The ward's server tallies elsewhere, so the
+// proposer keeps its own row and the ward's server ANSWERS the Offer when the
+// decision settles: Accept when it settled on the proposed value, Reject when
+// it settled on the opposite. An open row past the window renders as expired,
+// because an expired decision settles on nothing and nobody writes home.
+
+export function recordSent(offerId, guardianSlug, wardUri, feature, value) {
+  try {
+    db.prepare(`INSERT OR REPLACE INTO ap_gated_sent (offer_id, guardian_slug, ward_uri, feature, value)
+                VALUES (?,?,?,?,?)`).run(offerId, guardianSlug, wardUri, feature, value ? 1 : 0);
+  } catch { /* non-fatal */ }
+}
+
+export function recallSent(offerId) {
+  try { return db.prepare('SELECT * FROM ap_gated_sent WHERE offer_id = ?').get(offerId) || null; }
+  catch { return null; }
+}
+
+export function settleSent(offerId, outcome) {
+  try { db.prepare('UPDATE ap_gated_sent SET status = ? WHERE offer_id = ?').run(outcome, offerId); } catch { /* non-fatal */ }
+}
+
+/** The latest proposal per feature this guardian sent to this ward. */
+export function listSent(guardianSlug, wardUri) {
+  try {
+    return db.prepare(`SELECT * FROM ap_gated_sent WHERE guardian_slug = ? AND ward_uri = ?
+                       GROUP BY feature HAVING MAX(created_at) ORDER BY created_at DESC`).all(guardianSlug, wardUri);
+  } catch { return []; }
+}
+
+/**
+ * What a sent row means on a screen. Pure, so the rule is testable: an answer
+ * wins, and silence past the window is not "still running", it is over.
+ */
+export function sentStatus(row, now) {
+  if (!row) return null;
+  if (row.status === 'accepted' || row.status === 'rejected') return row.status;
+  const opened = new Date(String(row.created_at).includes('T') ? row.created_at : `${row.created_at}Z`.replace(' ', 'T')).getTime();
+  if (Number.isFinite(opened) && now - opened >= GATED_WINDOW_MS) return 'expired';
+  return 'open';
 }
 
@@ -198 +242 @@
   parseGatedSetting, buildGatedOffer, rememberGatedOffer, recallGatedOffer,
   recordGatedReview, getGatedReview, listGatedReviews, removeGatedReview, clearGatedReviews,
+  recordSent, recallSent, settleSent, listSent, sentStatus,
 };

src/services/guardianship/handshake.js

@@ -81 +81 @@
   }
   return anyDelivered;
+}
+
+/**
+ * §5.6, the closing of the loop: a settled gated decision answers the Offer
+ * that opened it. Accept when it settled on the proposed value, Reject when on
+ * the opposite. Without this the proposer's screen can only ever say
+ * "waiting", forever, whatever actually happened: the tally lives on the
+ * ward's server and nobody else may read it, so the ward's server must speak.
+ */
+function answerGatedProposer(site, offerId, r) {
+  const o = gated.recallGatedOffer(offerId);
+  if (!o || !o.proposer) return;
+  const me = deps.selfId(site.slug);
+  if (o.proposer === me) return;   // the ward proposed to itself: nothing to write home
+  const agreed = r.value === !!o.value;
+  deps.deliverTo(site, o.proposer, {
+    id: `${me}#gatedanswer-${Date.now().toString(36)}${Math.floor(Math.random() * 1e4).toString(36)}`,
+    type: agreed ? 'Accept' : 'Reject',
+    actor: me, to: [o.proposer], object: offerId,
+  }).catch(() => { /* the delivery queue retries */ });
 }
 
@@ -301 +321 @@
       // ── 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);
+        gated.rememberGatedOffer(offerId, site.slug, gs.feature, gs.value, actor);
         // 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);
@@ -326 +346 @@
         } else {
           gated.clearGatedReviews(offerId);   // settled at once: nothing left to ask
+          answerGatedProposer(site, offerId, r);
         }
         notify(site.slug, { kind: 'gated_setting', feature: gs.feature, value: gs.value, state: r.state });
@@ -385 +406 @@
   // Accept / Reject of an offer we (also) track.
   const offerId = idOf(activity.object);
+  // §5.6, the answer coming HOME: the ward's server settled a decision we
+  // proposed and answers our Offer. Accept = it settled on what we proposed,
+  // Reject = on the opposite. Only the ward may say so: the answer must come
+  // from the ward the proposal was about, or anyone could close our books.
+  const sent = gated.recallSent(offerId);
+  if (sent && sent.guardian_slug === site.slug) {
+    if (actor !== sent.ward_uri) return false;   // not the ward's voice: not an outcome
+    const outcome = type === 'Accept' ? 'accepted' : 'rejected';
+    gated.settleSent(offerId, outcome);
+    notify(site.slug, { kind: 'gated_outcome', feature: sent.feature, value: !!sent.value, outcome, ward: sent.ward_uri });
+    return true;
+  }
   // §5.6: a fellow guardian answering a gated-setting proposal. The Accept only
   // references the offer, so the value comes from the proposal we stored. A
@@ -392 +425 @@
     const value = type === 'Accept' ? !!gsOffer.value : !gsOffer.value;
     const r = gated.recordGatedVote(site.slug, gsOffer.feature, actor, value);
+    if (r.state === 'settled') answerGatedProposer(site, offerId, r);
     notify(site.slug, { kind: 'gated_setting', feature: gsOffer.feature, value, state: r.state });
     return true;