@bongos/core 1.23.20 → 1.23.22

package/modules/copy-desk/chrome-pages.js

@@ -0,0 +1,178 @@
+// modules/copy-desk/chrome-pages.js — the shared page chrome as its own pages
+// (task 1004904, ADR 0341 D3's "shared" placement).
+//
+// The reader (scripts/bongos/page-reader.js) records every visible line of a page,
+// and the skip link, top bar, navigation and footer are on every page of a
+// surface, so each page's reading carried the same few dozen lines. An artist
+// tweaking one page was shown, and could rewrite, words that change on all of
+// them. This is the read-side split:
+//
+//   * A real page's reading loses its chrome lines. They are not shown, not
+//     editable, not counted, not in its drift.
+//   * Each surface gains one page per chrome section: "<surface>:top-bar",
+//     "<surface>:navigation", "<surface>:footer", "<surface>:skip-link". Each
+//     lists every DISTINCT line of that section once, in the order it first
+//     appears, and goes through the same claim, draft, submit and approve flow
+//     as any page.
+//
+// PURE, like pages.js: it derives from the two committed artifacts and writes
+// nothing. The generators and the committed files are untouched, so the
+// reader's --stale check and the registry are exactly as they were, and a
+// surface with no chrome gains no page.
+
+'use strict';
+
+const crypto = require('node:crypto');
+
+// section name the reader writes -> the page it becomes
+const CHROME = Object.freeze([
+  Object.freeze({ section: 'top bar', slug: 'top-bar', title: 'Top bar' }),
+  Object.freeze({ section: 'navigation', slug: 'navigation', title: 'Navigation' }),
+  Object.freeze({ section: 'footer', slug: 'footer', title: 'Footer' }),
+  Object.freeze({ section: 'skip link', slug: 'skip-link', title: 'Skip link' }),
+  Object.freeze({ section: 'sidebar', slug: 'sidebar', title: 'Sidebar' }),
+]);
+
+const CHROME_SECTIONS = new Set(CHROME.map((c) => c.section));
+
+function isChromeLine(line) {
+  return !!line && line.placement === 'shared' && CHROME_SECTIONS.has(line.section);
+}
+
+function hash(parts) {
+  return crypto.createHash('sha256').update(parts.join('\n')).digest('hex').slice(0, 16);
+}
+
+function key(n) { return `L${String(n).padStart(4, '0')}`; }
+
+function countsOf(lines) {
+  return {
+    lines: lines.length,
+    placed: lines.filter((l) => l.placement === 'placed').length,
+    shared: lines.filter((l) => l.placement === 'shared').length,
+    unplaced: lines.filter((l) => l.placement === 'unplaced').length,
+  };
+}
+
+// The chrome page ids a surface can have, so a caller can tell one from a page.
+// A reading names its surface; one that does not is read from its id.
+function surfaceOf(page) { return page.surface || String(page.id || '').split(':')[0]; }
+
+function chromePageId(surface, slug) { return `${surface}:${slug}`; }
+function isChromePageId(id) {
+  const m = /^[a-z0-9-]+:([a-z0-9-]+)$/.exec(String(id || ''));
+  return !!m && CHROME.some((c) => c.slug === m[1]);
+}
+
+// readings -> readings, every real page without its chrome and the chrome pages
+// after them. Returns { readings, chrome } where chrome maps a surface to the
+// pages it gained (the inventory is built from it).
+function splitReadings(readings) {
+  const pages = Array.isArray(readings && readings.pages) ? readings.pages : [];
+  const real = [];
+  // surface -> slug -> { lines: Map text -> line, from: page, states: Set, sources: Set of pages }
+  const gathered = new Map();
+  const order = [];
+  for (const p of pages) {
+    const lines = Array.isArray(p && p.lines) ? p.lines : [];
+    const kept = [];
+    for (const l of lines) {
+      if (!isChromeLine(l)) { kept.push(l); continue; }
+      const spec = CHROME.find((c) => c.section === l.section);
+      const surface = surfaceOf(p);
+      if (!gathered.has(surface)) { gathered.set(surface, new Map()); order.push(surface); }
+      const bySlug = gathered.get(surface);
+      if (!bySlug.has(spec.slug)) bySlug.set(spec.slug, { spec, lines: new Map(), from: p, states: new Set(), sources: new Set() });
+      const g = bySlug.get(spec.slug);
+      const text = String(l.text);
+      const seen = g.lines.get(text);
+      if (!seen) g.lines.set(text, { ...l });
+      else if (!seen.file && l.file) { seen.file = l.file; seen.line = l.line; seen.string_id = l.string_id; }
+      if (!g.sources.has(p)) {
+        g.sources.add(p);
+        for (const s of p.states_read || []) g.states.add(s);
+      }
+    }
+    if (kept.length === lines.length) { real.push(p); continue; }
+    real.push({
+      ...p,
+      ...(p.counts ? { counts: countsOf(kept) } : {}),
+      lines: kept,
+    });
+  }
+  const chrome = new Map();
+  const made = [];
+  for (const surface of order) {
+    const bySlug = gathered.get(surface);
+    const list = [];
+    for (const spec of CHROME) {
+      const g = bySlug.get(spec.slug);
+      if (!g) continue;
+      const lines = [...g.lines.values()].map((l, i) => ({ ...l, key: key(i + 1) }));
+      const id = chromePageId(surface, spec.slug);
+      made.push({
+        id,
+        surface,
+        title: spec.title,
+        states_read: [...g.states],
+        files_hash: hash([...g.sources].map((s) => String(s.files_hash || ''))),
+        reading_hash: hash(lines.map((l) => `${l.section}\t${l.text}`)),
+        counts: countsOf(lines),
+        omitted: {},
+        notes: [`The ${spec.title.toLowerCase()} shown on every ${surface} page, each line once. Read from ${g.sources.size} pages.`],
+        lines,
+      });
+      list.push({ id, spec, from: g.from, sources: g.sources, lines });
+    }
+    chrome.set(surface, list);
+  }
+  const out = { ...readings, pages: [...real, ...made] };
+  if (readings.counts) {
+    // Totals are counted from the lines, not from each page's own counts: a
+    // reading need not carry them.
+    const all = countsOf(out.pages.flatMap((p) => p.lines || []));
+    out.counts = { ...readings.counts, pages: out.pages.length, ...all };
+  }
+  return { readings: out, chrome };
+}
+
+// inventory -> inventory, with the chrome pages of each surface after that
+// surface's own pages. A chrome page opens on the first page it was read from
+// (the live page shows it), and its files are the ones its lines come from, so
+// the claim's touches and the "changed since" read name the shell, not a page.
+function addChromePages(inventory, chrome) {
+  const pages = Array.isArray(inventory && inventory.pages) ? inventory.pages : [];
+  const byId = new Map(pages.map((p) => [p.id, p]));
+  const added = [];
+  for (const [surface, list] of chrome) {
+    for (const c of list) {
+      const src = byId.get(c.from.id) || {};
+      const files = [...new Set(c.lines.map((l) => l.file).filter(Boolean))];
+      added.push({
+        id: c.id,
+        surface,
+        module: src.module || null,
+        page: c.spec.slug,
+        id_from: 'shared-chrome',
+        title: c.spec.title,
+        document_title: `${c.spec.title} — shown on every ${surface} page`,
+        path: src.path || null,
+        url: src.url || null,
+        files,
+        states_files: [],
+        states: [],
+      });
+    }
+  }
+  const all = [...pages, ...added];
+  const out = { ...inventory, pages: all };
+  if (inventory.counts) out.counts = { ...inventory.counts, pages: all.length };
+  if (Array.isArray(inventory.surfaces)) {
+    const tally = new Map();
+    for (const p of all) tally.set(p.surface, (tally.get(p.surface) || 0) + 1);
+    out.surfaces = inventory.surfaces.map((s) => ({ ...s, pages: tally.get(s.id) || 0 }));
+  }
+  return out;
+}
+
+module.exports = { isChromeLine, isChromePageId, splitReadings, addChromePages };

