@bongos/core 1.21.8 → 1.21.10

package/modules/government/routes/government.js

@@ -122,6 +122,10 @@ const governmentPort = {
   // `charter` block. Opening a sitting decides nothing; the vote does.
   proposeCharter: board.proposeCharter,
   genesisStageStatus: board.genesisStageStatus,
+  // task 1004529 — who decides what. The table, resolved, and the check a
+  // building's own direct route runs before letting one builder act alone.
+  decisionRulesView: board.decisionRulesView,
+  checkActAlone: board.checkActAlone,
 };
 
 function registerSeams() {
@@ -225,6 +229,31 @@ module.exports = function buildGovernmentRouter() {
     }
     return rank;
   }
+  // WHO DECIDES AT PEOPLE (task 1004529). Giving or taking a custom rank is
+  // People's own act, and the project's decision-rules table says who may do it
+  // alone. As today (the default row) the route's own permission is the whole
+  // gate, unchanged. Once a passed amendment hands People to a sitting, one
+  // builder may no longer do it alone — the route refuses and names the matter
+  // route instead — unless the row's rule lets a seated member decide alone and
+  // this builder is seated. Server-side, per request, uncached (ADR 0016).
+  // Fail-CLOSED: an unreadable row refuses rather than waving the act through.
+  async function peopleMayActAlone(req, res) {
+    let out;
+    try {
+      out = await board.checkActAlone('people', req.builder.id);
+    } catch (err) {
+      log.error('[gds] people decision rule unreadable', err);
+      res.fail('decision_rule_unreadable', { status: 503, message: 'who decides at People could not be read just now' });
+      return false;
+    }
+    if (out.ok) return true;
+    res.fail('decided_by_sitting', 409, {
+      area: out.area, rule: out.rule, who: out.who,
+      what_this_means: out.what_this_means, open_with: out.open_with,
+    });
+    return false;
+  }
+
   const ARCHON = 'archon';
   const ARCHON_REASON = 'the Archon rank holds every permission and is immutable — it is the rank that can never be locked out of this tab (ADR 0172)';
   const ASSIGN_REASON = 'a seeded rank is assigned by rank (R95b sync); change the builder\'s rank instead';
