@bongos/core 1.21.18 → 1.21.19

package/modules/ui-design/kit/fixtures/government-constitution-rules.json

@@ -0,0 +1,184 @@
+{
+  "_": "GET /government/constitution as the street reads it for a drafted amendment (task 1004530): the board block and the who-decides-what table, resolved by modules/government/decision-rules.js resolveAll (Release already amended to a sitting; every other building as today). Regenerate from the resolver, never by hand.",
+  "board": {
+    "membership": "rank:metic+",
+    "pass_rule": "majority",
+    "window_minutes": 4320,
+    "close_early_on_full_turnout": true
+  },
+  "history": [],
+  "headcount": 6,
+  "decision_rules": {
+    "areas": [
+      {
+        "area": "charter",
+        "name": "Charter",
+        "decided_by": "board",
+        "rule": "majority",
+        "rule_words": "majority vote",
+        "who": "the board (metic and above (metic, archon))",
+        "as_today": true,
+        "sitting": false,
+        "gate": null,
+        "today": "the board, under the constitution in force",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "rules",
+        "name": "Rules",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may change the project settings",
+        "as_today": true,
+        "sitting": false,
+        "gate": "project.settings.manage",
+        "today": "whoever may change the project settings",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "disputes",
+        "name": "Disputes",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may judge reports",
+        "as_today": true,
+        "sitting": false,
+        "gate": "security.report.adjudicate",
+        "today": "whoever may judge reports",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "people",
+        "name": "People",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may manage ranks",
+        "as_today": true,
+        "sitting": false,
+        "gate": "government.manage",
+        "today": "whoever may manage ranks",
+        "acts": [
+          "POST /government/assignments",
+          "DELETE /government/assignments/:builderId/:rankKey"
+        ],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "planning",
+        "name": "Planning",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may create goals",
+        "as_today": true,
+        "sitting": false,
+        "gate": "goal.create",
+        "today": "whoever may create goals",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "automation",
+        "name": "Automation",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may switch unattended building on and off",
+        "as_today": true,
+        "sitting": false,
+        "gate": "autonomy.fence.manage",
+        "today": "whoever may switch unattended building on and off",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "review",
+        "name": "Review",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may mark work as meeting its checks",
+        "as_today": true,
+        "sitting": false,
+        "gate": "criterion.satisfy",
+        "today": "whoever may mark work as meeting its checks",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      },
+      {
+        "area": "release",
+        "name": "Release",
+        "decided_by": "rank:archon",
+        "rule": "unanimous",
+        "rule_words": "everyone agrees",
+        "who": "exactly archon",
+        "as_today": false,
+        "sitting": true,
+        "gate": "core.pin.move",
+        "today": "whoever may put a release live",
+        "acts": [],
+        "set_by_item_id": "3",
+        "updated_at": null
+      },
+      {
+        "area": "treasury",
+        "name": "Treasury",
+        "decided_by": "gate",
+        "rule": "decide",
+        "rule_words": "decides alone",
+        "who": "whoever may set spending limits",
+        "as_today": true,
+        "sitting": false,
+        "gate": "builder.budget.set",
+        "today": "whoever may set spending limits",
+        "acts": [],
+        "set_by_item_id": null,
+        "updated_at": null
+      }
+    ],
+    "rules": [
+      {
+        "key": "decide",
+        "words": "decides alone"
+      },
+      {
+        "key": "first",
+        "words": "first yes wins"
+      },
+      {
+        "key": "consent",
+        "words": "passes unless someone objects"
+      },
+      {
+        "key": "majority",
+        "words": "majority vote"
+      },
+      {
+        "key": "unanimous",
+        "words": "everyone agrees"
+      },
+      {
+        "key": "signoff",
+        "words": "signed off by someone who did not build it"
+      },
+      {
+        "key": "vacant",
+        "words": "no one holds this yet"
+      }
+    ],
+    "changed_by": "a passed amendment only — POST /government/board/decision-rules files one"
+  }
+}

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.18",
+  "version": "1.21.19",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.21.18",
+      "version": "1.21.19",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.18",
+  "version": "1.21.19",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -8864,5 +8864,11 @@
       "id": "1004555",
       "text": "Project setup no longer shows an \"Allow repo access\" button — if the site needs GitHub access it fetches it in a quick reload and brings you straight back to where you were."
     }