package/modules/copy-desk/page-data.js

@@ -24,6 +24,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const chromePages = require('./chrome-pages');
 
 const ROOT = path.resolve(__dirname, '..', '..');
 
@@ -73,7 +74,38 @@ function load(which) {
   return value;
 }
 
-function loadInventory() { return load('inventory'); }
-function loadReadings() { return load('readings'); }
+// The shared chrome (skip link, top bar, navigation, footer) is read out of
+// every page and handed back as pages of its own (chrome-pages.js, task
+// 1004904). Derived per raw load, so the committed files stay what the
+// generators wrote; a WeakMap keeps one derivation per cached read.
+const _derived = new WeakMap();
+function derive() {
+  const rawReadings = load('readings');
+  if (!rawReadings.ok) return null;
+  const hit = _derived.get(rawReadings);
+  if (hit) return hit;
+  const split = chromePages.splitReadings(rawReadings.data);
+  const value = { readings: { ok: true, data: split.readings, at: rawReadings.at }, chrome: split.chrome };
+  _derived.set(rawReadings, value);
+  return value;
+}
+
+const _derivedInventory = new WeakMap();
+function loadInventory() {
+  const raw = load('inventory');
+  if (!raw.ok) return raw;
+  const d = derive();
+  if (!d) return raw;
+  const key = d.readings;
+  const hit = _derivedInventory.get(raw);
+  if (hit && hit.key === key) return hit.value;
+  const value = { ok: true, data: chromePages.addChromePages(raw.data, d.chrome), at: raw.at };
+  _derivedInventory.set(raw, { key, value });
+  return value;
+}
+function loadReadings() {
+  const d = derive();
+  return d ? d.readings : load('readings');
+}
 
 module.exports = { ARTIFACTS, loadInventory, loadReadings, _setRoot };