@@ -447,6 +476,7 @@ module.exports = function buildGovernmentRouter() {
     try {
       const rank = await loadAssignableRank(res, rankKey);
       if (rank === null) return;
+      if (!(await peopleMayActAlone(req, res))) return;
       const assigned = await db.assignRank({
         builderId: req.body.builder_id,
         rankKey,
@@ -472,6 +502,7 @@ module.exports = function buildGovernmentRouter() {
     try {
       const rank = await loadAssignableRank(res, rankKey);
       if (rank === null) return;
+      if (!(await peopleMayActAlone(req, res))) return;
       const removed = await db.unassignRank({ builderId, rankKey });
       res.json({ ok: true, builder_id: builderId, rank_key: rankKey, removed });
     } catch (err) {
@@ -678,6 +709,90 @@ module.exports = function buildGovernmentRouter() {
     }
   });
 
+  // rank: perm board.item.open — propose a change to WHO DECIDES WHAT (task
+  // 1004529): one or more buildings' rows of the decision-rules table, filed as
+  // an amendment of kind 'decision_rules' and sat under the constitution IN
+  // FORCE, like every amendment. Nothing here changes the table — only the
+  // sitting passing does, inside its closing transaction. The same atom as
+  // proposing any amendment.
+  //
+  // Body: { rules: [{ area, decided_by, rule?, who? }], rationale_md? }
+  //   area       ∈ rules disputes people planning automation review release treasury
+  //              (the charter is the board — change it with a constitution amendment)
+  //   decided_by 'gate' (as today) | 'nobody' (vacant) | rank:<key> | rank:<key>+ | rank:a,b
+  //   rule       decide | first | consent | majority | unanimous | signoff (vacant with 'nobody';
+  //              none with 'gate')
+  //   who        the seat in words, display only ("Mira under $50, the council above")
+  router.post('/government/board/decision-rules', api.requireBuilder, api.requirePermission('board.item.open'), async (req, res) => {
+    if (validateOrRespond(req, res, {
+      rules: { required: true, type: 'array' },
+      rationale_md: { type: 'string', maxLength: 5000 },
+    })) return;
+    try {
+      const out = await board.proposeDecisionRules({
+        rules: req.body.rules,
+        rationaleMd: req.body.rationale_md ?? null,
+        proposedBy: req.builder.id,
+      });
+      if (!out.ok) {
+        if (out.reason === 'no_change') return res.fail('no_change', 409, { reason: 'every building named is already decided this way' });
+        return res.fail('invalid_decision_rules', 400, {
+          reason: out.reason,
+          ...(out.area ? { area: out.area } : {}),
+          ...(out.field ? { field: out.field } : {}),
+          ...(out.expected ? { expected: out.expected } : {}),
+          ...(out.rank_key ? { rank_key: out.rank_key } : {}),
+        });
+      }
+      res.status(201).json({ ok: true, amendment: out.amendment, item: out.item, rules: out.rules });
+    } catch (err) {
+      log.error('[gds] POST /government/board/decision-rules', err);
+      res.fail('propose_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
+  // rank: perm board.item.open — put a MATTER to a building's sitting (task
+  // 1004529): the board's new subjects, one per building other than the
+  // charter. Refused unless the building's row names a sitting — under the
+  // default rows every building is decided as today and this route opens
+  // nothing. The sitting is snapshotted from the row (who and how).
+  //
+  // Body: { area, title, detail_md?, action? }
+  //   action (People only): { type: 'assign_rank' | 'unassign_rank', builder_id, rank_key }
+  //   — carried out when the sitting passes, under the same walls as the direct route.
+  router.post('/government/board/matters', api.requireBuilder, api.requirePermission('board.item.open'), async (req, res) => {
+    if (validateOrRespond(req, res, {
+      area: { required: true, type: 'string', maxLength: 32 },
+      title: { required: true, type: 'string', maxLength: 200 },
+      detail_md: { type: 'string', maxLength: 5000 },
+      action: { type: 'object' },
+    })) return;
+    try {
+      const out = await board.openMatter({
+        area: req.body.area,
+        title: req.body.title,
+        detailMd: req.body.detail_md ?? null,
+        action: req.body.action ?? null,
+        proposedBy: req.builder.id,
+      });
+      if (!out.ok) {
+        if (out.reason === 'decided_by_gate' || out.reason === 'no_one_holds_this') {
+          return res.fail(out.reason, 409, { area: out.area, ...(out.gate ? { gate: out.gate } : {}), what_this_means: out.what_this_means });
+        }
+        return res.fail('invalid_matter', 400, {
+          reason: out.reason,
+          ...(out.field ? { field: out.field } : {}),
+          ...(out.expected ? { expected: out.expected } : {}),
+          ...(out.rank_key ? { rank_key: out.rank_key } : {}),
+        });
+      }
+      res.status(201).json({ ok: true, matter: out.matter, item: out.item, decided: out.decided });
+    } catch (err) {
+      log.error('[gds] POST /government/board/matters', err);
+      res.fail('matter_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
   // rank: perm board.vote.cast — cast a vote on an open board item (R08 of goal
   // 1000069, ADR 0175). The atom FLOORS AT XENOS deliberately (the R04 carry-
   // note): the permission is only the coarse gate, and the real wall is the

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.8",
+  "version": "1.21.10",
   "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

@@ -8804,5 +8804,17 @@
       "id": "1004441",
       "text": "Checked and signed off on the live site: artists and ideators now read as their own craft on profiles, the builders list and the status page. Their earnings charts show, and builders can choose their main role in Settings."
     }
+  ],
+  "1.21.9": [
+    {
+      "id": "1004529",
+      "text": "Each project can now set who decides what in each part of its government: the charter, rules, disputes, people, planning, automation, review, release and treasury. For each part it names who decides and how: one person decides"
+    }
+  ],
+  "1.21.10": [
+    {
+      "id": "1004545",
+      "text": "The list of every piece of on-screen text now comes out the same on a Windows computer as on the build server, so updating it on Windows no longer breaks the automatic checks. Notes the authors left inside page source are no l"
+    }
   ]
 }

package/scripts/gds/copy-inventory.js

@@ -119,8 +119,12 @@ function lineAt(starts, index) {
 
 // Does this look like prose a person reads, rather than code that happens to be a
 // string? Conservative on purpose — a false positive costs an artist's attention.
+//
+// Measured with CRLF folded to LF: the length cap must give a multi-line run the
+// same verdict on a Windows checkout as on CI's, or the committed registry differs
+// by platform (task 1004545 — a 396-char run was 403 under CRLF and vanished).
 function looksLikeCopy(raw) {
-  const s = String(raw).trim();
+  const s = String(raw).replace(/\r\n/g, '\n').trim();
   if (s.length < 4 || s.length > 400) return false;
   if (!/[A-Za-z]{2}/.test(s)) return false;               // needs actual letters
   if (!/\s/.test(s) && !/[.!?]$/.test(s)) return false;   // one bare word is a token
@@ -155,12 +159,25 @@ function trimmedSpan(group, groupStart) {
   return { start: groupStart + lead, end: groupStart + group.length - trail };
 }
 
-// Strip <script>/<style> bodies so their contents are not read as page text.
-// Replaced with spaces of equal length so every line number stays truthful.
+// Strip HTML comments and <script>/<style> bodies so their contents are not read
+// as page text. Replaced with spaces of equal length so every line number — and
+// every span copy-apply.js writes through — stays truthful.
+//
+// Comments are author notes, never something a visitor reads (task 1004545: a
+// header comment's literal `<a>` opened a fake text node). ONE alternation, not
+// three passes, so whichever construct opens first wins, as in a browser: a
+// `<style>` named inside a comment cannot swallow the page up to the real
+// `</style>`, and a `<!--` inside a script string cannot eat past `</script>`.
+//
+// A comment keeps its `<` and `>` and blanks only its inside: marker comments
+// (`<!--apex-only:start-->`, `<!--brand-if:…-->`) split a sentence into segments
+// the server shows or drops independently, so each segment must stay its own row
+// with its own stable id — blanking the whole comment would fuse them.
 function stripEmbedded(html) {
-  return html
-    .replace(/<script\b[\s\S]*?<\/script>/gi, (m) => m.replace(/[^\n]/g, ' '))
-    .replace(/<style\b[\s\S]*?<\/style>/gi, (m) => m.replace(/[^\n]/g, ' '));
+  return html.replace(/<!--[\s\S]*?-->|<script\b[\s\S]*?<\/script>|<style\b[\s\S]*?<\/style>/gi, (m) => {
+    const blank = m.replace(/[^\r\n]/g, ' ');
+    return m.startsWith('<!--') ? `<${blank.slice(1, -1)}>` : blank;
+  });
 }
 
 function fromHtml({ source, rel }) {
@@ -193,7 +210,7 @@ function fromHtml({ source, rel }) {
 
   // 3. <title> is the page's own name — always copy.
   const titleRe = /<title>([^<]{2,200})<\/title>/gi;
-  while ((m = titleRe.exec(source)) !== null) {
+  while ((m = titleRe.exec(cleaned)) !== null) {
     const titleStart = m.index + '<title>'.length;
     out.push({ text: m[1].replace(/\s+/g, ' ').trim(), file: rel, line: lineAt(starts, m.index), origin: 'html-title', confidence: 'certain', ...trimmedSpan(m[1], titleStart) });
   }

package/src/bongos/route-rank-check.js

@@ -281,6 +281,12 @@ const GOVERNMENT_PINS = {
   // task 1004523: the governor's docket — every matter awaiting a governor. The
   // coarse gate is the room's; each source inside is scoped to its own atom.
   'GET /government/docket': 'perm:board.vote.cast',
+  // task 1004529: who decides what — a change to the decision-rules table is an
+  // amendment by another door (same atom as proposing one), and a building's
+  // matter is put to its sitting by the same atom. Only a passed amendment
+  // writes the table; neither route does.
+  'POST /government/board/decision-rules': 'perm:board.item.open',
+  'POST /government/board/matters': 'perm:board.item.open',
 };
 
 // Module-scoped privileged-rank pins: a privileged route that lives in a FEATURE

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.8'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.10'; // 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/copy_inventory.mjs

@@ -98,6 +98,68 @@ test('stripEmbedded keeps line numbers truthful', () => {
   assert.equal(copy.line, 6, 'a stripped script must not shift the lines after it — a wrong line number sends an artist to the wrong place');
 });
 
+// Task 1004545. street.html's header comment held a literal `<a>`, which opened a
+// fake text node; under CRLF that run was 403 characters, under LF 396 — so a
+// Windows regen dropped a row CI kept and redded "the committed artifacts match".
+// The fixture rebuilds both halves: a tag inside a comment, and a run sized to
+// straddle the cap.
+// Eight 45-char lines under a 28-char head: 396 chars on LF, 404 on CRLF.
+const NEAR_CAP_LINES = Array.from({ length: 8 }, () => `   ${'word '.repeat(8)}s.`);
+const EOL_FIXTURE = [
+  '<!doctype html>',
+  '<!-- Author note: a building is a door (an <a>) to its interior.',
+  '     The template is street.css, the <style> on the tokens.',
+  '-->',
+  '<style>.x { color: red; }</style>',
+  '<p>A real sentence on the page,',
+  ...NEAR_CAP_LINES.slice(0, -1),
+  `${NEAR_CAP_LINES.at(-1)}</p>`,
+  '<p title="A tooltip a person reads">Second real line.</p>',
+].join('\n');
+
+test('LF and CRLF checkouts extract identical rows (task 1004545)', () => {
+  const lf = inv.fromHtml({ source: EOL_FIXTURE, rel: 'p.html' });
+  const crlf = inv.fromHtml({ source: EOL_FIXTURE.replace(/\n/g, '\r\n'), rel: 'p.html' });
+  const strip = (rows) => rows.map(({ text, line, origin }) => ({ text, line, origin }));
+  assert.deepEqual(strip(crlf), strip(lf), 'the registry must not depend on the checkout\'s line endings');
+  const run = EOL_FIXTURE.slice(EOL_FIXTURE.indexOf('A real'), EOL_FIXTURE.indexOf('</p>'));
+  assert.ok(run.length <= 400 && run.replace(/\n/g, '\r\n').length > 400, 'the fixture must straddle the cap, or this test proves nothing');
+  // The multi-line sentence sits under the cap only when CRLF counts as one
+  // character — so this is the case that reds if the length rule regresses.
+  assert.ok(lf.some((r) => r.text.startsWith('A real sentence on the page')), 'a multi-line run under the cap is copy on LF');
+  assert.ok(crlf.some((r) => r.text.startsWith('A real sentence on the page')), 'and the same run is copy on CRLF');
+});
+
+test('HTML comments are never copy, and a tag named inside one swallows nothing', () => {
+  const rows = inv.fromHtml({ source: EOL_FIXTURE, rel: 'p.html' });
+  const texts = rows.map((r) => r.text);
+  assert.ok(!texts.some((t) => /Author note|its interior|the tokens/.test(t)), 'comment text is an author note, not page copy');
+  // The comment names `<style>`: a strip pass that ran style-first would blank from
+  // there to the real </style> — harmless here, but the same shape with <script>
+  // ahead of real copy would erase it. Both real lines must survive.
+  assert.ok(texts.includes('Second real line.'));
+  assert.ok(texts.includes('A tooltip a person reads'));
+  const real = rows.find((r) => r.text === 'Second real line.');
+  assert.equal(real.line, 15, 'a stripped comment must not shift the lines after it');
+  // A span still addresses the file's own characters (copy-apply writes through it).
+  assert.equal(EOL_FIXTURE.slice(real.start, real.end), 'Second real line.');
+});
+
+test('a marker comment still splits copy into the segments the server drops independently', () => {
+  // The landing footer: the first sentence is apex-only, the second is not. One
+  // fused row would give both a new id and hide that a child instance drops half.
+  const src = '<p><!--apex-only:start-->A non-profit, capture-resistant commons. <!--apex-only:end-->Built by agents, on the platform.</p>';
+  const texts = inv.fromHtml({ source: src, rel: 'p.html' }).map((r) => r.text);
+  assert.ok(texts.includes('A non-profit, capture-resistant commons.'));
+  assert.ok(texts.includes('Built by agents, on the platform.'));
+});
+
+test('a comment opener inside a script string does not eat the page after it', () => {
+  const src = '<script>const s = "<!--";</script>\n<p>Copy after the script.</p>\n<!-- x -->';
+  const texts = inv.fromHtml({ source: src, rel: 'p.html' }).map((r) => r.text);
+  assert.ok(texts.includes('Copy after the script.'));
+});
+
 test('the registry is deterministic and internally consistent', () => {
   const a = inv.buildRegistry();
   const b = inv.buildRegistry();

package/tests/government_abuse_matrix.mjs

@@ -120,6 +120,9 @@ const stub = {
   unassignRank: async () => true,
   listRanksWithGrants: async () => [],
   listAssignments: async () => [],
+  // task 1004529: People's row is read before a rank is given or taken. No rows
+  // = every building as today, so this matrix's walls are the route's own.
+  listDecisionRules: async () => [],
 };
 const REAL = {};
 for (const k of Object.keys(stub)) {