@bongos/core 1.21.174 → 1.21.176

package/tests/hook_user_agents.mjs

@@ -37,7 +37,7 @@ const hookFiles = fs.existsSync(HOOKS_DIR)
   : [];
 
 // The neutral core does NOT carry .claude/hooks/ — it's instance-materialized and
-// package-excluded (PROTECTED_TOPOLOGY_EXCLUDE in scripts/gds/publish-manifest.js),
+// package-excluded (PROTECTED_TOPOLOGY_EXCLUDE in scripts/bongos/publish-manifest.js),
 // so a clean core checkout has no hooks to scan. Skip cleanly rather than fail the
 // assertions below (task 1002234, same class as tests/stop_refcheck.mjs's absent-hook
 // crash); this UA invariant is enforced on an instance whose hooks are materialized.

package/tests/hooks_drain.mjs

@@ -8,7 +8,7 @@
 // hook takes its "not signed in" no-op path — the exit mechanics are what's under test.
 //
 // .claude/hooks/ is instance-materialized and package-excluded (PROTECTED_TOPOLOGY_EXCLUDE
-// in scripts/gds/publish-manifest.js), so a clean core checkout has no hooks: skip cleanly.
+// in scripts/bongos/publish-manifest.js), so a clean core checkout has no hooks: skip cleanly.
 //
 // Run:  node tests/hooks_drain.mjs
 