package/modules/copy-desk/tests/copy_chrome_pages.mjs

@@ -0,0 +1,127 @@
+// modules/copy-desk/tests/copy_chrome_pages.mjs — the shared page chrome as its
+// own pages (task 1004904), pure.
+//
+// The skip link, top bar, navigation and footer are on every page of a surface.
+// A real page's reading must not carry them, and each surface must gain one
+// page per chrome section, each line once. Run over a small hand-made reading
+// (the rules) and over the committed artifacts (the real data holds them).
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const chrome = require('../chrome-pages.js');
+const pageData = require('../page-data.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.stack || err.message}`); }
+}
+
+const L = (key, section, text, placement, row) => ({ key, section, text, placement, ...(row || {}) });
+const READINGS = {
+  counts: { pages: 3, lines: 9, placed: 3, shared: 5, unplaced: 1 },
+  pages: [
+    { id: 'landing:index', surface: 'landing', reading_hash: 'h-index', files_hash: 'f1', states_read: ['in'], lines: [
+      L('L0001', 'skip link', 'Skip to content', 'shared', { file: 'shell.js', line: 9, string_id: 'a1' }),
+      L('L0002', 'top bar', 'Projects', 'shared', { file: 'nav.js', line: 3, string_id: 'a2' }),
+      L('L0003', 'hero', 'Build here', 'placed', { file: 'index.html', line: 4, string_id: 'a3' }),
+    ] },
+    { id: 'landing:account', surface: 'landing', reading_hash: 'h-acct', counts: { lines: 5, placed: 1, shared: 3, unplaced: 1 }, files_hash: 'f2', states_read: ['in', 'out'], lines: [
+      L('L0001', 'skip link', 'Skip to content', 'shared'),
+      L('L0002', 'top bar', 'Projects', 'shared'),
+      L('L0003', 'top bar', 'Sign in', 'shared'),
+      L('L0004', 'hero', 'Your account', 'placed'),
+      L('L0005', 'list', 'Something unplaced', 'unplaced'),
+    ] },
+    // No surface on the reading: it is read from the id.
+    { id: 'status:explore', reading_hash: 'h-exp', files_hash: 'f3', lines: [L('L0001', 'hero', 'Explore', 'placed')] },
+  ],
+};
+const INVENTORY = {
+  counts: { pages: 3, surfaces: 2 },
+  surfaces: [{ id: 'landing', pages: 2 }, { id: 'status', pages: 1 }],
+  pages: [
+    { id: 'landing:index', surface: 'landing', module: 'public-landing', page: 'index', title: 'Home', path: '/', url: 'https://{apex}/', files: ['index.html'] },
+    { id: 'landing:account', surface: 'landing', module: 'public-landing', page: 'account', title: 'Account', path: '/account', url: 'https://{apex}/account', files: ['account.html'] },
+    { id: 'status:explore', surface: 'status', module: 'status-ui', page: 'explore', title: 'Explore', path: '/explore', url: 'https://status.{apex}/explore', files: ['explore.html'] },
+  ],
+};
+
+const split = chrome.splitReadings(READINGS);
+const byId = (rd, id) => rd.pages.find((p) => p.id === id);
+
+test('a real page no longer carries its chrome, and keeps its own lines and keys', () => {
+  assert.deepEqual(byId(split.readings, 'landing:index').lines.map((l) => [l.key, l.section]), [['L0003', 'hero']]);
+  assert.deepEqual(byId(split.readings, 'landing:account').lines.map((l) => l.key), ['L0004', 'L0005']);
+  assert.equal(byId(split.readings, 'landing:index').reading_hash, 'h-index', 'a draft on the reading stays on it');
+  assert.deepEqual(byId(split.readings, 'landing:account').counts, { lines: 2, placed: 1, shared: 0, unplaced: 1 });
+});
+
+test('each chrome section becomes one page per surface, every distinct line once, in first-seen order', () => {
+  const top = byId(split.readings, 'landing:top-bar');
+  assert.deepEqual(top.lines.map((l) => [l.key, l.text]), [['L0001', 'Projects'], ['L0002', 'Sign in']]);
+  assert.deepEqual(byId(split.readings, 'landing:skip-link').lines.map((l) => l.text), ['Skip to content']);
+  assert.equal(byId(split.readings, 'landing:footer'), undefined, 'a surface with no footer gains no footer page');
+  assert.equal(byId(split.readings, 'status:top-bar'), undefined, 'a surface with no chrome gains no chrome page');
+});
+
+test('a chrome line keeps the registry row of its first occurrence that has one', () => {
+  const top = byId(split.readings, 'landing:top-bar').lines[0];
+  assert.deepEqual([top.file, top.line, top.string_id, top.placement], ['nav.js', 3, 'a2', 'shared']);
+});
+
+test('the reading totals follow the pages', () => {
+  assert.equal(split.readings.counts.pages, 5);
+  assert.equal(split.readings.counts.lines, 1 + 2 + 1 + 2 + 1);
+  assert.equal(split.readings.counts.shared, 3);
+});
+
+test('the inventory gains the same pages, after their surface, opening on a page that shows them', () => {
+  const inv = chrome.addChromePages(INVENTORY, split.chrome);
+  assert.deepEqual(inv.pages.map((p) => p.id), ['landing:index', 'landing:account', 'status:explore', 'landing:top-bar', 'landing:skip-link']);
+  const top = inv.pages.find((p) => p.id === 'landing:top-bar');
+  assert.deepEqual([top.surface, top.page, top.title, top.url], ['landing', 'top-bar', 'Top bar', 'https://{apex}/']);
+  assert.deepEqual(top.files, ['nav.js']);
+  assert.equal(inv.counts.pages, 5);
+  assert.deepEqual(inv.surfaces.map((s) => [s.id, s.pages]), [['landing', 4], ['status', 1]]);
+});
+
+test('a chrome page id is told from a page id', () => {
+  assert.equal(chrome.isChromePageId('landing:top-bar'), true);
+  assert.equal(chrome.isChromePageId('landing:index'), false);
+});
+
+test('only a shared line in a chrome section is chrome', () => {
+  assert.equal(chrome.isChromeLine(L('L1', 'top bar', 'x', 'placed')), false);
+  assert.equal(chrome.isChromeLine(L('L1', 'hero', 'x', 'shared')), false);
+  assert.equal(chrome.isChromeLine(L('L1', 'top bar', 'x', 'shared')), true);
+});
+
+test('the committed readings: no real page lists a skip link, top bar, navigation or footer line', () => {
+  const rd = pageData.loadReadings();
+  assert.equal(rd.ok, true);
+  for (const p of rd.data.pages) {
+    if (chrome.isChromePageId(p.id)) continue;
+    const bad = p.lines.filter(chrome.isChromeLine);
+    assert.equal(bad.length, 0, `${p.id} still lists ${bad.length} chrome lines`);
+  }
+});
+
+test('the committed data: every surface that had a top bar has a Top bar page, in both reads', () => {
+  const rd = pageData.loadReadings().data;
+  const inv = pageData.loadInventory().data;
+  for (const surface of ['builders', 'landing', 'status']) {
+    const id = `${surface}:top-bar`;
+    const r = rd.pages.find((p) => p.id === id);
+    assert.ok(r && r.lines.length > 0, `${id} in the readings`);
+    assert.ok(inv.pages.find((p) => p.id === id), `${id} in the inventory`);
+    assert.equal(new Set(r.lines.map((l) => l.text)).size, r.lines.length, `${id} lists each line once`);
+  }
+  assert.equal(rd.pages.length, inv.pages.length, 'the two reads name the same pages');
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);

package/modules/copy-desk/tests/copy_no_cms.mjs

@@ -70,7 +70,7 @@ const stripComments = (src) => src
 // Task 1004435 added routes/copy-desk-artist.js (one artist's approved pages, a
 // read) and artist-stats.js's readArtistPages under it.
 const ROUTE_FILES = fs.readdirSync(path.join(MODULE_DIR, 'routes')).filter((f) => f.endsWith('.js')).sort().map((f) => `routes/${f}`);
-const MODULE_FILES = ['registry.js', 'flags.js', 'proposals.js', 'pages.js', 'page-status.js', 'page-data.js', 'docx.js', 'page-decisions.js', 'artist-stats.js', 'auto-close.js', ...ROUTE_FILES];
+const MODULE_FILES = ['registry.js', 'flags.js', 'proposals.js', 'pages.js', 'page-status.js', 'page-data.js', 'chrome-pages.js', 'docx.js', 'page-decisions.js', 'artist-stats.js', 'auto-close.js', ...ROUTE_FILES];
 
 console.log('copy-desk: NO LIVE CMS');
 

package/modules/government/db.js

@@ -169,6 +169,79 @@ async function grantRankPermission({ rankKey, permissionKey }) {
   return rowCount > 0;
 }
 
+// Add a recommended rank set in ONE transaction and three statements (task
+// 1004929) — the batched form of "createRank, then grantRankPermission per key",
+// which used to cost a read, an insert and one insert per grant for every rank,
+// each its own round trip and none of them atomic. A rank that already exists is
+// LEFT ALONE: it is neither inserted nor granted, and a rank a concurrent call
+// created between the read and the insert is caught by ON CONFLICT DO NOTHING —
+// the batched twin of the old per-row 23505 catch. Grants go only to the ranks
+// THIS call created. Still a dumb write: `permissionKeys` arrive screened against
+// the catalog by the route (routes/government.js), which owns that decision.
+//
+// `ranks`: [{ rankKey, label, description, permissionKeys }], in set order.
+// Returns a Map of rank_key → the permission keys actually granted, in input
+// order, for each rank this call created; a key absent from the Map was skipped.
+async function applyRankSet({ ranks, createdBy }) {
+  const firstByKey = new Map();
+  for (const r of ranks) if (!firstByKey.has(r.rankKey)) firstByKey.set(r.rankKey, r);
+  const wanted = [...firstByKey.values()];
+  const created = new Map();
+  if (wanted.length === 0) return created;
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN');
+    const { rows: existing } = await client.query(
+      `SELECT rank_key FROM government_ranks WHERE rank_key = ANY($1::text[])`,
+      [wanted.map((r) => r.rankKey)],
+    );
+    const have = new Set(existing.map((row) => row.rank_key));
+    const fresh = wanted.filter((r) => !have.has(r.rankKey));
+    if (fresh.length > 0) {
+      // WITH ORDINALITY + ORDER BY keeps the ids in set order, as the loop did.
+      const { rows: inserted } = await client.query(
+        `INSERT INTO government_ranks (rank_key, label, description, is_system, seeded_rank, created_by)
+         SELECT r.rank_key, r.label, r.description, false, NULL, $4::bigint
+           FROM unnest($1::text[], $2::text[], $3::text[]) WITH ORDINALITY AS r(rank_key, label, description, ord)
+          ORDER BY r.ord
+         ON CONFLICT DO NOTHING
+         RETURNING rank_key`,
+        [fresh.map((r) => r.rankKey), fresh.map((r) => r.label), fresh.map((r) => r.description ?? null), createdBy],
+      );
+      const made = new Set(inserted.map((row) => row.rank_key));
+      const grantRanks = [];
+      const grantKeys = [];
+      for (const r of fresh) {
+        if (!made.has(r.rankKey)) continue;
+        created.set(r.rankKey, []);
+        for (const key of new Set(r.permissionKeys)) { grantRanks.push(r.rankKey); grantKeys.push(key); }
+      }
+      if (grantKeys.length > 0) {
+        const { rows: granted } = await client.query(
+          `INSERT INTO government_rank_permissions (rank_key, permission_key)
+           SELECT g.rank_key, g.permission_key
+             FROM unnest($1::text[], $2::text[]) WITH ORDINALITY AS g(rank_key, permission_key, ord)
+            ORDER BY g.ord
+           ON CONFLICT (rank_key, permission_key) DO NOTHING
+           RETURNING rank_key, permission_key`,
+          [grantRanks, grantKeys],
+        );
+        const landed = new Set(granted.map((row) => `${row.rank_key}\u0000${row.permission_key}`));
+        grantRanks.forEach((rk, i) => {
+          if (landed.has(`${rk}\u0000${grantKeys[i]}`)) created.get(rk).push(grantKeys[i]);
+        });
+      }
+    }
+    await client.query('COMMIT');
+  } catch (err) {
+    await client.query('ROLLBACK').catch(() => {});
+    throw err;
+  } finally {
+    client.release();
+  }
+  return created;
+}
+
 async function revokeRankPermission({ rankKey, permissionKey }) {
   const { rowCount } = await pool.query(
     `DELETE FROM government_rank_permissions
@@ -1165,6 +1238,7 @@ module.exports = {
   getRankByKey,
   createRank,
   grantRankPermission,
+  applyRankSet,
   revokeRankPermission,
   resetRankGrants,
   deleteCustomRank,

package/modules/government/routes/government.js

@@ -434,40 +434,50 @@ module.exports = function buildGovernmentRouter() {
 
   // rank: perm government.manage — add a RECOMMENDED RANK SET (task 1004400):
   // the custom ranks recommendations.js names for a project type and size, each
-  // with its grants. It is the create form and the grant toggle run in a loop,
-  // under the same checks: a rank that already exists is LEFT ALONE (never
+  // with its grants. It does what the create form and the grant toggle do, for
+  // every rank in the set, under the same checks: a rank that already exists is LEFT ALONE (never
   // re-granted, never relabelled — an owner may have edited it), and every grant
   // is re-checked with catalog.isGrantableTo, so a set can never write what the
   // toggle would refuse. Re-applying is safe; the reply says what was added.
+  //
+  // task 1004929: the whole set is written by db.applyRankSet in ONE transaction
+  // and three statements, instead of a read + insert + one insert per grant for
+  // every rank. A rank this route creates is always a CUSTOM rank (is_system
+  // false, no seeded_rank — what createRank returns), so each grant is screened
+  // against that shape before the write, exactly as the toggle would screen it.
+  // A failure now writes nothing, so a 500 reports empty created/skipped lists.
   router.post('/government/rank-sets/apply', api.requireBuilder, api.requirePermission('government.manage'), async (req, res) => {
     if (validateOrRespond(req, res, {
       type: { type: 'string', maxLength: 32 },
       headcount: { required: true, type: 'integer', min: 0, max: 100000 },
     })) return;
     const set = recommendations.recommendedRankSet(req.body.type, req.body.headcount);
-    const created = [];
-    const skipped = [];
+    const customRank = { is_system: false, seeded_rank: null };
     try {
+      const granted = await db.applyRankSet({
+        createdBy: req.builder.id,
+        ranks: set.ranks.map((r) => ({
+          rankKey: r.rank_key,
+          label: r.label,
+          description: r.description,
+          permissionKeys: r.permissions.filter((key) => catalog.byKey(key) && catalog.isGrantableTo(key, customRank)),
+        })),
+      });
+      const created = [];
+      const skipped = [];
       for (const r of set.ranks) {
-        if (await db.getRankByKey(r.rank_key)) { skipped.push({ rank_key: r.rank_key, label: r.label }); continue; }
-        let rank;
-        try {
-          rank = await db.createRank({ rankKey: r.rank_key, label: r.label, description: r.description, createdBy: req.builder.id });
-        } catch (err) {
-          if (err && err.code === '23505') { skipped.push({ rank_key: r.rank_key, label: r.label }); continue; }
-          throw err;
-        }
-        const granted = [];
-        for (const key of r.permissions) {
-          if (!catalog.byKey(key) || !catalog.isGrantableTo(key, rank)) continue;
-          if (await db.grantRankPermission({ rankKey: r.rank_key, permissionKey: key })) granted.push(key);
+        // delete-on-read: a key named twice in a set is created once, then skipped.
+        if (granted.has(r.rank_key)) {
+          created.push({ rank_key: r.rank_key, label: r.label, permissions: granted.get(r.rank_key) });
+          granted.delete(r.rank_key);
+        } else {
+          skipped.push({ rank_key: r.rank_key, label: r.label });
         }
-        created.push({ rank_key: r.rank_key, label: r.label, permissions: granted });
       }
       res.json({ ok: true, type: set.type, size: set.size, created, skipped });
     } catch (err) {
       log.error('[gds] POST /government/rank-sets/apply', err);
-      res.fail('rank_set_apply_failed', { status: 500, message: 'internal error', details: { created, skipped } });
+      res.fail('rank_set_apply_failed', { status: 500, message: 'internal error', details: { created: [], skipped: [] } });
     }
   });
 

package/modules/grading/grader-subagent.js

@@ -183,18 +183,23 @@ function runSubagent({ prompt, opts = {} }) {
 // agentic Read turns re-opening the same changed files. Read them ONCE here
 // and hand every worker the post-change contents inline (fenced, untrusted),
 // so a worker's Read tool is only needed for files beyond the bundle.
+//
+// task 1004932: the bundle rides in EVERY worker prompt, so its total is paid
+// once per worker; 120k chars made it the largest fixed input of a grade.
 const CONTEXT_BUNDLE_MAX_FILES = 24;
-const CONTEXT_BUNDLE_MAX_TOTAL_CHARS = 120_000;
+const CONTEXT_BUNDLE_MAX_TOTAL_CHARS = 60_000;
 const CONTEXT_BUNDLE_MAX_FILE_CHARS = 16_000;
 // Binary-ish extensions never worth inlining (the diff already names them).
 const CONTEXT_BUNDLE_SKIP_RE = /\.(?:png|jpe?g|gif|webp|ico|svgz|woff2?|ttf|eot|zip|gz|tgz|tar|pdf|mp[34]|wav|ogg|bin|exe|dll|node)$/i;
 
-// Added lines per file, from the unified diff. Only lines long enough to be a
-// meaningful fingerprint (a bare `}` or `});` matches anywhere) — used to prove
-// a truncated bundle prefix actually SHOWS the change (task 1002905).
+// One pass over a unified diff, per file: how many lines it adds (a relevance
+// weight), and the added lines long enough to be a meaningful fingerprint (a bare
+// `}` or `});` matches anywhere) — used to prove a truncated bundle prefix
+// actually SHOWS the change (task 1002905).
 const BUNDLE_EVIDENCE_MIN_CHARS = 12;
-function diffAddedLinesByFile(diff) {
-  const byFile = new Map();
+function scanDiff(diff) {
+  const evidence = new Map();
+  const added = new Map();
   let cur = null;
   let prevWasOldHeader = false;
   for (const line of String(diff || '').split('\n')) {
@@ -209,12 +214,26 @@ function diffAddedLinesByFile(diff) {
     prevWasOldHeader = line.startsWith('--- ');
     if (prevWasOldHeader || line.startsWith('diff --git')) continue;
     if (!cur || !line.startsWith('+')) continue;
+    added.set(cur, (added.get(cur) || 0) + 1);
     const t = line.slice(1).trim();
     if (t.length < BUNDLE_EVIDENCE_MIN_CHARS) continue;
-    if (!byFile.has(cur)) byFile.set(cur, []);
-    byFile.get(cur).push(t);
+    if (!evidence.has(cur)) evidence.set(cur, []);
+    evidence.get(cur).push(t);
   }
-  return byFile;
+  return { evidence, added };
+}
+function diffAddedLinesByFile(diff) { return scanDiff(diff).evidence; }
+
+// The order the bundle is filled in (task 1004932): the files the diff adds the
+// most lines to first, so when the total cap bites it is the lightly touched
+// files (a one-line doc pointer, a generated index) that fall to skipped[] for
+// the worker to Read, not the heart of the change. Stable: ties, and every file
+// when there is no diff, keep the caller's order.
+function orderByChange(changedFiles, added) {
+  return changedFiles
+    .map((file, i) => ({ file, i, n: added.get(file) || 0 }))
+    .sort((a, b) => (b.n - a.n) || (a.i - b.i))
+    .map((x) => x.file);
 }
 
 // Pure-ish (fs reads only, injectable): returns { files: [{file, content,
@@ -241,8 +260,8 @@ function buildContextBundle({ changedFiles, cwd, diff, fsImpl = fs } = {}) {
   // exactly the pre-change state). A prefix that contains none of the change is
   // worse than no bundle at all, so refuse it: skipped[] already tells the worker
   // to Read the file.
-  const addedByFile = diffAddedLinesByFile(diff);
-  for (const rel of (Array.isArray(changedFiles) ? changedFiles : [])) {
+  const { evidence: addedByFile, added } = scanDiff(diff);
+  for (const rel of orderByChange(Array.isArray(changedFiles) ? changedFiles : [], added)) {
     if (files.length >= CONTEXT_BUNDLE_MAX_FILES || total >= CONTEXT_BUNDLE_MAX_TOTAL_CHARS) {
       skipped.push(rel);
       continue;

package/modules/hall-ui/public/city.html

@@ -106,24 +106,24 @@
 </div>
 
 <script src="/builders/dom-utils.js?v=2026-10-25-escape"></script>
-<script src="/builders/shell-trail.js?v=2026-10-08-city-tab"></script>
-<script src="/builders/craft-mode.js?v=2026-10-09-living3"></script>
-<script src="/builders/shell.js?v=2026-10-25-escape"></script>
+<script src="/builders/shell-trail.js?v=2026-10-08-city-tab" defer></script>
+<script src="/builders/craft-mode.js?v=2026-10-09-living3" defer></script>
+<script src="/builders/shell.js?v=2026-10-25-escape" defer></script>
 <script src="/builders/palette.js" defer></script>
-<script src="/builders/gov-living.js?v=2026-10-09-positions1"></script>
-<script src="/builders/gov-feeds.js?v=2026-10-09-living3"></script>
-<script src="/builders/city-draw.js?v=2026-10-17-tidy"></script>
+<script src="/builders/gov-living.js?v=2026-10-09-positions1" defer></script>
+<script src="/builders/gov-feeds.js?v=2026-10-09-living3" defer></script>
+<script src="/builders/city-draw.js?v=2026-10-17-tidy" defer></script>
 <!-- a building's card answers its first ask in place through the deck's own
      route (task 1004702): the desk rows (street-desk.js over the street's kit)
      and the deck's card and sender (street-deck.js) -->
-<script src="/builders/hall-kit.js?v=2026-10-23-decide12"></script>
-<script src="/builders/street-draw.js?v=2026-10-09-living3"></script>
-<script src="/builders/street-card.js?v=2026-10-04-record1"></script>
-<script src="/builders/street-inside.js?v=2026-10-09-living3"></script>
-<script src="/builders/street-desk.js?v=2026-10-04-record1"></script>
-<script src="/builders/street-deck.js?v=2026-10-13-glass1"></script>
-<script src="/builders/city-decide.js?v=2026-10-23-decide12"></script>
-<script src="/builders/city-switchboard.js?v=2026-10-23-board5"></script>
-<script src="/builders/city.js?v=2026-10-23-decide12"></script>
+<script src="/builders/hall-kit.js?v=2026-10-23-decide12" defer></script>
+<script src="/builders/street-draw.js?v=2026-10-09-living3" defer></script>
+<script src="/builders/street-card.js?v=2026-10-04-record1" defer></script>
+<script src="/builders/street-inside.js?v=2026-10-09-living3" defer></script>
+<script src="/builders/street-desk.js?v=2026-10-04-record1" defer></script>
+<script src="/builders/street-deck.js?v=2026-10-13-glass1" defer></script>
+<script src="/builders/city-decide.js?v=2026-10-23-decide12" defer></script>
+<script src="/builders/city-switchboard.js?v=2026-10-23-board5" defer></script>
+<script src="/builders/city.js?v=2026-10-23-decide12" defer></script>
 </body>
 </html>