@bongos/core 1.21.175 → 1.21.177

package/tests/instance_feedback.mjs

@@ -300,7 +300,7 @@ test('direct route: answers 202 before verifying, and caps BEFORE anything is fe
 test('`bongos feedback` is a registered verb, and every refusal has a plain line', () => {
   const { VERBS } = require_(path.join(ROOT, 'bin/bongos.js'));
   assert.equal(VERBS.feedback.script, 'feedback-send.js');
-  const { REFUSALS, readMessage } = require_(path.join(ROOT, 'scripts/gds/feedback-send.js'));
+  const { REFUSALS, readMessage } = require_(path.join(ROOT, 'scripts/bongos/feedback-send.js'));
   for (const code of ['message_required', 'too_long', 'local_only', 'no_scrubber']) assert.ok(REFUSALS[code], code);
   assert.equal(readMessage(['--idea', 'filter', 'by', 'goal']), 'filter by goal');
 });
@@ -308,7 +308,7 @@ test('`bongos feedback` is a registered verb, and every refusal has a plain line
 // The skill tells the agent to use --message-file; it used to send the literal
 // "[object Object]" because argText's result object was used as the text.
 test('--message-file and stdin give the TEXT, never an object', () => {
-  const { readMessage } = require_(path.join(ROOT, 'scripts/gds/feedback-send.js'));
+  const { readMessage } = require_(path.join(ROOT, 'scripts/bongos/feedback-send.js'));
   assert.equal(readMessage(['--message-file', '-'], { readStdin: () => 'from stdin' }), 'from stdin');
   assert.equal(readMessage(['--message-file', 'x.md'], { readFile: () => 'from file' }), 'from file');
   assert.equal(readMessage([], { stdinIsPiped: true, readStdin: () => 'piped' }), 'piped');
@@ -316,7 +316,7 @@ test('--message-file and stdin give the TEXT, never an object', () => {
 });
 
 async function runCli(argv, extra = {}) {
-  const { main } = require_(path.join(ROOT, 'scripts/gds/feedback-send.js'));
+  const { main } = require_(path.join(ROOT, 'scripts/bongos/feedback-send.js'));
   const out = []; const err = [];
   const log = console.log; const error = console.error;
   console.log = (...a) => out.push(a.join(' ')); console.error = (...a) => err.push(a.join(' '));
@@ -370,14 +370,14 @@ test('the repeat guard records only after the project vouched', async () => {
 });
 
 test('requestReceipt: a 404 from the project reads as project_too_old', async () => {
-  const { requestReceipt } = require_(path.join(ROOT, 'scripts/gds/feedback-send.js'));
+  const { requestReceipt } = require_(path.join(ROOT, 'scripts/bongos/feedback-send.js'));
   const api = { request: async () => ({ ok: false, status: 404, data: { error: 'Not found' } }) };
   const r = await requestReceipt({ message: 'x', kind: 'idea' }, { api, base: 'https://toast.cloudbongos.com' });
   assert.deepEqual(r, { ok: false, step: 'receipt', code: 'project_too_old' });
 });
 
 test('keepUnsent writes the note where the builder can send it again', () => {
-  const { keepUnsent } = require_(path.join(ROOT, 'scripts/gds/feedback-send.js'));
+  const { keepUnsent } = require_(path.join(ROOT, 'scripts/bongos/feedback-send.js'));
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fb-unsent-'));
   const file = keepUnsent('the note', { dir, now: new Date('2026-10-19T10:00:00Z') });
   assert.equal(fs.readFileSync(file, 'utf8'), 'the note');
@@ -394,7 +394,7 @@ test('the CLI refuses a project only this computer can reach, and sends nothing'
 });
 
 test('the same report twice inside the window is sent once', async () => {
-  const { checkAndRecordRepeat } = require_(path.join(ROOT, 'scripts/gds/feedback-send.js'));
+  const { checkAndRecordRepeat } = require_(path.join(ROOT, 'scripts/bongos/feedback-send.js'));
   const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'fb-')), 'sent.json');
   assert.equal(checkAndRecordRepeat('Claim hung\nfirst time', { file, now: 0 }), false);
   assert.equal(checkAndRecordRepeat('claim hung  \nsecond rant', { file, now: 1000 }), true);
@@ -406,7 +406,7 @@ test('the same report twice inside the window is sent once', async () => {
 });
 
 test('deliver: receipt for the exact text from the project, then the report straight to the hub', async () => {
-  const { deliver } = require_(path.join(ROOT, 'scripts/gds/feedback-send.js'));
+  const { deliver } = require_(path.join(ROOT, 'scripts/bongos/feedback-send.js'));
   const reqs = [];
   const api = { request: async (m, p, o) => { reqs.push({ m, p, body: o.body }); return { ok: true, data: { receipt: 'R'.repeat(24), hub: 'https://hub.example.com' } }; } };
   const sent = [];
@@ -567,7 +567,7 @@ test('a labelled message or a wish about Bongos triggers the skill too, and noth
 });
 
 test('every report is secret-scrubbed before it leaves the machine, and never sent unscrubbed', async () => {
-  const { scrubReport } = require_(path.join(ROOT, 'scripts/gds/feedback-send.js'));
+  const { scrubReport } = require_(path.join(ROOT, 'scripts/bongos/feedback-send.js'));
   const token = 'ghp_' + 'a1B2c3D4e5F6g7H8i9J0k1L2m3N4o5P6q7R8';
   const envValue = 'zq9-private-value-7781';
   const r = scrubReport(`claim failed, my token is ${token} and the key is ${envValue}`, { MY_API_KEY: envValue });
@@ -575,7 +575,7 @@ test('every report is secret-scrubbed before it leaves the machine, and never se
   assert.ok(!r.text.includes(envValue), 'an env secret is stripped by value');
   assert.ok(r.removed >= 2);
   assert.equal(scrubReport('bongos claim hung for two minutes', {}).text, 'bongos claim hung for two minutes', 'plain prose is untouched');
-  const src = fs.readFileSync(path.join(ROOT, 'scripts/gds/feedback-send.js'), 'utf8');
+  const src = fs.readFileSync(path.join(ROOT, 'scripts/bongos/feedback-send.js'), 'utf8');
   const main = src.slice(src.indexOf('async function main('));
   assert.ok(main.indexOf('scrubReport(message)') < main.indexOf('spawnDelivery'), 'scrubbed before anything is handed off');
   assert.match(main, /message: scrubbed\.text/, 'only the scrubbed text is sent');

package/tests/instance_mismatch_guard.mjs

@@ -1,7 +1,7 @@
 // tests/instance_mismatch_guard.mjs
 //
 // Unit test for the PURE fail-closed instance guard exported from
-// scripts/gds/cli-lib.js (task 2102):
+// scripts/bongos/cli-lib.js (task 2102):
 //   - instanceOriginHost(origin) → host string, or null if unparseable
 //   - detectInstanceMismatch({ session, brand, env }) → { mismatch, expected, actual }
 //
@@ -15,7 +15,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const cli = require('../scripts/gds/cli-lib.js');
+const cli = require('../scripts/bongos/cli-lib.js');
 
 let passed = 0;
 let failed = 0;

package/tests/integration_parked_ratchet.mjs

@@ -28,7 +28,7 @@ import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
 const TESTS_DIR = path.dirname(fileURLToPath(import.meta.url));
-const { INTEGRATION, INTEGRATION_PARKED, KNOWN_FAILING } = require('../scripts/gds/run-unit-tests.js');
+const { INTEGRATION, INTEGRATION_PARKED, KNOWN_FAILING } = require('../scripts/bongos/run-unit-tests.js');
 
 // The ceiling. Twenty-three is what the integration lane's first ever run surfaced
 // (task 1000862) — every one a test nothing had executed before, not a regression.
@@ -44,7 +44,14 @@ const { INTEGRATION, INTEGRATION_PARKED, KNOWN_FAILING } = require('../scripts/g
 //
 // LOWERED 24 → 23 by task 1002863: consumer_layout_boot was fixed and un-parked, and the
 // ceiling follows it down so the freed slot cannot quietly be spent on a new failure.
-const MAX_PARKED = 23;
+// LOWERED 23 → 14 by task 1004865: bfg, bfg_write, memory_isolation, memory_pull and setup_smoke
+// were repaired and moved to the unit lane (they never needed a database).
+// LOWERED 14 → 11 by task 1004864: handle_machinery, profile_fields and project_visibility_db
+// pass once integration.yml switches the platform-identity module on.
+// LOWERED 11 → 6 by task 1004861: claim_gate_open_blocker, claim_gate_rebase,
+// clawback_confirmed_backlog, needs_rebase and reward_mode_cost_plus_only stopped adding a
+// second 'planning' version (and had three stale fixtures under it repaired).
+const MAX_PARKED = 6;
 
 // The one test that proves the PUBLISHED package works end to end: packaged, installed into
 // a consumer, installed again from its own shipped lockfile, migrated onto EMPTY databases,
@@ -100,3 +107,18 @@ test('the parked count is ratcheted and cannot grow silently', () => {
     `${n} parked integration tests exceeds the ratchet of ${MAX_PARKED}. Fix the new `
     + 'failure rather than parking it; raising MAX_PARKED is a deliberate act.');
 });
+
+// task 1004865: five tests sat in INTEGRATION (and so, failing, in INTEGRATION_PARKED) that
+// never needed a database — each failed on a stale harness that was read as "needs Postgres".
+// Repaired, they gate the cross-builder memory read and write, memory isolation, the memory
+// restore hook and setup. Back in a database lane they would run only weekly, parked, again.
+const REPAIRED_DB_FREE = ['bfg', 'bfg_write', 'memory_isolation', 'memory_pull', 'setup_smoke'];
+
+test('the five repaired DB-free tests stay in the unit lane', () => {
+  for (const name of REPAIRED_DB_FREE) {
+    assert.ok(fs.existsSync(path.join(TESTS_DIR, `${name}.mjs`)), `tests/${name}.mjs is gone`);
+    assert.ok(!INTEGRATION.has(name) && !INTEGRATION_PARKED.has(name) && !KNOWN_FAILING.has(name),
+      `${name} is excluded from the DB-free unit lane again. It needs no database; if it fails, `
+      + 'repair the harness rather than moving it somewhere it only runs weekly.');
+  }
+});

package/tests/intent_retry.mjs

@@ -8,7 +8,7 @@
 // Run:  node tests/intent_retry.mjs
 
 import { strict as assert } from 'node:assert';
-import { retryDecision, maxAttemptsFor, TRANSIENT_BACKOFF_MS, DEFAULT_RETRY_DELAY_MS } from '../scripts/gds/intent-retry.js';
+import { retryDecision, maxAttemptsFor, TRANSIENT_BACKOFF_MS, DEFAULT_RETRY_DELAY_MS } from '../scripts/bongos/intent-retry.js';
 
 let passed = 0;
 let failed = 0;

package/tests/interaction_posture.mjs

@@ -22,12 +22,12 @@ import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
 const REPO_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
-const gen = require('../scripts/gds/gen-interaction-posture.js');
+const gen = require('../scripts/bongos/gen-interaction-posture.js');
 const prefs = require('../modules/builder-settings/interaction-prefs.js');
 // Never `===` on raw file bytes here: the generator renders LF, and a default Windows
 // clone checks CLAUDE.md out as CRLF, so a byte comparison would fail on one OS and pass
 // on the other. gen-freshness.js exists for exactly this (and its header says so).
-const { sameContent } = require('../scripts/gds/gen-freshness.js');
+const { sameContent } = require('../scripts/bongos/gen-freshness.js');
 
 test('the block carries one bullet per DEFAULT value that injects, and none for one that does not', () => {
   const block = gen.renderBlock();
@@ -71,7 +71,7 @@ test('the committed CLAUDE.md §2 block matches a freshly rendered one', () => {
   const e = claude.indexOf(gen.END);
   assert.ok(b !== -1 && e > b, 'CLAUDE.md §2 must carry the posture markers');
   assert.ok(sameContent(claude.slice(b, e + gen.END.length), gen.renderBlock()),
-    'CLAUDE.md §2 is STALE or hand-edited — run `node scripts/gds/gen-interaction-posture.js`');
+    'CLAUDE.md §2 is STALE or hand-edited — run `node scripts/bongos/gen-interaction-posture.js`');
 });
 
 test('CLAUDE.md expresses the posture through the knob instead of restating it', () => {

package/tests/invite_expiry_db.mjs

@@ -16,7 +16,7 @@
 // never seen or changed.
 //
 // Real-DB integration test: self-skips without a reachable Postgres; in the
-// INTEGRATION set (scripts/gds/run-unit-tests.js) so the default DB-free lane
+// INTEGRATION set (scripts/bongos/run-unit-tests.js) so the default DB-free lane
 // never runs it.
 //
 // Run:  DATABASE_URL=... node tests/invite_expiry_db.mjs

package/tests/joinability_invite_only.mjs

@@ -192,7 +192,7 @@ test('the hall landing renders one door per mode, and its form collapses on the
 });
 
 test('the CLI says invite-only and stops, rather than filing a request the project refuses', () => {
-  const cli = src('scripts/gds/login.js');
+  const cli = src('scripts/bongos/login.js');
   assert.match(cli, /joinability === 'invite_only'/);
   assert.match(cli, /is invite-only — it doesn’t take applications/);
 });

package/tests/karma_vote_lists.mjs

@@ -0,0 +1,270 @@
+// tests/karma_vote_lists.mjs — karma vote buttons on every hall task/idea list,
+// and ideas voted for karma like tasks (task 1004727).
+//
+// Owner decisions this pins (2026-10-23):
+//   * an idea vote earns karma for the builder who SUBMITTED the idea, weighs
+//     the same as a task vote, and has the same guards: no self-vote, a vote
+//     already folded into karma is frozen, and the same 7-day lag in the fold;
+//   * ONE vote control (modules/hall-ui/public/vote-control.js), reused by the
+//     work board, goal task lists, idea lists and profile task lists;
+//   * a task row offers the vote only where the server accepts one (confirmed
+//     or shipped). Any other row renders NOTHING, not a disabled button;
+//   * voting from a list updates that row in place.
+//
+// The real fold over a real Postgres is tests/idea_votes_fold_db.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 require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const read = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8').replace(/\r\n/g, '\n');
+
+// ---------------------------------------------------------------------------
+// the server half: modules/ideas/votes.js over a scripted pool
+// ---------------------------------------------------------------------------
+
+// A pool that answers by matching the SQL; records every statement it saw.
+function fakePool({ idea = { id: 7, captured_by: 2 }, upsertRows = 1, net = 1, total = 1 } = {}) {
+  const seen = [];
+  return {
+    seen,
+    async query(sql, params) {
+      seen.push({ sql, params });
+      if (/FROM idea_inbox/.test(sql)) return { rows: idea ? [idea] : [], rowCount: idea ? 1 : 0 };
+      if (/INSERT INTO ideas_votes/.test(sql)) return { rows: upsertRows ? [{ id: 1 }] : [], rowCount: upsertRows };
+      if (/DELETE FROM ideas_votes/.test(sql)) return { rows: [], rowCount: upsertRows };
+      if (/SUM\(vote\)/.test(sql)) return { rows: [{ net, total }], rowCount: 1 };
+      return { rows: [], rowCount: 0 };
+    },
+  };
+}
+
+const votes = () => require(path.join(ROOT, 'modules', 'ideas', 'votes.js'));
+
+test('an idea vote is cast and returns the authoritative tally', async () => {
+  const pool = fakePool({ net: 3, total: 4 });
+  const r = await votes().castIdeaVote(pool, { voterId: 1, ideaId: 7, vote: 1 });
+  assert.equal(r.ok, true);
+  assert.equal(r.net_votes, 3);
+  assert.equal(r.my_vote, 1);
+  assert.ok(pool.seen.some((s) => /INSERT INTO ideas_votes/.test(s.sql)));
+});
+
+test('no voting on your own idea', async () => {
+  const r = await votes().castIdeaVote(fakePool({ idea: { id: 7, captured_by: 1 } }), { voterId: 1, ideaId: 7, vote: 1 });
+  assert.equal(r.ok, false);
+  assert.equal(r.code, 'self_vote_forbidden');
+  assert.equal(r.status, 403);
+});
+
+test('an unknown idea and an idea with no submitter are refused', async () => {
+  const gone = await votes().castIdeaVote(fakePool({ idea: null }), { voterId: 1, ideaId: 7, vote: 1 });
+  assert.equal(gone.code, 'idea_not_found');
+  const orphan = await votes().castIdeaVote(fakePool({ idea: { id: 7, captured_by: null } }), { voterId: 1, ideaId: 7, vote: 1 });
+  assert.equal(orphan.code, 'no_submitter');
+});
+
+test('a vote already folded into karma is frozen', async () => {
+  const r = await votes().castIdeaVote(fakePool({ upsertRows: 0 }), { voterId: 1, ideaId: 7, vote: -1 });
+  assert.equal(r.code, 'vote_already_counted');
+  assert.equal(r.status, 409);
+});
+
+test('the upsert carries the same tallied-freeze guard as the task vote', () => {
+  const src = read('modules/ideas/votes.js');
+  assert.match(src, /WHERE ideas_votes\.tallied_at IS NULL/);
+});
+
+// ---------------------------------------------------------------------------
+// the fold: ONE fold counts task votes AND idea votes
+// ---------------------------------------------------------------------------
+
+test('the karma fold folds idea votes into the submitter, with the same lag', () => {
+  const src = read('modules/lifecycle/db-analytics.js');
+  const fold = src.slice(src.indexOf('async function tallyPeerVotes'), src.indexOf('module.exports'));
+  assert.match(fold, /FROM ideas_votes/);
+  assert.match(fold, /captured_by/);
+  assert.match(fold, /UPDATE ideas_votes SET tallied_at/);
+  // the same lag constant drives both halves
+  assert.ok((fold.match(/PEER_VOTE_KARMA_LAG_DAYS/g) || []).length >= 2);
+});
+
+test('the migration lives in the ideas module and the DB test joins the integration set', () => {
+  const mig = read('modules/ideas/migrations/ideas_011_idea_votes.sql');
+  assert.match(mig, /CREATE TABLE IF NOT EXISTS ideas_votes/);
+  assert.match(mig, /UNIQUE \(voter_builder_id, target_idea_id\)/);
+  assert.match(read('scripts/bongos/run-unit-tests.js'), /'idea_votes_fold_db'/);
+});
+
+// ---------------------------------------------------------------------------
+// the client half: ONE vote control, in a vm with a small fake DOM
+// ---------------------------------------------------------------------------
+
+function el(tag, attrs = {}) {
+  const node = {
+    tagName: tag.toUpperCase(), attrs: { ...attrs }, children: [], textContent: '', disabled: false, parent: null,
+    classList: {
+      set: new Set(),
+      add(...c) { c.forEach((x) => this.set.add(x)); },
+      remove(...c) { c.forEach((x) => this.set.delete(x)); },
+      toggle(c, on) { if (on) this.set.add(c); else this.set.delete(c); },
+      contains(c) { return this.set.has(c); },
+    },
+    getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; },
+    setAttribute(k, v) { this.attrs[k] = String(v); },
+    hasAttribute(k) { return k in this.attrs; },
+    querySelector(sel) { return this.querySelectorAll(sel)[0] || null; },
+    querySelectorAll(sel) {
+      const out = [];
+      const m = sel.match(/^\[([\w-]+)\]$/);
+      const walk = (n) => { for (const c of n.children) { if (m && c.hasAttribute(m[1])) out.push(c); walk(c); } };
+      walk(this);
+      return out;
+    },
+    closest(sel) {
+      const m = sel.match(/^\[([\w-]+)\]$/);
+      for (let n = this; n; n = n.parent) if (m && n.hasAttribute(m[1])) return n;
+      return null;
+    },
+    append(c) { c.parent = this; this.children.push(c); return c; },
+  };
+  return node;
+}
+
+function control(kind, id) {
+  const root = el('span', { 'data-vote-kind': kind, 'data-vote-id': String(id) });
+  root.append(el('button', { 'data-vote': '1' }));
+  root.append(el('span', { 'data-vote-net': '' }));
+  root.append(el('button', { 'data-vote': '-1' }));
+  return root;
+}
+
+function boot(fetchImpl) {
+  const ctx = { console, fetch: fetchImpl };
+  ctx.window = ctx;
+  vm.createContext(ctx);
+  vm.runInContext(fs.readFileSync(path.join(HALL, 'vote-control.js'), 'utf8'), ctx);
+  return ctx.OTBVote;
+}
+
+test('a task row renders the control only when the server would accept a vote', () => {
+  const V = boot(async () => ({}));
+  for (const status of ['confirmed', 'shipped']) {
+    assert.match(V.taskHtml({ id: 5, status }), /data-vote-kind="task"/, status);
+  }
+  for (const status of ['ready', 'active', 'backlog', 'completed', '', undefined]) {
+    assert.equal(V.taskHtml({ id: 5, status }), '', `status ${status} renders nothing`);
+  }
+});
+
+test('an idea row always offers the vote', () => {
+  const V = boot(async () => ({}));
+  const html = V.ideaHtml({ id: 9 });
+  assert.match(html, /data-vote-kind="idea"/);
+  assert.match(html, /data-vote-id="9"/);
+  assert.match(html, /data-vote="1"/);
+  assert.match(html, /data-vote="-1"/);
+});
+
+test('voting from a list posts to the right route and updates the row in place', async () => {
+  const calls = [];
+  const fetchImpl = async (url, opts) => {
+    calls.push({ url, opts });
+    return { ok: true, status: 200, json: async () => ({ ok: true, net_votes: 4, my_vote: 1 }) };
+  };
+  const V = boot(fetchImpl);
+  for (const [kind, route] of [['task', '/api/bongos/tasks/5/vote'], ['idea', '/api/bongos/inbox/5/vote']]) {
+    const row = control(kind, 5);
+    const up = row.children[0];
+    await V.cast(up);
+    const last = calls[calls.length - 1];
+    assert.equal(last.url, route);
+    assert.equal(JSON.parse(last.opts.body).vote, 1);
+    assert.equal(row.children[1].textContent, '+4');
+    assert.equal(up.getAttribute('aria-pressed'), 'true');
+    assert.equal(row.children[2].getAttribute('aria-pressed'), 'false');
+  }
+});
+
+test('clicking your current vote clears it', async () => {
+  const bodies = [];
+  const V = boot(async (url, opts) => { bodies.push(JSON.parse(opts.body)); return { ok: true, json: async () => ({ ok: true, net_votes: 0, my_vote: null }) }; });
+  const row = control('idea', 3);
+  row.children[0].classList.add('is-active');
+  await V.cast(row.children[0]);
+  assert.equal(bodies[0].vote, 0);
+  assert.equal(row.children[1].textContent, '0');
+});
+
+test('a refused vote leaves the row as it was and says why', async () => {
+  const V = boot(async () => ({ ok: false, status: 403, json: async () => ({ error: { code: 'self_vote_forbidden' } }) }));
+  const row = control('idea', 3);
+  row.children[1].textContent = '+1';
+  const msg = await V.cast(row.children[0]);
+  assert.equal(row.children[1].textContent, '+1');
+  assert.match(String(msg), /own/);
+});
+
+test('hydrate reads every control on the page in one batched call per kind', async () => {
+  const urls = [];
+  const V = boot(async (url) => {
+    urls.push(url);
+    const body = url.includes('/inbox/')
+      ? { votes: { 9: { net: -2, mine: -1 } } }
+      : { votes: { 5: { net: 2, mine: null }, 6: { net: 0, mine: 1 } } };
+    return { ok: true, json: async () => body };
+  });
+  const page = el('div');
+  const a = page.append(control('task', 5));
+  page.append(control('task', 6));
+  const c = page.append(control('idea', 9));
+  await V.hydrate(page);
+  assert.deepEqual(urls.sort(), ['/api/bongos/inbox/votes?ids=9', '/api/bongos/tasks/peer-votes/lookup?ids=5,6']);
+  assert.equal(a.children[1].textContent, '+2');
+  assert.equal(c.children[1].textContent, '-2');
+  assert.equal(c.children[2].getAttribute('aria-pressed'), 'true');
+});
+
+// ---------------------------------------------------------------------------
+// the surfaces: every listed page loads the ONE control and uses it
+// ---------------------------------------------------------------------------
+
+const SURFACES = [
+  { page: 'work.html', js: 'work.js', call: 'OTBVote.taskHtml' },
+  { page: 'goals.html', js: 'goals-render.js', call: 'OTBVote.taskHtml' },
+  { page: 'profile.html', js: 'profile.js', call: 'OTBVote.taskHtml' },
+  { page: 'ideas.html', js: 'ideas.js', call: 'OTBVote.ideaHtml' },
+  { page: 'index.html', js: 'builders.js', call: 'OTBVote.ideaHtml' },
+];
+
+for (const s of SURFACES) {
+  test(`${s.page} loads the shared vote control and ${s.js} renders it`, () => {
+    assert.match(read(`modules/hall-ui/public/${s.page}`), /<script src="\/builders\/vote-control\.js/);
+    assert.ok(read(`modules/hall-ui/public/${s.js}`).includes(s.call), `${s.js} calls ${s.call}`);
+  });
+}
+
+test('no page carries its own copy of the idea or batch vote calls', () => {
+  for (const s of SURFACES) {
+    assert.doesNotMatch(read(`modules/hall-ui/public/${s.js}`), /\/inbox\/\$\{[^}]*\}\/vote|\/votes\?ids=/, `${s.js} must not post votes itself`);
+  }
+});
+
+test('the task vote read is batched, two segments deep, and registered by the lifecycle module', async () => {
+  const mod = require(path.join(ROOT, 'modules', 'lifecycle', 'routes', 'task-votes.js'));
+  const seen = [];
+  const pool = { async query(sql, params) { seen.push(params); return { rows: [{ id: 5, net: 2, mine: -1 }] }; } };
+  const out = await mod.readTaskVotes(pool, { voterId: 1, ids: ['5', '6', 'x', '5'] });
+  assert.deepEqual(JSON.parse(JSON.stringify(out)), { 5: { net: 2, mine: -1 }, 6: { net: 0, mine: null } });
+  assert.deepEqual(seen[0][0], [5, 6]);
+  const manifest = JSON.parse(read('modules/lifecycle/module.json'));
+  assert.ok(manifest.contributes.routes.includes('task-votes'));
+  // GET /tasks/:id would swallow a one-segment path such as /tasks/votes.
+  assert.match(read('modules/lifecycle/routes/task-votes.js'), /router\.get\('\/tasks\/peer-votes\/lookup'/);
+});

package/tests/key-card.mjs

@@ -1,6 +1,6 @@
 // tests/key-card.mjs
 //
-// Unit tests for scripts/gds/key-card.js (task 1391) — the reusable "key
+// Unit tests for scripts/bongos/key-card.js (task 1391) — the reusable "key
 // needed" visual callout, mirroring modules/lifecycle/ship-card.js's model.
 // Pure surface: buildKeyCardModel, renderMonospaceKeyCard, renderKeyCardHtml.
 // emitKeyCard writes to os.tmpdir(), so it's exercised too (file-system side
@@ -13,7 +13,7 @@ import { createRequire } from 'node:module';
 import fs from 'node:fs';
 
 const require = createRequire(import.meta.url);
-const keyCard = require('../scripts/gds/key-card.js');
+const keyCard = require('../scripts/bongos/key-card.js');
 
 let passed = 0;
 let failed = 0;

package/tests/key-status.mjs

@@ -1,6 +1,6 @@
 // tests/key-status.mjs
 //
-// Unit tests for scripts/gds/key-status.js's pasted-key guard (task 1391,
+// Unit tests for scripts/bongos/key-status.js's pasted-key guard (task 1391,
 // done-when #3: "no code path accepts a key pasted in chat without warning +
 // redirect"). Only the pure guard function is exercised here — the rest of
 // the script makes network calls (GET /me/art-key) and belongs in the
@@ -12,7 +12,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const keyStatus = require('../scripts/gds/key-status.js');
+const keyStatus = require('../scripts/bongos/key-status.js');
 
 let passed = 0;
 let failed = 0;

package/tests/knip_ratchet_ambient.mjs

@@ -32,8 +32,8 @@ import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
 const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const ratchets = require('../scripts/gds/fitness-ratchets.js');
-const SRC = readFileSync(path.join(REPO_ROOT, 'scripts/gds/fitness-ratchets.js'), 'utf8');
+const ratchets = require('../scripts/bongos/fitness-ratchets.js');
+const SRC = readFileSync(path.join(REPO_ROOT, 'scripts/bongos/fitness-ratchets.js'), 'utf8');
 
 test('the local-knip check runs BEFORE npx, so an ambient knip is never scored', () => {
   const fn = SRC.slice(SRC.indexOf('function knipIssueCount()'));

package/tests/known_failing_ratchet.mjs

@@ -3,7 +3,7 @@
 //
 // WHY THIS EXISTS, AND WHY IT IS NOT A MUTE
 //
-// `scripts/gds/run-unit-tests.js` already has a KNOWN_FAILING set, but gate-review.js
+// `scripts/bongos/run-unit-tests.js` already has a KNOWN_FAILING set, but gate-review.js
 // HARD-FLOORS that file (ADR 0058): adding an entry there is classified as muting a
 // test and escalates to the owner. It also genuinely hides the failure — a muted test
 // stops running. This file does the opposite:

package/tests/land_watch.mjs

@@ -1,6 +1,6 @@
 // tests/land_watch.mjs
 //
-// GDS-V4 task 1687 — locks the pending-land watcher (scripts/gds/land-watch.js) that
+// GDS-V4 task 1687 — locks the pending-land watcher (scripts/bongos/land-watch.js) that
 // renders the SHIPPED banner once an async CI land completes. Pure + DB-free + network-
 // free: classifyLand's truth table, buildShippedEnvelope's shape (forces the shipped
 // stage, honors widgets-off), and watch()'s orchestration (emit newest shipped, drop the
@@ -12,7 +12,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const L = require('../scripts/gds/land-watch.js');
+const L = require('../scripts/bongos/land-watch.js');
 const { classifyLand, buildShippedEnvelope, watch } = L;
 
 let passed = 0, failed = 0;

package/tests/landing_legal_pages.mjs

@@ -165,7 +165,7 @@ for (const p of PAGES) {
     for (const piece of [
       '<header class="shell bar">',
       '<a class="barMark" id="barMark" href="/">',
-      '<ellipse cx="8.4" cy="5.6" rx="6.6" ry="2.9"/>',
+      '<svg class="bongosMark" viewBox="0 0 200 200" aria-hidden="true">',
       '<button class="trig" type="button" id="projTrig" data-menu="projects" aria-expanded="false" aria-controls="menuProjects">Projects<svg class="cv" viewBox="0 0 20 20" aria-hidden="true"><path d="m5.6 8 4.4 4.4L14.4 8"/></svg></button>',
       '<button class="trig who" type="button" id="who" data-menu="profile" aria-expanded="false" aria-controls="menuProfile" hidden>',
       '<div class="menuBand" id="menuProjects" data-menu="projects" hidden>',

package/tests/landing_page.mjs

@@ -416,7 +416,7 @@ test('the chrome bongo pair is not a hero object; it keeps the closing figure, t
   // the pair is still the world's object elsewhere on the page
   assert.match(PAGE_CSS, /\.close \.closemark\{[^}]*--sky-bongos/, 'the closing figure is the pair');
   assert.match(PAGE_CSS, /\.o2\{[^}]*--bead-src:var\(--sky-bongos\)/, 'the second project orb is the pair');
-  assert.match(HTML, /<a class="barMark" href="\/"[^>]*>\s*<svg viewBox="0 0 26 20"/, 'the bar keeps the mark');
+  assert.match(HTML, /<a class="barMark" href="\/"[^>]*>\s*<svg class="bongosMark" viewBox="0 0 200 200"/, 'the bar keeps the mark');
 });
 
 // ── the live-data contract ─────────────────────────────────────────────────
@@ -540,7 +540,7 @@ test('the page satisfies the parked platform_boot assertions', () => {
 test('the bar is markup: the mark, the Projects trigger, the sign-in door — and no mode glyph (tasks 1003300, 1003336)', () => {
   const body = HTML.split('<body>')[1].split('<script>')[0];
   assert.match(body, /<header class="topbar bar">/, 'one bar, the hub\'s class beside the page\'s');
-  assert.match(body, /<a class="barMark" href="\/" aria-label="\{\{productName\}\}">\s*<svg viewBox="0 0 26 20"/, 'the static mark is the way home, labelled from the stamped name');
+  assert.match(body, /<a class="barMark" href="\/" aria-label="\{\{productName\}\}">\s*<svg class="bongosMark" viewBox="0 0 200 200"/, 'the static mark is the way home, labelled from the stamped name');
   assert.match(body, /<span class="mark-word">\{\{productName\}\}<\/span>/, 'the product name as plain type, folded away under 900');
   assert.match(body, /<button class="trig" type="button" id="projTrig" data-menu="projects" aria-expanded="false" aria-controls="menuProjects">Projects<svg class="cv"/);
   assert.doesNotMatch(body, /modeBtn|id="mode"|class="moon"|class="sun"/, 'the mode glyph left the bar — the apex is dark only (task 1003336)');

package/tests/leaderboard_roles.mjs

@@ -136,7 +136,10 @@ await test('a roles failure costs the roles, never the board', async () => {
 
 await test('the public list carries karma, so the roster can read it and keep its karma column', () => {
   const sql = read('modules/economy/achievements.js');
-  const q = sql.slice(sql.indexOf('async function getLeaderboardWithAchievements'), sql.indexOf('async function getLeaderboardWithAchievements') + 1200);
+  // task 1004853: the SQL moved behind the cache, into queryLeaderboardWithAchievements.
+  const at = sql.indexOf('async function queryLeaderboardWithAchievements');
+  assert.ok(at >= 0, 'the leaderboard query function is where this test reads it');
+  const q = sql.slice(at, at + 1200);
   assert.match(q, /\bb\.karma\b/);
 });
 

package/tests/leak_scan_allowlist.mjs

@@ -11,9 +11,9 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const A = require('../scripts/gds/leak-scan-allowlist.js');
+const A = require('../scripts/bongos/leak-scan-allowlist.js');
 const { allowReason, partitionHits, unusedEntries, FILE_ALLOWLIST, WELL_KNOWN_PUBLIC_IPS } = A;
-const { PRIOR_INSTANCE_FLOOR } = require('../scripts/gds/package-core.js');
+const { PRIOR_INSTANCE_FLOOR } = require('../scripts/bongos/package-core.js');
 
 // This test file is itself published, so it derives the literals it exercises rather
 // than spelling them out — the same self-leak invariant the allowlist module holds.
@@ -43,14 +43,14 @@ t('every entry names a path, at least one literal, and a substantive reason', ()
 t('an allowlisted file still fails on a literal it was not listed for', () => {
   // mirror-redact.js is listed for public-ip only. An owner login appearing there would
   // be a real leak — the SELF-LEAK INVARIANT that file documents about itself.
-  assert.ok(allowReason('scripts/gds/mirror-redact.js', 'public-ip', '8.8.8.8'));
-  assert.equal(allowReason('scripts/gds/mirror-redact.js', `literal:${OWNER}`, OWNER), null,
+  assert.ok(allowReason('scripts/bongos/mirror-redact.js', 'public-ip', '8.8.8.8'));
+  assert.equal(allowReason('scripts/bongos/mirror-redact.js', `literal:${OWNER}`, OWNER), null,
     'a literal whose class is not named for this path must still fail');
 });
 t('an entry does not leak across to another path', () => {
   // audit-authorship.sh may carry the owner login; an arbitrary script may not.
-  assert.ok(allowReason('scripts/gds/audit-authorship.sh', `literal:${OWNER}`, OWNER));
-  assert.equal(allowReason('scripts/gds/some-other-script.js', `literal:${OWNER}`, OWNER), null);
+  assert.ok(allowReason('scripts/bongos/audit-authorship.sh', `literal:${OWNER}`, OWNER));
+  assert.equal(allowReason('scripts/bongos/some-other-script.js', `literal:${OWNER}`, OWNER), null);
 });
 t('an unlisted file gets no exception at all', () => {
   assert.equal(allowReason('src/bongos/routes/auth.js', `literal:${TOKEN}`, TOKEN), null);
@@ -86,8 +86,8 @@ t('unusedEntries reports an entry that has stopped matching', () => {
   // No hits at all → every file entry is stale, which is the signal to prune.
   assert.ok(unusedEntries([]).length > 0);
   // A hit that covers one entry removes exactly that one from the stale list.
-  const stale = unusedEntries([{ path: 'scripts/gds/mirror-redact.js', label: 'public-ip', sample: '8.8.8.8' }]);
-  assert.ok(!stale.some((s) => s.path === 'scripts/gds/mirror-redact.js' && s.literal === 'public-ip'));
+  const stale = unusedEntries([{ path: 'scripts/bongos/mirror-redact.js', label: 'public-ip', sample: '8.8.8.8' }]);
+  assert.ok(!stale.some((s) => s.path === 'scripts/bongos/mirror-redact.js' && s.literal === 'public-ip'));
 });
 
 console.log(`\n${passed} passed, ${failed} failed`);