@@ -26,7 +26,7 @@ const HOOKS = ['recall-hints', 'rank-change-greeting', 'conductor', 'pull-memory
 // session-digest requires `pg` at load (via db-kernel), so it can only be exercised where node_modules
 // is installed — the CI lane; a bare Windows worktree skips it rather than reporting a phantom fail.
 const hasPg = fs.existsSync(path.join(ROOT, 'node_modules', 'pg'));
-const SCRIPTS = ['fetch-sound-prefs', 'session-cost', ...(hasPg ? ['session-digest'] : [])].map((n) => path.join(ROOT, 'scripts', 'gds', `${n}.js`));
+const SCRIPTS = ['fetch-sound-prefs', 'session-cost', ...(hasPg ? ['session-digest'] : [])].map((n) => path.join(ROOT, 'scripts', 'bongos', `${n}.js`));
 
 if (!HOOKS.every((p) => fs.existsSync(p))) {
   console.log('hooks_drain: SKIP — .claude/hooks/ is not materialized in this checkout (package-excluded).');

package/tests/host_topology_skips.mjs

@@ -31,7 +31,7 @@ const TESTS_DIR = path.dirname(fileURLToPath(import.meta.url));
 // Adding a line here is a deliberate, reviewable act — that is the point.
 const ALLOWED = {
   allow_rule_guard: '.claude/hooks/allow-rule-guard.js (package-excluded)',
-  art_stage: 'scripts/gds/art-stage.js (art-pipeline tooling, not in the core)',
+  art_stage: 'scripts/bongos/art-stage.js (art-pipeline tooling, not in the core)',
   bongos_downloads: 'config/bongos-cli.json (instance content)',
   cli_allowlist_permissions: '.claude/settings.json (package-excluded)',
   conductor: '.claude/hooks/conductor.js (package-excluded)',

package/tests/howto_guide.mjs

@@ -80,7 +80,7 @@ test('every `npx bongos <verb>` a step names is a real bongos verb', () => {
 
 test('every slash command a step names is a core skill an instance gets', async () => {
   const fs = await import('node:fs');
-  const { isPublishable } = require('../scripts/gds/publish-manifest.js');
+  const { isPublishable } = require('../scripts/bongos/publish-manifest.js');
   for (const s of guide.STEPS) {
     for (const m of s.try.matchAll(/\/([a-z][a-z-]+)/g)) {
       const skill = `.claude/skills/${m[1]}/SKILL.md`;

package/tests/howto_moments.mjs

@@ -16,8 +16,8 @@ const guide = require('../modules/onboarding/howto-guide.js');
 const m = require('../modules/onboarding/howto-moments.js');
 const { howtoAdvisory, evaluateTriggers } = require('../.claude/hooks/conductor.js');
 const { VERBS } = require('../bin/bongos.js');
-const { renderInstanceClaudeMd } = require('../scripts/gds/claude-md-template.js');
-const { readIds, formatProgress } = require('../scripts/gds/howto.js');
+const { renderInstanceClaudeMd } = require('../scripts/bongos/claude-md-template.js');
+const { readIds, formatProgress } = require('../scripts/bongos/howto.js');
 
 let passed = 0;
 let failed = 0;
@@ -166,7 +166,7 @@ test('evaluateTriggers carries the how-to advisory on a first prompt, and not on
 
 console.log('\nother AI tools:');
 
-test('`bongos howto` is a verb, run by scripts/gds/howto.js', () => {
+test('`bongos howto` is a verb, run by scripts/bongos/howto.js', () => {
   assert.equal(VERBS.howto.script, 'howto.js');
 });
 

package/tests/hub_account_page.mjs

@@ -113,7 +113,7 @@ test('the bar is the hub’s own: the same markup as /projects, no header of its
   // byte-equal pieces of projects.html: a rename on either page fails here
   for (const piece of [
     '<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/idea_capture_grades.mjs

@@ -24,9 +24,9 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const CAPTURE = path.join(ROOT, 'scripts/gds/capture.js');
+const CAPTURE = path.join(ROOT, 'scripts/bongos/capture.js');
 const SRC = fs.readFileSync(CAPTURE, 'utf8');
-const { acceptsOffer } = require('../scripts/gds/capture.js');
+const { acceptsOffer } = require('../scripts/bongos/capture.js');
 
 // Run capture.js as a real process with piped stdio. Every case below is refused
 // by argument validation BEFORE any network call, so this needs no session.

package/tests/idea_develop_spark.mjs

@@ -371,7 +371,7 @@ api.resolveOptional = realResolveOptional;
 
 // --- what the developer actually reads -----------------------------------
 
-const cli = require('../scripts/gds/spark.js');
+const cli = require('../scripts/bongos/spark.js');
 
 await test('the CLI names both parties, and never prints "undefined"', () => {
   const out = cli.renderDeveloped({

package/tests/idea_filed_via.mjs

@@ -139,12 +139,12 @@ await test('the ROUTED insert (a filing that becomes a task in the same act) wri
 });
 
 await test('capture.js names \'planning\' and nothing else — every other CLI filing\'s door is read off the session', () => {
-  const src = read('scripts/gds/capture.js');
+  const src = read('scripts/bongos/capture.js');
   assert.match(src, /const viaFromArg = arg\('--via', args\);/);
   assert.match(src, /if \(viaFromArg !== null && viaFromArg !== 'planning'\)[\s\S]{0,400}process\.exit\(2\)/, 'a door the CLI may not name is refused before the request');
   assert.match(src, /if \(viaFromArg\) payload\.filed_via = viaFromArg;/, 'sent only when given — a pinned core that predates the field never sees it');
   assert.equal(/filed_via: 'cli'/.test(src), false, 'never claims cli — the session already says so');
-  assert.equal(/postInbox\(/.test(read('scripts/gds/spark.js')), false, 'spark.js files no idea row of its own (a spark is made from an existing idea), so its door is the row\'s');
+  assert.equal(/postInbox\(/.test(read('scripts/bongos/spark.js')), false, 'spark.js files no idea row of its own (a spark is made from an existing idea), so its door is the row\'s');
   assert.match(read('.claude/skills/planning-session/SKILL.md'), /--via planning/, 'the planning session is told to name its door');
 });
 

package/tests/idea_ideate_full.mjs

@@ -62,7 +62,7 @@ function test(name, fn) {
 // said `capture.js --full` to a capture.js that had never heard of it. Prompt
 // tests must reach the executable, or they only prove the prose is self-consistent.
 test('capture.js really supports the flags the skill tells you to use', () => {
-  const capture = path.join(ROOT, 'scripts/gds/capture.js');
+  const capture = path.join(ROOT, 'scripts/bongos/capture.js');
   const usage = spawnSync(process.execPath, [capture], { encoding: 'utf8', timeout: 20000 });
   assert.equal(usage.status, 2, 'the no-args usage path');
   assert.match(usage.stderr, /--full/, 'usage advertises --full');

package/tests/idea_spark_mark.mjs

@@ -205,7 +205,7 @@ await test('a missing idea is a 404, not a 500', async () => {
 // them under error.details. So the CLI's explain() is checked against the real
 // builder, not the stub — that mismatch is a silent "grade=undefined" in an
 // ideator's terminal, which no route-level assertion above would catch.
-const { explain } = require('../scripts/gds/spark.js');
+const { explain } = require('../scripts/bongos/spark.js');
 const { envelope } = require('../src/bongos/api-errors.js');
 
 await test('the CLI reads each refusal off the REAL envelope shape', async () => {

package/tests/idea_spark_queue.mjs

@@ -194,7 +194,7 @@ await test('the count query takes no limit — it counts the whole queue', async
 
 // --- the CLI's rendering of the queue ------------------------------------
 
-const { renderQueue } = require('../scripts/gds/spark.js');
+const { renderQueue } = require('../scripts/bongos/spark.js');
 
 await test('the empty queue reads as an ANSWER, not a blank screen', () => {
   const out = renderQueue({ sparks: [], count: 0 });

package/tests/idea_triage.mjs

@@ -164,7 +164,7 @@ await test('listOpenIdeas selects the triage-provenance columns', async () => {
 });
 
 // ── task 1003623: batch-cluster follow-ups ─────────────────────────────────
-const triage = require('../scripts/gds/triage.js');
+const triage = require('../scripts/bongos/triage.js');
 const fakeRl = (answers) => {
   const asked = [];
   return { asked, question: (q, cb) => { asked.push(q); cb(answers.shift() ?? 's'); } };

package/tests/idea_triage_grade.mjs

@@ -27,7 +27,7 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const { gradeLabel, partition } = require('../scripts/gds/render-ideas.js');
+const { gradeLabel, partition } = require('../scripts/bongos/render-ideas.js');
 
 const open = (o) => ({ status: 'open', captured_at: '2026-08-01T00:00:00Z', ...o });
 
@@ -141,14 +141,14 @@ test('a non-open idea is not in either open group', () => {
 test('the interactive walk and the generated file share ONE grade label', () => {
   // Two triage surfaces describing the same idea differently defeats the point of
   // a grade at a glance, so triage.js imports the label rather than restating it.
-  const triage = fs.readFileSync(path.join(ROOT, 'scripts/gds/triage.js'), 'utf8');
+  const triage = fs.readFileSync(path.join(ROOT, 'scripts/bongos/triage.js'), 'utf8');
   assert.match(triage, /require\('\.\/render-ideas'\)/, 'triage.js imports the shared helpers');
   assert.match(triage, /gradeLabel\(idea\)/, 'and prints the shared label on each card');
   assert.ok(!/FULL \$\{|SPARK —/.test(triage), 'triage.js does not restate the label text');
 });
 
 test('the walk is ordered by the shared partition, not re-sorted locally', () => {
-  const triage = fs.readFileSync(path.join(ROOT, 'scripts/gds/triage.js'), 'utf8');
+  const triage = fs.readFileSync(path.join(ROOT, 'scripts/bongos/triage.js'), 'utf8');
   assert.match(triage, /partition\(ideas\)/);
   assert.match(triage, /openFull\.concat\(grouped\.openRest\)/, 'full ideas first, then the rest');
 });

package/tests/idea_vote_permission.mjs

@@ -0,0 +1,113 @@
+// tests/idea_vote_permission.mjs — voting on ideas has its OWN permission,
+// `idea.vote`, granted by default exactly where `task.vote` is (task 1004834,
+// follow-up to task 1004727, which reused task.vote for both).
+//
+// What it pins:
+//   * the idea-vote route checks idea.vote: it refuses a builder who holds only
+//     task.vote and admits one who holds idea.vote;
+//   * the default grant matches the task-vote grant: same catalog floor, same
+//     RANK_SEED ranks, the same "reviewer" job grant, and a migration that
+//     copies the grant to every rank holding task.vote on a live project;
+//   * the permission is resolved server-side into /me, and the shared vote
+//     control hides idea buttons for a viewer who does not hold it (it never
+//     re-derives authority from rank).
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const read = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8').replace(/\r\n/g, '\n');
+const auth = require(path.join(ROOT, 'src', 'bongos', 'auth.js'));
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const { attachFail } = require(path.join(ROOT, 'src', 'bongos', 'middleware', 'error-envelope.js'));
+const catalog = require(path.join(ROOT, 'modules', 'government', 'catalog.js'));
+
+function fakeRes() {
+  const res = { _status: null, _json: null, status(c) { this._status = c; return this; }, json(b) { this._json = b; return this; } };
+  attachFail({}, res, () => {});
+  return res;
+}
+async function gate(perms) {
+  seams._reset();
+  seams.registerProvider('government', { resolveBuilderPermissions: async () => perms });
+  const res = fakeRes();
+  let nexted = false;
+  await auth.requirePermission('idea.vote')({ builder: { id: 7, rank: 'metic' } }, res, () => { nexted = true; });
+  seams._reset();
+  return { res, nexted };
+}
+
+// The route's own gate list, read from the shipped source.
+const inboxSrc = read('modules/ideas/routes/inbox.js');
+const voteRoute = inboxSrc.slice(inboxSrc.indexOf("router.post('/inbox/:id(\\\\d+)/vote'"));
+
+test('the idea-vote route gates on idea.vote, not task.vote', () => {
+  assert.ok(voteRoute.length > 0, 'the route is still where this test reads it');
+  const head = voteRoute.slice(0, voteRoute.indexOf('async (req, res)'));
+  assert.match(head, /requirePermission\('idea\.vote'\)/);
+  assert.doesNotMatch(head, /task\.vote/);
+});
+
+test('without idea.vote the gate refuses, even holding task.vote', async () => {
+  const { res, nexted } = await gate(['task.vote']);
+  assert.equal(nexted, false);
+  assert.equal(res._status, 403);
+  assert.equal(res._json.error.code, 'permission_forbidden');
+});
+
+test('with idea.vote the gate admits', async () => {
+  const { res, nexted } = await gate(['idea.vote']);
+  assert.equal(nexted, true);
+  assert.equal(res._status, null);
+});
+
+test('the default grant matches the task-vote grant', () => {
+  const idea = catalog.byKey('idea.vote');
+  const task = catalog.byKey('task.vote');
+  assert.ok(idea, 'idea.vote is in the catalog, so the permissions page lists it and can edit it');
+  assert.equal(idea.floor, task.floor);
+  assert.equal(idea.system, task.system);
+  for (const [rank, keys] of Object.entries(catalog.RANK_SEED)) {
+    assert.equal(keys.includes('idea.vote'), keys.includes('task.vote'), `${rank}: idea.vote is seeded exactly where task.vote is`);
+  }
+  assert.match(read('modules/government/recommendations.js'), /reviewer: freeze\(\[[^\]]*'task\.vote'[^\]]*'idea\.vote'/,
+    'the reviewer job that hands out task.vote hands out idea.vote too');
+});
+
+test('the migration copies the grant to every rank that holds task.vote today', () => {
+  const dir = path.join(ROOT, 'modules', 'government', 'migrations');
+  const file = fs.readdirSync(dir).find((f) => /idea_vote/.test(f));
+  assert.ok(file, 'a government migration grants idea.vote');
+  const sql = read(`modules/government/migrations/${file}`);
+  assert.match(sql, /SELECT rp\.rank_key, 'idea\.vote'\s+FROM government_rank_permissions rp\s+WHERE rp\.permission_key = 'task\.vote'/);
+  assert.match(sql, /ON CONFLICT \(rank_key, permission_key\) DO NOTHING/);
+});
+
+test('/me resolves idea.vote for the page', () => {
+  assert.match(read('src/bongos/routes/me.js'), /NAV_PERMISSION_ATOMS = Object\.freeze\(\[[^\]]*'idea\.vote'/);
+  assert.match(read('modules/hall-ui/public/shell.js'), /permissions: function \(\) \{ return access\.permissions; \}/);
+});
+
+function bootControl(perms) {
+  const ctx = { console, fetch: async () => ({ ok: true, json: async () => ({ votes: {} }) }) };
+  ctx.window = ctx;
+  ctx.OTBShell = { permissions: () => perms };
+  vm.createContext(ctx);
+  vm.runInContext(read('modules/hall-ui/public/vote-control.js'), ctx);
+  return ctx.OTBVote;
+}
+
+test('the control hides idea buttons for a viewer without idea.vote', () => {
+  assert.match(bootControl({ 'idea.vote': true }).ideaHtml({ id: 9 }), /data-vote-kind="idea"/);
+  assert.equal(bootControl({ 'idea.vote': false }).ideaHtml({ id: 9 }), '');
+  assert.equal(bootControl({}).ideaHtml({ id: 9 }), '');
+  // Unknown yet (/me still loading): rendered hidden, never shown on a guess.
+  assert.match(bootControl(null).ideaHtml({ id: 9 }), /data-vote-kind="idea"[^>]* hidden/);
+  // Task rows are unaffected by the idea permission.
+  assert.match(bootControl({ 'idea.vote': false }).taskHtml({ id: 5, status: 'shipped' }), /data-vote-kind="task"/);
+});

package/tests/idea_votes_fold_db.mjs

@@ -0,0 +1,123 @@
+// tests/idea_votes_fold_db.mjs — idea votes fold into karma through the REAL
+// weekly fold, against a real Postgres (task 1004727).
+//
+// The owner's decisions (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 as a task vote, including the 7-day lag. The DB-free sibling
+// (tests/karma_vote_lists.mjs) proves the guards over a scripted pool and reads
+// the fold's text; only a transaction engine can prove the fold itself:
+//   - a matured idea vote lands in karma_log for the SUBMITTER, not the voter;
+//   - a vote younger than the lag is left alone, untallied;
+//   - a tallied vote is stamped, so a second run folds nothing again;
+//   - the guarded write path (modules/ideas/votes.js) refuses a self-vote and
+//     a change to a tallied vote, against the real table.
+//
+// Self-skips without a reachable Postgres; in the INTEGRATION set
+// (scripts/bongos/run-unit-tests.js), which applies every module migration first.
+//
+// Run:  DATABASE_URL=... node tests/idea_votes_fold_db.mjs
+import { createRequire } from 'node:module';
+import { strict as assert } from 'node:assert';
+
+const require = createRequire(import.meta.url);
+const api = require('../src/module-api');
+const pool = api.pool;
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`idea_votes_fold_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+const { tallyPeerVotes } = require('../modules/lifecycle/db-analytics.js');
+const { castIdeaVote } = require('../modules/ideas/votes.js');
+
+const VOTER_A = 90004701;
+const VOTER_B = 90004702;
+const SUBMITTER = 90004703;
+const IDEA = 90004711;
+
+const q = (sql, params) => pool.query(sql, params).then((r) => r.rows);
+
+async function cleanup() {
+  await q('DELETE FROM ideas_votes WHERE target_idea_id = $1', [IDEA]);
+  await q('DELETE FROM karma_log WHERE builder_id = ANY($1)', [[VOTER_A, VOTER_B, SUBMITTER]]);
+  await q('DELETE FROM idea_inbox WHERE id = $1', [IDEA]);
+  await q('DELETE FROM builders WHERE id = ANY($1)', [[VOTER_A, VOTER_B, SUBMITTER]]);
+}
+
+let failures = 0;
+let ran = 0;
+const check = async (name, fn) => {
+  ran += 1;
+  try { await fn(); console.log(`  PASS  ${name}`); } catch (e) {
+    failures += 1; console.log(`  FAIL  ${name}\n        ${e.message}`);
+  }
+};
+
+const karmaFor = async (id) => {
+  const [r] = await q('SELECT COALESCE(SUM(delta), 0)::int AS k FROM karma_log WHERE builder_id = $1', [id]);
+  return r.k;
+};
+
+try {
+  await cleanup();
+  for (const [id, login] of [[VOTER_A, '__iv_a__'], [VOTER_B, '__iv_b__'], [SUBMITTER, '__iv_sub__']]) {
+    // github_id is NOT NULL UNIQUE (migrations/003_pms.sql); the id doubles as a
+    // collision-free stand-in.
+    await q("INSERT INTO builders (id, github_id, github_login, display_name, rank) VALUES ($1, $2, $3, $3, 'metic')", [id, String(id), login]);
+  }
+  await q("INSERT INTO idea_inbox (id, title, captured_by) VALUES ($1, '__iv__ an idea worth voting on', $2)", [IDEA, SUBMITTER]);
+
+  await check('the guarded write refuses a vote on your own idea', async () => {
+    const r = await castIdeaVote(pool, { voterId: SUBMITTER, ideaId: IDEA, vote: 1 });
+    assert.equal(r.code, 'self_vote_forbidden');
+  });
+
+  await check('two votes are cast through the guarded write', async () => {
+    assert.equal((await castIdeaVote(pool, { voterId: VOTER_A, ideaId: IDEA, vote: 1 })).ok, true);
+    const r = await castIdeaVote(pool, { voterId: VOTER_B, ideaId: IDEA, vote: 1 });
+    assert.equal(r.ok, true);
+    assert.equal(r.net_votes, 2);
+  });
+
+  // A's vote is past the lag; B's was cast just now.
+  await q("UPDATE ideas_votes SET recorded_at = now() - interval '8 days' WHERE voter_builder_id = $1 AND target_idea_id = $2", [VOTER_A, IDEA]);
+
+  const before = await karmaFor(SUBMITTER);
+  const first = await tallyPeerVotes();
+
+  await check('the matured idea vote folds into the SUBMITTER, at the weight of a task vote', async () => {
+    assert.equal((await karmaFor(SUBMITTER)) - before, 1);
+    assert.ok(first.idea_votes_tallied >= 1);
+    const [row] = await q("SELECT reason FROM karma_log WHERE builder_id = $1 ORDER BY id DESC LIMIT 1", [SUBMITTER]);
+    assert.equal(row.reason, 'peer_vote_weekly', 'the same fold row as a task vote');
+  });
+
+  await check('the voter earns nothing from casting', async () => {
+    assert.equal(await karmaFor(VOTER_A), 0);
+  });
+
+  await check('a vote younger than the lag is left untallied', async () => {
+    const [b] = await q('SELECT tallied_at FROM ideas_votes WHERE voter_builder_id = $1 AND target_idea_id = $2', [VOTER_B, IDEA]);
+    assert.equal(b.tallied_at, null);
+  });
+
+  await check('a second run folds nothing again', async () => {
+    const k = await karmaFor(SUBMITTER);
+    await tallyPeerVotes();
+    assert.equal(await karmaFor(SUBMITTER), k);
+  });
+
+  await check('a tallied vote is frozen against change and clearing', async () => {
+    assert.equal((await castIdeaVote(pool, { voterId: VOTER_A, ideaId: IDEA, vote: -1 })).code, 'vote_already_counted');
+    assert.equal((await castIdeaVote(pool, { voterId: VOTER_A, ideaId: IDEA, vote: 0 })).code, 'vote_already_counted');
+  });
+} finally {
+  await cleanup().catch(() => {});
+  await pool.end().catch(() => {});
+}
+
+console.log(`\nidea_votes_fold_db: ${ran - failures} passed, ${failures} failed`);
+process.exit(failures ? 1 : 0);

package/tests/infra_exec_paths.mjs

@@ -20,7 +20,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
-const { lintInfraExec } = require('../scripts/gds/lint-infra-exec.js');
+const { lintInfraExec } = require('../scripts/bongos/lint-infra-exec.js');
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const REPO = path.resolve(__dirname, '..');
 const LAUNCHER = path.join(REPO, 'infra', 'core-node.sh');
@@ -52,7 +52,7 @@ hostTest('lint-infra-exec: every core-script unit resolves in a consumer layout
   assert.ok(r.checked.length >= 2, `expected the core-script units repointed + resolving, got ${r.checked.length}`);
   // The core CLIs the units invoke are all covered.
   const rels = new Set(r.checked.map((c) => c.rel));
-  for (const rel of ['scripts/gds/provision.js', 'scripts/gds/search-ingest-db.js']) {
+  for (const rel of ['scripts/bongos/provision.js', 'scripts/bongos/search-ingest-db.js']) {
     assert.ok(rels.has(rel), `expected a unit routing through ${rel}`);
   }
 });
@@ -62,10 +62,10 @@ test('lint-infra-exec: a bare repo-relative core ExecStart is flagged (counterfa
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'infra-lint-'));
   try {
     fs.mkdirSync(path.join(tmp, 'infra'), { recursive: true });
-    fs.mkdirSync(path.join(tmp, 'scripts', 'gds'), { recursive: true });
-    fs.writeFileSync(path.join(tmp, 'scripts', 'gds', 'provision.js'), '// probe\n');
+    fs.mkdirSync(path.join(tmp, 'scripts', 'bongos'), { recursive: true });
+    fs.writeFileSync(path.join(tmp, 'scripts', 'bongos', 'provision.js'), '// probe\n');
     fs.writeFileSync(path.join(tmp, 'infra', 'legacy.service'),
-      '[Service]\nExecStart=/usr/bin/node scripts/gds/provision.js run-intents --apply\n');
+      '[Service]\nExecStart=/usr/bin/node scripts/bongos/provision.js run-intents --apply\n');
     const r = lintInfraExec({ instanceRoot: tmp, coreRoot: tmp });
     assert.ok(!r.ok, 'a bare repo-relative core ExecStart must fail the lint');
     assert.equal(r.violations.length, 1);
@@ -84,20 +84,20 @@ function runLauncher(rel, instanceRoot) {
 hostTest('core-node.sh resolves the monolith layout (script at the instance root)', HAS_LAUNCHER, () => {
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'cn-mono-'));
   try {
-    fs.mkdirSync(path.join(tmp, 'scripts', 'gds'), { recursive: true });
-    fs.writeFileSync(path.join(tmp, 'scripts', 'gds', 'probe.js'), 'console.log("MONOLITH");\n');
-    assert.equal(runLauncher('scripts/gds/probe.js', tmp), 'MONOLITH');
+    fs.mkdirSync(path.join(tmp, 'scripts', 'bongos'), { recursive: true });
+    fs.writeFileSync(path.join(tmp, 'scripts', 'bongos', 'probe.js'), 'console.log("MONOLITH");\n');
+    assert.equal(runLauncher('scripts/bongos/probe.js', tmp), 'MONOLITH');
   } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
 });
 
 hostTest('core-node.sh falls back to the consumer layout (script only under node_modules/@bongos/core)', HAS_LAUNCHER, () => {
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'cn-cons-'));
   try {
-    const pkgDir = path.join(tmp, 'node_modules', '@bongos', 'core', 'scripts', 'gds');
+    const pkgDir = path.join(tmp, 'node_modules', '@bongos', 'core', 'scripts', 'bongos');
     fs.mkdirSync(pkgDir, { recursive: true });
     fs.writeFileSync(path.join(pkgDir, 'probe.js'), 'console.log("CONSUMER");\n');
-    // No scripts/gds/probe.js at the instance root → the resolver must reach node_modules.
-    assert.equal(runLauncher('scripts/gds/probe.js', tmp), 'CONSUMER');
+    // No scripts/bongos/probe.js at the instance root → the resolver must reach node_modules.
+    assert.equal(runLauncher('scripts/bongos/probe.js', tmp), 'CONSUMER');
   } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
 });
 
@@ -105,7 +105,7 @@ hostTest('core-node.sh exits non-zero when the script is in NO layout', HAS_LAUN
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'cn-none-'));
   let threw = false;
   try {
-    execFileSync('bash', [LAUNCHER, 'scripts/gds/nope.js'], {
+    execFileSync('bash', [LAUNCHER, 'scripts/bongos/nope.js'], {
       encoding: 'utf8', stdio: 'pipe', env: { ...process.env, BONGOS_INSTANCE_ROOT: tmp },
     });
   } catch (_) { threw = true; }

package/tests/init.mjs

@@ -1,6 +1,6 @@
 // tests/init.mjs
 //
-// Unit tests for the PURE builders of `bongos init` (scripts/gds/init.js,
+// Unit tests for the PURE builders of `bongos init` (scripts/bongos/init.js,
 // task 1204 / V4.R65) — config assembly, kickoff-task generation, spec
 // validation, and the version payload. No I/O, no network (writeConfigs /
 // seedViaApi are exercised end-to-end by `bongos init --dry-run` + the C8
@@ -15,7 +15,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 const require = createRequire(import.meta.url);
-const init = require('../scripts/gds/init.js');
+const init = require('../scripts/bongos/init.js');
 
 let passed = 0;
 let failed = 0;

package/tests/instance_db_migrated_on_code_move.mjs

@@ -22,16 +22,16 @@ import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { upgradeInvocation } from '../scripts/gds/provision-core-upgrade.js';
-import { migrateCmd, standaloneMigrateCmd, dbName } from '../scripts/gds/provision-repo.js';
-import { CORE_MIGRATE_SCRIPT } from '../scripts/gds/upgrade-migrate.js';
-import { INSTANCE_MIGRATE_SCRIPT } from '../scripts/gds/init.js';
+import { upgradeInvocation } from '../scripts/bongos/provision-core-upgrade.js';
+import { migrateCmd, standaloneMigrateCmd, dbName } from '../scripts/bongos/provision-repo.js';
+import { CORE_MIGRATE_SCRIPT } from '../scripts/bongos/upgrade-migrate.js';
+import { INSTANCE_MIGRATE_SCRIPT } from '../scripts/bongos/init.js';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const tenant = { slug: 'charter', db_name: 'charter_db', hosting_shape: 'co-tenant', port: 3107, status: 'active' };
 
 test('bongos upgrade migrates before it restarts, and only --skip-migrate opts out', () => {
-  const src = fs.readFileSync(path.join(ROOT, 'scripts/gds/upgrade.js'), 'utf8');
+  const src = fs.readFileSync(path.join(ROOT, 'scripts/bongos/upgrade.js'), 'utf8');
   const migrate = src.indexOf('const mig = await runMigrate(instanceDir, run, opts.migrateAs || null);'); // async since task 1004734 (teed output)
   const restart = src.lastIndexOf('restartService({ service: opts.service, restartCmd: opts.restartCmd }');
   assert.ok(migrate > 0, 'the upgrade flow runs migrate');

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');