Changeset 72d8eff in Klonkt for src/services/guardianship/gated.js

Timestamp:

08/07/2026 07:16:27 PM (5 weeks ago)

Author:

roboburr <roboburr@…>

Branches:

main

Children:

a66266d

Parents:

01fb44f

git-author:

Robin <roboburr@…> (08/07/2026 07:16:25 PM)

git-committer:

roboburr <roboburr@…> (08/07/2026 07:16:27 PM)

Message:

De gate-stand komt uit de besluiten, want er zijn geen lokale accounts

Barts correctie, en hij raakt twee dingen die ik fout had.

ER ZIJN GEEN LOKALE ACCOUNTS. wardGateSetting() leest de kolom alleen als de ward
op onze eigen base staat, en met een Klonkt per gebruiker woont elke ward elders.
Die functie gaf dus voor IEDERE ward null, en het gate-paneel toonde overal
"onbekend". Ik noemde dat een randgeval terwijl het het enige geval is.

EN DE GUARDIAN WEET HET WEL: hij kreeg de uitslag van het besluit door.
ap_gated_sent bewaart per voorstel de feature, de waarde en de uitkomst, dus een
geaccepteerd voorstel met waarde true IS de stand. knownSetting() leest dat.

Drie standen in plaats van twee. "Uit" en "voor zover wij weten uit" zijn niet
hetzelfde: dat tweede betekent dat niemand er ooit over besloot, en dat hoort
niet te lezen als een genomen besluit. De rij draagt nu decided en het scherm
zegt "uit (nog niets over besloten)".

Daarmee vervalt ook het gat dat ik een commit eerder noteerde: de richting van de
voorstelknop volgt nu een BEKENDE stand, dus voor een ward elders kun je ook
DICHTZETTEN voorstellen. Dat was precies de veilige richting die ontbrak.

De trap blokkeert alleen op een BESLOTEN dicht, niet op de standaard. Anders kan
afspelen nooit als eerste voorgesteld worden, en zo ging er ooit een hele
voorstelronde de verkeerde gate in.

BEKEND GAT, in het commentaar bij knownSetting gezet en niet hier opgelost: dit
ziet alleen onze EIGEN voorstellen. Antwoordde je op dat van een mede-guardian,
dan komt de uitslag wel binnen (gated_outcome) maar wordt hij niet bewaard --
handshake.js legt alleen vast voor sent-rijen die van ons zijn. Een gate die een
ander heeft geopend leest hier dus als uit, en dat is de onveilige kant.

4 tests erbij, waaronder de terugval op de oude kale-boolean vorm. Suite 599/599.

File:

• src/services/guardianship/gated.js (modified) (4 diffs)

src/services/guardianship/gated.js

@@ -97 +97 @@
 export function gateRows({ settings = {}, guardianCount = null, proposals = [], waiting = {} } = {}) {
   return GATE_CATALOGUE.map((g) => {
-    const value = Object.prototype.hasOwnProperty.call(settings, g.feature) ? settings[g.feature] : null;
+    // Een stand kan drie dingen zijn: beslist-aan, beslist-uit, of de standaard
+    // omdat er nooit iets besloten is. Dat derde als "uit" tonen zou een besluit
+    // suggereren dat niemand nam.
+    const raw = Object.prototype.hasOwnProperty.call(settings, g.feature) ? settings[g.feature] : null;
+    const beslist = raw && typeof raw === 'object' ? !!raw.decided : (raw === true || raw === false);
+    const value = raw && typeof raw === 'object' ? raw.value : raw;
     // De trap: het bovenliggende moet OPEN staan. Onbekend telt niet als dicht --
     // bij een ward elders kennen we de stand niet, en verbergen betekende daar
     // ooit dat een voorstel nooit geopend kon worden.
-    const blockedBy = g.needs && settings[g.needs] === false ? g.needs : null;
+    const bovenliggend = settings[g.needs];
+    const bovenWaarde = bovenliggend && typeof bovenliggend === 'object' ? bovenliggend.value : bovenliggend;
+    const bovenBeslist = bovenliggend && typeof bovenliggend === 'object' ? bovenliggend.decided : (bovenWaarde === true || bovenWaarde === false);
+    // Alleen dichthouden als we ZEKER weten dat het bovenliggende uit staat.
+    const blockedBy = (g.needs && bovenBeslist && bovenWaarde === false) ? g.needs : null;
     return {
       feature: g.feature,
@@ -107 +116 @@
       reversible: !!g.reversible,
       value,
+      decided: beslist,
       // Vast staat vast: tonen mag, verzetten niet.
       adjustable: !g.fixed && !blockedBy,
@@ -274 +284 @@
 }
 
+/**
+ * De stand van een gate zoals DEZE guardian hem kent.
+ *
+ * Er zijn geen lokale accounts: elke ward woont op een andere server, dus de
+ * kolom op onze eigen sites-tabel is voor een ward altijd leeg. Wat een guardian
+ * wel heeft is de UITSLAG van besluiten -- een geaccepteerd voorstel met waarde
+ * true betekent dat de poort openging.
+ *
+ * Geeft { value, decided }:
+ *   decided true   we hebben een aangenomen besluit gezien; value is die waarde
+ *   decided false  we hebben er geen; value is de standaard voor een ward (uit)
+ *
+ * Dat verschil hoort zichtbaar te blijven. "Uit" en "voor zover wij weten uit"
+ * zijn niet hetzelfde, en het tweede is wat we meestal hebben.
+ *
+ * BEKEND GAT: dit ziet alleen onze EIGEN voorstellen. Antwoordde je op dat van
+ * een mede-guardian, dan komt de uitslag wel binnen (gated_outcome) maar wordt
+ * hij niet bewaard -- handshake.js legt alleen vast voor sent-rijen die van ons
+ * zijn. Een gate die een ander heeft geopend leest hier dus als "uit". Dat is de
+ * onveilige kant en het hoort gerepareerd te worden.
+ */
+export function knownSetting(guardianSlug, wardUri, feature) {
+  try {
+    const r = db.prepare(`SELECT value FROM ap_gated_sent
+                           WHERE guardian_slug = ? AND ward_uri = ? AND feature = ? AND status = 'accepted'
+                           ORDER BY created_at DESC LIMIT 1`).get(guardianSlug, wardUri, feature);
+    if (r) return { value: !!r.value, decided: true };
+  } catch { /* val terug op de standaard */ }
+  return { value: false, decided: false };
+}
+
 export function settleSent(offerId, outcome) {
   try { db.prepare('UPDATE ap_gated_sent SET status = ? WHERE offer_id = ?').run(outcome, offerId); } catch { /* non-fatal */ }
@@ -299 +340 @@
 
 export default {
-  GATE_CATALOGUE, gateRows,
+  GATE_CATALOGUE, gateRows, knownSetting,
   tallyGatedSetting, thresholdFor, featureColumn, recordGatedVote, gatedProgress, GATED_WINDOW_MS,
   parseGatedSetting, buildGatedOffer, rememberGatedOffer, recallGatedOffer,