+  ],
+  "1.21.19": [
+    {
+      "id": "1004530",
+      "text": "Inside any building on the street, \"change how this works\" now drafts a real amendment. It shows how the building decides today crossed out, and the proposed change written in. You pick who decides and how from the project's o"
+    }
   ]
 }

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.18'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.19'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/hall_street.mjs

@@ -377,7 +377,7 @@ test('the page holds the prototype\'s header, the street, the readings and the c
   for (const id of ['hudNeeds', 'hudMoving', 'hudShare', 'streetMode', 'streetSigns', 'streetPins', 'streetDoors', 'streetCard']) assert.match(html, new RegExp(`id="${id}"`), id);
   assert.doesNotMatch(html, /app-sidebar|shell\.js/, 'no hall chrome, as the city');
   const scripts = [...html.matchAll(/<script src="\/builders\/([a-z-]+)\.js/g)].map((m) => m[1]);
-  assert.deepEqual(scripts, ['city-draw', 'street-draw', 'street-card', 'street-inside', 'street'], 'the shared kit loads first, then the card (task 1004528) and the interiors (task 1004526)');
+  assert.deepEqual(scripts, ['city-draw', 'street-draw', 'street-card', 'street-inside', 'street-amend', 'street'], 'the shared kit loads first, then the card (task 1004528), the interiors (task 1004526) and the drafted amendment (task 1004530)');
   assert.equal(City.STREET_HREF, '/builders/street', 'the city\'s door is this page');
 });
 

package/tests/hall_street_amend.mjs

@@ -0,0 +1,336 @@
+// tests/hall_street_amend.mjs — CHANGE HOW THIS WORKS DRAFTS AN AMENDMENT
+// (task 1004530, goal 1000125).
+//
+// WHAT IT GUARDS. From any building, "change how this works" opens a drafted
+// amendment to that building's row of the who-decides-what table, prefilled
+// with the rule in force and a proposed one as struck and inserted text; the
+// governor picks who and which rule from the vocabulary only, says why, and
+// files it; the street answers. What can go wrong:
+//   * the draft offering a seat or a rule the server does not know (free text),
+//     or a rule that does not fit who decides (as today with a rule, empty with
+//     anything but vacant) — the server would refuse what the governor drafted;
+//   * the struck and inserted words drifting from what the matter card shows the
+//     council (pinned: they ARE the card's change() over the stored amendment);
+//   * a request body the server's own validator refuses, the Charter's draft
+//     going to the rules route (it is the board: /board/items);
+//   * a refusal swallowed, or said as a code instead of words;
+//   * the page filing with no reason, filing twice, or answering nothing.
+//
+// The fixtures are the SERVER'S OWN resolved rows (decision-rules.js), so the
+// draft is tested against the shape the constitution route really serves.
+//
+// Run:  node --test tests/hall_street_amend.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules/hall-ui/public');
+const require = createRequire(import.meta.url);
+const C = require(path.join(PUB, 'street-card.js'));
+const A = require(path.join(PUB, 'street-amend.js'));
+const S = require(path.join(PUB, 'street-draw.js'));
+const DR = require(path.join(ROOT, 'modules/government/decision-rules.js'));
+const { RANK_ORDER } = require(path.join(ROOT, 'modules/government/membership-predicate.js'));
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+const j = (v) => JSON.parse(JSON.stringify(v));
+
+const BOARD = { membership: 'rank:archon', pass_rule: 'majority', window_minutes: 4320, close_early_on_full_turnout: true };
+function constitution(rows = [], board = BOARD) {
+  return {
+    board,
+    decision_rules: {
+      areas: j(DR.resolveAll(rows, { board })),
+      rules: DR.DECISION_RULES.map((r) => ({ key: r.key, words: r.words })),
+      changed_by: 'a passed amendment only',
+    },
+  };
+}
+const SAT = { area: 'review', decided_by: 'rank:metic+', rule: 'signoff', who: null, set_by_item_id: 12 };
+
+// ── the draft ───────────────────────────────────────────────────────────────
+
+test('the vocabulary is the server\'s: the rank ladder, the seven rules, the nine buildings', () => {
+  assert.deepEqual(A.RANKS, [...RANK_ORDER]);
+  const c = constitution();
+  for (const area of DR.AREA_KEYS) {
+    const d = A.draftFor(area, c);
+    assert.equal(d.ok, true, area);
+    for (const o of d.whoOptions) assert.ok(o.value === 'gate' || o.value === 'nobody' || /^rank:/.test(o.value), `${area}: ${o.value} is a seat, never free text`);
+    for (const o of d.ruleOptions) assert.ok(DR.SITTING_RULE_KEYS.includes(o.value), `${area}: ${o.value}`);
+  }
+});
+
+test('a building decided as today drafts: the board\'s members, by consent, struck and inserted', () => {
+  const d = A.draftFor('review', constitution());
+  assert.equal(d.name, 'Review');
+  assert.deepEqual(d.current, { decided_by: 'gate', rule: null });
+  assert.equal(d.decided_by, 'rank:archon');
+  assert.equal(d.rule, 'consent');
+  assert.deepEqual(d.whoOptions.map((o) => o.value), ['gate', 'rank:archon', 'rank:xenos+', 'rank:thetes+', 'rank:metic+', 'nobody']);
+  assert.equal(d.whoOptions[0].words, 'as today: whoever may mark work as meeting its checks');
+  assert.deepEqual(d.ruleOptions.map((o) => o.value), ['decide', 'first', 'consent', 'majority', 'unanimous', 'signoff']);
+  assert.deepEqual(j(A.change(d)), [{ label: 'Review', struck: 'whoever may mark work as meeting its checks, decides alone', inserted: 'the archon rank, passes unless someone objects' }]);
+});
+
+test('a building already changed drafts its way back to as today', () => {
+  const d = A.draftFor('review', constitution([SAT]));
+  assert.deepEqual(d.current, { decided_by: 'rank:metic+', rule: 'signoff' });
+  assert.equal(d.decided_by, 'gate');
+  assert.equal(d.rule, null);
+  assert.deepEqual(d.ruleOptions, [], 'as today decides alone: there is no rule to pick');
+  assert.deepEqual(j(A.change(d)), [{ label: 'Review', struck: 'metic and above (metic, archon), signed off by someone who did not build it', inserted: 'as it is decided today' }]);
+});
+
+test('the rule follows who: no one is vacant, a sitting keeps a rule that fits, a value outside the vocabulary changes nothing', () => {
+  let d = A.draftFor('people', constitution());
+  d = A.pick(d, 'who', 'nobody');
+  assert.equal(d.rule, 'vacant');
+  assert.deepEqual(j(A.change(d))[0].inserted, 'no one yet');
+  d = A.pick(d, 'who', 'rank:metic+');
+  assert.ok(DR.SITTING_RULE_KEYS.includes(d.rule), 'a sitting gets a sitting rule back');
+  d = A.pick(d, 'rule', 'unanimous');
+  assert.equal(d.rule, 'unanimous');
+  assert.equal(A.pick(d, 'who', 'rank:everyone'), d, 'not a seat on offer');
+  assert.equal(A.pick(d, 'rule', 'vacant'), d, 'vacant is not a sitting rule');
+  assert.equal(A.pick(d, 'rule', 'whatever'), d);
+  d = A.pick(d, 'who', 'gate');
+  assert.equal(A.changed(d), false, 'back to as today is no change');
+  assert.deepEqual(A.change(d), []);
+  assert.match(A.check(d), /how it works today/);
+});
+
+test('the request is the one the server\'s validator accepts, and the card reads it back word for word', () => {
+  for (const [area, who, rule] of [['review', 'rank:archon', 'consent'], ['treasury', 'rank:metic+', 'majority'], ['people', 'nobody', null], ['rules', 'rank:xenos+', 'signoff']]) {
+    let d = A.draftFor(area, constitution());
+    d = A.pick(d, 'who', who);
+    if (rule) d = A.pick(d, 'rule', rule);
+    assert.equal(A.request(d), null, 'no reason, no request');
+    assert.match(A.check(d), /Say why/);
+    d = A.pick(d, 'reason', '  Three pieces of work are waiting.  ');
+    const req = A.request(d);
+    assert.equal(req.method, 'POST');
+    assert.equal(req.url, '/api/bongos/government/board/decision-rules');
+    assert.equal(req.body.rationale_md, 'Three pieces of work are waiting.');
+    const v = DR.validateDecisionRulesProposal(req.body.rules);
+    assert.equal(v.ok, true, `${area}: ${v.reason}`);
+    assert.equal(DR.changesAnything(v.rules, []), true, 'a change the server will not refuse as no_change');
+    // the card the council votes on, over the amendment as the server stores it
+    const stored = { subject_type: 'constitutional_amendment', subject: { kind: 'decision_rules', proposed: { decision_rules: j(v.rules) } } };
+    const docket = { buildings: [{ key: area, decision: constitution().decision_rules.areas.find((r) => r.area === area) }] };
+    assert.deepEqual(j(C.change(stored, docket, { board: BOARD }).rows), j(A.change(d)), `${area}: drafted words = voted words`);
+  }
+});
+
+test('the Charter is the board: its draft is a constitution amendment of members and pass rule, through /board/items', () => {
+  let d = A.draftFor('charter', constitution());
+  assert.equal(d.charter, true);
+  assert.ok(!d.whoOptions.some((o) => o.value === 'gate' || o.value === 'nobody'), 'the charter is never as-today or empty');
+  assert.deepEqual(d.ruleOptions.map((o) => o.value), ['first', 'consent', 'majority', 'unanimous'], 'the board\'s four pass rules');
+  assert.equal(d.rule, 'consent');
+  assert.deepEqual(j(A.change(d)), j(C.change({ subject: { kind: 'constitution', proposed: { pass_rule: 'consent' } } }, null, { board: { pass_rule: 'majority' } }).rows));
+  assert.equal(j(A.change(d))[0].label, 'how it passes');
+  d = A.pick(A.pick(d, 'who', 'rank:metic+'), 'reason', 'More of us should sit.');
+  const req = A.request(d);
+  assert.equal(req.url, '/api/bongos/government/board/items');
+  assert.equal(req.body.subject_type, 'constitutional_amendment');
+  assert.deepEqual(Object.keys(req.body.proposal).sort(), ['close_early_on_full_turnout', 'membership', 'pass_rule', 'window_minutes'], 'a constitution is filed whole, with no field the validator refuses');
+  assert.deepEqual(req.body.proposal, { membership: 'rank:metic+', pass_rule: 'consent', window_minutes: 4320, close_early_on_full_turnout: true });
+  assert.equal(j(A.change(d)).length, 2, 'who sits, and how it passes');
+});
+
+test('a constitution that could not be read drafts nothing, and says so', () => {
+  for (const c of [null, {}, { board: BOARD }, { board: BOARD, decision_rules: null }, { board: BOARD, decision_rules: { areas: [], rules: [] } }]) {
+    const d = A.draftFor('review', c);
+    assert.equal(d.ok, false);
+    assert.equal(A.request(d), null);
+    assert.match(A.check(d), /could not be read/);
+  }
+});
+
+test('the server\'s refusal is said plainly, never as a code', () => {
+  const env = (code, details) => ({ error: { code, message: code, details } });
+  assert.match(A.refusal(403, env('forbidden')), /not yours to do/);
+  assert.match(A.refusal(401, env('unauthorized')), /Sign in/);
+  assert.match(A.refusal(409, env('no_change', { reason: 'every building named is already decided this way' })), /already is how it works/);
+  assert.match(A.refusal(400, env('invalid_decision_rules', { reason: 'unknown_rank', rank_key: 'council' })), /no such rank/);
+  assert.equal(A.refusal(400, env('invalid_decision_rules', { reason: 'too_many_rows' })), 'The server refused it: too many rows.');
+  assert.equal(A.refusal(409, env('proposer_would_lose_their_seat', { what_this_means: 'You would no longer sit on the board.' })), 'You would no longer sit on the board.');
+  assert.equal(A.refusal(0, {}), 'It could not be done just now.');
+  for (const s of [A.refusal(400, env('invalid_decision_rules', { reason: 'bad_rule' })), A.refusal(403, env('forbidden'))]) assert.doesNotMatch(s, /_/);
+});
+
+test('the model is pure', () => {
+  const src = read('street-amend.js').replace(/^\s*\/\/.*$/gm, '');
+  assert.doesNotMatch(src, /document\.|fetch\(|Date\.now|Math\.random|innerHTML/);
+  const d = A.draftFor('review', constitution());
+  assert.deepEqual(j(A.draftFor('review', constitution())), j(d));
+  A.pick(d, 'who', 'gate');
+  assert.equal(d.decided_by, 'rank:archon', 'a pick returns a new draft');
+});
+
+// ── the page ────────────────────────────────────────────────────────────────
+
+test('the markup: the draft lives under the button, hidden, and the model loads before the page', () => {
+  const html = read('street.html').replace(/<!--[\s\S]*?-->/g, '');
+  assert.match(html, /id="insideAmend" aria-expanded="false" aria-controls="insideDraft"/);
+  assert.match(html, /<div class="inside-draft" id="insideDraft" hidden><\/div>/);
+  const order = ['street-card.js', 'street-amend.js', 'street.js'].map((f) => html.indexOf(`/builders/${f}?`));
+  assert.ok(order[0] > 0 && order[0] < order[1] && order[1] < order[2], 'card, then the draft model, then the page');
+  const css = read('street.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.ok(css.includes('.inside-draft[hidden] { display: none; }'));
+  assert.match(css, /@media \(max-width: 899px\) \{\s*\.inside-draft__picks \{ grid-template-columns: 1fr; \}/, 'narrow: the picks stack');
+  assert.doesNotMatch(css.slice(css.indexOf('.inside-draft')), /#[0-9a-f]{3,8}\b/i, 'tokens only');
+  assert.doesNotMatch(read('street.js'), /not built yet/);
+});
+
+function fakeDom() {
+  const byId = new Map();
+  const focused = { el: null };
+  const mk = (tag) => ({
+    tagName: tag, attrs: {}, kids: [], className: '', listeners: {}, _text: '', hidden: false, value: undefined,
+    style: { setProperty(k, v) { this[k] = v; } },
+    clientWidth: 1440, clientHeight: 708, offsetLeft: 0, scrollLeft: 0, parentNode: null,
+    get children() { const a = this.kids.slice(); a[Symbol.isConcatSpreadable] = false; return a; },
+    get firstChild() { return this.kids[0] || null; },
+    setAttribute(k, v) { this.attrs[k] = String(v); if (k === 'id') byId.set(String(v), this); },
+    getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; },
+    appendChild(c) { this.kids.push(c); c.parentNode = this; return c; },
+    removeChild(c) { this.kids = this.kids.filter((x) => x !== c); return c; },
+    addEventListener(t, fn) { (this.listeners[t] = this.listeners[t] || []).push(fn); },
+    fire(t, e = {}) { return (this.listeners[t] || []).map((fn) => fn({ type: t, preventDefault() {}, ...e })); },
+    focus() { focused.el = this; },
+    set textContent(v) { this._text = String(v); this.kids = []; },
+    get textContent() { return this._text; },
+    get innerHTML() { throw new Error('no innerHTML'); },
+    set innerHTML(v) { throw new Error('no innerHTML'); },
+  });
+  const html = read('street.html').replace(/<!--[\s\S]*?-->/g, '');
+  for (const id of [...html.matchAll(/id="([A-Za-z]+)"/g)].map((m) => m[1])) {
+    const el = mk('x');
+    el.setAttribute('id', id);
+    const tag = new RegExp(`<[^>]*\\bid="${id}"[^>]*>`).exec(html);
+    if (tag && /\shidden(?=[\s>])/.test(tag[0])) el.hidden = true;
+  }
+  const document = { documentElement: mk('html'), getElementById: (id) => byId.get(id) || null, createElement: (t) => mk(t), createElementNS: (_ns, t) => mk(t) };
+  return { document, byId, focused };
+}
+const all = (el) => [el, ...el.kids.flatMap(all)];
+const textOf = (el) => all(el).map((n) => n._text).filter(Boolean).join(' | ');
+const tick = () => new Promise((r) => setTimeout(r, 0));
+
+async function bootPage({ hash = '#building=review', cons = constitution(), answer = () => ({ status: 201, body: { ok: true, item: { id: 77 }, amendment: { id: 5 } } }) } = {}) {
+  const { document, byId, focused } = fakeDom();
+  const gets = [], posts = [], history = [];
+  const location = { hash };
+  const window = {
+    innerWidth: 1440, innerHeight: 900, location,
+    localStorage: { getItem: () => null, setItem() {} },
+    matchMedia: () => ({ matches: false, addEventListener() {} }),
+    addEventListener() {},
+    history: { pushState(_s, _t, url) { history.push(url); location.hash = ''; } },
+  };
+  const feeds = {
+    '/api/bongos/government/docket': { viewer: { id: '95' }, counts: { needs: 0, moving: 0, settled: 0 }, line: '', matters: [], buildings: S.CIVIC_KEYS.map((key) => ({ key, name: key, matter_ids: [] })), sources: [], readings: [] },
+    '/api/bongos/goals': { goals: [] },
+    '/api/bongos/goals/rollups': { rollups: [] },
+    '/api/bongos/government/constitution': cons,
+  };
+  const fetch = (url, opts = {}) => {
+    if (opts.method === 'POST') {
+      posts.push({ url, body: JSON.parse(opts.body) });
+      const a = answer(url);
+      return Promise.resolve({ ok: a.status < 300, status: a.status, json: async () => a.body });
+    }
+    gets.push(url);
+    const body = feeds[url];
+    return Promise.resolve(body == null ? { ok: false, status: 500, json: async () => ({}) } : { ok: true, status: 200, json: async () => body });
+  };
+  const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite, Map, setTimeout, clearTimeout });
+  ctx.globalThis = ctx;
+  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-amend.js', 'street.js']) vm.runInContext(read(f), ctx);
+  await window.GovStreetPage.ready;
+  await tick();
+  return { window, byId, focused, gets, posts, history };
+}
+
+test('change how this works opens the drafted amendment: struck, inserted, who, how, why', async () => {
+  const p = await bootPage();
+  const box = p.byId.get('insideDraft');
+  assert.equal(box.hidden, true);
+  await p.byId.get('insideAmend').fire('click')[0];
+  assert.ok(p.gets.includes('/api/bongos/government/constitution'), 'the rule in force is read fresh');
+  assert.equal(box.hidden, false);
+  assert.equal(p.byId.get('insideAmend').attrs['aria-expanded'], 'true');
+  const del = all(box).find((n) => n.tagName === 'del'), ins = all(box).find((n) => n.tagName === 'ins');
+  assert.equal(del.textContent, 'whoever may mark work as meeting its checks, decides alone');
+  assert.equal(ins.textContent, 'the archon rank, passes unless someone objects');
+  assert.equal(p.focused.el, p.byId.get('insideDraftWho'), 'focus lands on who decides');
+  assert.equal(p.byId.get('insideDraftWho').kids.length, 6);
+  assert.equal(p.byId.get('insideDraftRule').value, 'consent');
+  // a pick redraws the words and keeps focus where it was
+  const who = p.byId.get('insideDraftWho');
+  who.value = 'nobody';
+  who.fire('change');
+  assert.equal(all(box).find((n) => n.tagName === 'ins').textContent, 'no one yet');
+  assert.ok(!all(box).some((n) => n.attrs.id === 'insideDraftRule'), 'an empty building has no rule to pick');
+  assert.match(textOf(box), /nothing is decided until someone holds it/);
+  assert.equal(p.focused.el.attrs.id, 'insideDraftWho');
+  // a feed landing mid-sentence leaves the draft alone
+  const before = p.byId.get('insideDraftWhy');
+  before.value = 'half a thought';
+  before.fire('input');
+  await p.window.GovStreetPage.load();
+  assert.equal(p.byId.get('insideDraftWhy'), before, 'the same textarea, not a fresh one');
+  // not now closes it and gives focus back to the button
+  all(box).find((n) => n.tagName === 'button' && n._text === 'not now').fire('click');
+  assert.equal(box.hidden, true);
+  assert.equal(p.byId.get('insideAmend').attrs['aria-expanded'], 'false');
+  assert.equal(p.focused.el, p.byId.get('insideAmend'));
+});
+
+test('filing: no reason is refused in place; a filed amendment goes to the Charter, once, and the street answers', async () => {
+  const p = await bootPage();
+  await p.byId.get('insideAmend').fire('click')[0];
+  await p.byId.get('insideDraftFile').fire('click')[0];
+  assert.equal(p.posts.length, 0, 'nothing is sent without a reason');
+  assert.match(p.byId.get('insideDraftError').textContent, /Say why/);
+  assert.equal(p.byId.get('insideDraftError').attrs.role, 'alert');
+  assert.equal(p.focused.el, p.byId.get('insideDraftWhy'));
+  const why = p.byId.get('insideDraftWhy');
+  why.value = 'Three pieces of finished work are waiting.';
+  const first = p.byId.get('insideDraftFile').fire('click')[0];
+  await p.byId.get('insideDraftFile').fire('click')[0];
+  await first;
+  assert.equal(p.posts.length, 1, 'one click files once');
+  assert.deepEqual(p.posts[0], { url: '/api/bongos/government/board/decision-rules', body: { rules: [{ area: 'review', decided_by: 'rank:archon', rule: 'consent' }], rationale_md: 'Three pieces of finished work are waiting.' } });
+  assert.equal(p.byId.get('streetToast').hidden, false);
+  assert.equal(p.byId.get('streetToast').textContent, 'Filed. Your amendment to Review is on the Charter for the council to vote on.');
+  assert.deepEqual(p.history, ['/builders/street'], 'back to the street, where the Charter pin appears');
+  assert.equal(p.byId.get('streetInside').hidden, true);
+});
+
+test('a refusal from the server is said in the draft, and the draft stays to be changed', async () => {
+  const p = await bootPage({ answer: () => ({ status: 403, body: { error: { code: 'forbidden', message: 'missing permission board.item.open' } } }) });
+  await p.byId.get('insideAmend').fire('click')[0];
+  p.byId.get('insideDraftWhy').value = 'Because.';
+  await p.byId.get('insideDraftFile').fire('click')[0];
+  assert.equal(p.posts.length, 1);
+  assert.match(p.byId.get('insideDraftError').textContent, /not yours to do/);
+  assert.equal(p.byId.get('insideDraft').hidden, false);
+  assert.equal(p.history.length, 0, 'still in the building');
+  assert.equal(p.byId.get('streetToast').hidden, true);
+});
+
+test('a constitution that cannot be read says so where the draft would be', async () => {
+  const p = await bootPage({ cons: null });
+  await p.byId.get('insideAmend').fire('click')[0];
+  assert.equal(p.byId.get('insideDraft').hidden, true);
+  assert.equal(p.byId.get('insideAmendNote').hidden, false);
+  assert.match(p.byId.get('insideAmendNote').textContent, /could not be read/);
+});

package/tests/hall_street_inside.mjs

@@ -475,8 +475,10 @@ test('picking a floor moves the SAME lift node and re-enters the chosen block; d
   assert.equal(p.byId.get('insideDrawers').children[1].attrs['aria-pressed'], 'true');
   assert.equal(p.byId.get('insideAmendNote').hidden, true);
   p.byId.get('insideAmend').fire('click');
-  assert.equal(p.byId.get('insideAmendNote').hidden, false, 'change how this works says it is not built yet, rather than nothing');
-  assert.match(p.byId.get('insideAmendNote').textContent, /not built yet/);
+  await new Promise((r) => setTimeout(r, 0));
+  // the draft itself is tests/hall_street_amend.mjs (task 1004530); with no constitution to read it says so, never nothing
+  assert.equal(p.byId.get('insideAmendNote').hidden, false, 'change how this works answers, rather than nothing');
+  assert.match(p.byId.get('insideAmendNote').textContent, /could not be read/);
 });
 
 test('a table row opens the short card; Escape gives focus back to the row; back to the street returns to the door', async () => {

package/tests/rank_tier_single_source.mjs

@@ -124,6 +124,11 @@ const STATIC_LADDER_FILES = [
   // match the canonical order or the example teaches a ladder that does not
   // exist.
   'modules/hall-ui/public/government.js',
+  // task 1004530: the street's drafted amendment offers the rank ladder as the
+  // seats a building can be handed to (rank:<key>+). Browser code, so a mirror;
+  // tests/hall_street_amend.mjs pins GovAmend.RANKS equal to the server's
+  // membership-predicate RANK_ORDER.
+  'modules/hall-ui/public/street-amend.js',
   // task 1002487: the pure agent-definition validator applies the ADR 0043
   // sub-Metic floor to an agent's declared scope, so it needs the ladder to
   // compare against. It is one of the "dependency-free" cases this array exists