@bongos/core 1.21.166 → 1.21.168

package/tests/hall_city_rewording.mjs

@@ -0,0 +1,51 @@
+// tests/hall_city_rewording.mjs — a matter sent for a rewrite (the "?", owner
+// 2026-10-23) leaves the to-do until its new words land, and is counted apart
+// as "Rewording", building by building.
+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 { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules/hall-ui/public');
+
+function boot() {
+  const ctx = { console, document: {} };
+  ctx.window = ctx;
+  vm.createContext(ctx);
+  vm.runInContext(fs.readFileSync(path.join(PUB, 'city-decide.js'), 'utf8'), ctx);
+  return ctx.window.GovCityDecide;
+}
+const DOCKET = { matters: [
+  { id: 'blockers:1', building: 'planning', unclear: { times: 1 } },
+  { id: 'blockers:2', building: 'planning' },
+  { id: 'redteam_reports:3', building: 'disputes', unclear: { times: 2 } },
+] };
+
+test('a flagged matter is left out of the queue as if answered, and the answered stay out too', () => {
+  const G = boot();
+  const done = JSON.parse(JSON.stringify(G.withoutReworded({ 'blockers:9': true }, DOCKET)));
+  assert.deepEqual(Object.keys(done).sort(), ['blockers:1', 'blockers:9', 'redteam_reports:3']);
+  assert.equal(done['blockers:2'], undefined, 'an unflagged matter stays in the queue');
+});
+
+test('Rewording counts per building, and everywhere', () => {
+  const G = boot();
+  assert.equal(G.rewordingCount(DOCKET, 'planning'), 1);
+  assert.equal(G.rewordingCount(DOCKET, 'disputes'), 1);
+  assert.equal(G.rewordingCount(DOCKET, 'treasury'), 0);
+  assert.equal(G.rewordingCount(DOCKET, null), 2);
+  assert.equal(G.rewordingCount({ matters: [] }, null), 0);
+});
+
+test('the "?" asks before it sends: the send lives behind a confirm button', () => {
+  const src = fs.readFileSync(path.join(PUB, 'city-decide.js'), 'utf8');
+  const fn = src.split('function unclearButton')[1].split('\n  }\n')[0];
+  const send = fn.indexOf("on.send({ method: 'POST'");
+  const confirm = fn.indexOf("go.addEventListener('click'");
+  assert.ok(send > 0 && confirm > 0 && send > confirm, 'the request is sent only from the confirm button');
+  assert.match(fn, /Send this to Claude to rewrite\?/);
+  assert.match(fn, /Nothing is decided or changed/);
+});

package/tests/hall_city_switchboard.mjs

@@ -0,0 +1,63 @@
+// tests/hall_city_switchboard.mjs — Automation as a switchboard (owner, 2026-10-23).
+// The board draws only the switches the docket hands THIS viewer, every flip
+// sends the desk row's own request, and the fence is never a to-do.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules/hall-ui/public');
+const require = createRequire(import.meta.url);
+const autoDocket = require(path.join(ROOT, 'modules/autonomy/governor-docket.js'));
+const FIXTURE = JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts/hall-preview/fixtures/government__docket.json'), 'utf8'));
+const DOCKET = FIXTURE.body || FIXTURE;
+
+function boot() {
+  const ctx = { console };
+  ctx.window = ctx;
+  vm.createContext(ctx);
+  for (const f of ['street-draw.js', 'street-card.js', 'street-inside.js', 'street-desk.js', 'city-switchboard.js']) vm.runInContext(fs.readFileSync(path.join(PUB, f), 'utf8'), ctx);
+  return ctx;
+}
+const j = (v) => JSON.parse(JSON.stringify(v));
+const GOALS = [{ id: '1000089', title: 'Working area 3', status: 'open' }];
+
+test('the fence is a standing state, never a to-do', () => {
+  for (const mayManage of [true, false]) {
+    for (const p of [{ enabled: false, goals: [] }, { enabled: true, goals: [] }]) {
+      assert.equal(autoDocket.fenceDocketMatters(p, mayManage)[0].state, 'settled');
+    }
+  }
+  assert.deepEqual(autoDocket.switchDeskRows({ enabled: false, goals: [] })[0].acts, [{ key: 'switch_on' }], 'off: the master row switches it on');
+  assert.equal(autoDocket.switchDeskRows({ enabled: true, goals: [] })[0].acts[0].key, 'switch_off', 'on, even with no goal: the master row switches it off');
+});
+
+test('the board draws the viewer\'s switches, and each flip is the desk row\'s request', () => {
+  const w = boot();
+  const m = j(w.GovCitySwitchboard.model(DOCKET, { now: Date.parse('2026-10-09T15:00:00Z'), goals: GOALS }));
+  assert.deepEqual(m.groups.map((g) => g.title), ['AI builds on its own (Autobongos)', 'Goals the AI may work on', 'Computers doing the building']);
+  const master = m.groups[0].switches[0];
+  assert.equal(master.on, false);
+  const live = w.GovCitySwitchboard.model(DOCKET, { now: Date.parse('2026-10-09T15:00:00Z'), goals: GOALS });
+  const flip = live.groups[0].switches[0].flip;
+  assert.deepEqual(j(w.GovMatterCard.request(flip.row.card, flip.key, flip.input)), { method: 'POST', url: '/api/bongos/autonomy/fence', body: { enabled: true } });
+  const goal = live.groups[1].switches[0];
+  assert.equal(goal.on, false, 'an open goal not yet allowed is an off switch');
+  assert.deepEqual(j(w.GovMatterCard.request(goal.flip.row.card, goal.flip.key, goal.flip.input)).body, { goal_id: 1000089 });
+  const runner = live.groups[2].switches[0];
+  assert.equal(runner.on, true);
+  assert.ok(runner.flip.reasons.length > 0, 'pausing a runner asks why, in one tap');
+});
+
+test('a viewer handed no Automation desks gets no switches', () => {
+  const w = boot();
+  const bare = j(DOCKET);
+  bare.desks = bare.desks.filter((d) => !/^automation\./.test(d.key));
+  const m = j(w.GovCitySwitchboard.model(bare, { goals: GOALS }));
+  assert.equal(m.any, false);
+  assert.deepEqual(m.groups, []);
+});

package/tests/hall_gov_real_site.mjs

@@ -555,9 +555,9 @@ test('a Lead the government appointed stands on their building on a real site; e
     assert.match(hit('planning').attrs['aria-label'], new RegExp('led by ' + A_REAL_LEAD));
     assert.match(hit('release').attrs['aria-label'], /held by the owner/);
     hit('planning').fire('click');
-    assert.match(city.byId.get('cityCard').textContent, new RegExp('Led by ' + A_REAL_LEAD + '\\.'));
+    assert.match(city.byId.get('cityCard').children[0].children[0].attrs.title, new RegExp('Led by ' + A_REAL_LEAD + '\\.'));
     hit('treasury').fire('click');
-    assert.match(city.byId.get('cityCard').textContent, /hold(s)? it until a Lead is seated\./);
+    assert.match(city.byId.get('cityCard').children[0].children[0].attrs.title, /hold(s)? it until a Lead is seated\./);
     noPrototype(city, 'city card with real Leads', { seatsRead: true });
     const street = await bootStreet('', false);
     assert.ok(street.calls.includes('/api/bongos/government/leads'), 'the street reads it too');

package/tests/hall_sky.mjs

@@ -216,6 +216,24 @@ await test('the rings are the criteria, closing as each is satisfied and thick w
   assert.equal(g.tasks.find((t) => t.id === '500').sourceRef, '10', 'and which thought it was born of');
 });
 
+await test('abandoned work is listed at zero and adds nothing to a well or its ring (task 1004782)', async () => {
+  const base = well();
+  const p = await boot({ sky: sky([well({
+    criteria: [{ ...base.criteria[0], task_ids: ['500', '504'] }, { ...base.criteria[1], task_ids: ['501', '502', '503'] }],
+    tasks: [
+      ...base.tasks,
+      { id: '503', title: 'A dropped task', status: 'abandoned', credits_reward: 500, created_on: '2026-08-03', idea_id: null },
+      // merged away: the DB only allows merged_into_task_id on an abandoned row, so this is its whole shape
+      { id: '504', title: 'A task folded into 500', status: 'abandoned', merged_into_task_id: '500', credits_reward: 90, created_on: '2026-08-04', idea_id: null },
+    ],
+  })]) });
+  const g = p.S().goalById.get('7');
+  assert.equal(g.tasks.find((t) => t.id === '503').credits, 0, 'still listed, at zero');
+  assert.equal(g.tasks.find((t) => t.id === '504').credits, 0, 'a merged-away task is listed at zero too');
+  assert.equal(g.credits, 130, 'the well\'s mass is the live work only (60 + 40 + 30)');
+  same(g.crit.map((c) => c.credits), [60, 70], 'and the ring it sat on is not thickened by it');
+});
+
 await test('a private goal keeps its structure and none of its prose', async () => {
   const p = await boot({ sky: sky([well({ goal_id: '8', title: null, subtitle: null, criteria: [{ id: '80', criterion_id: 'c1', criterion_md: null, satisfied: false, pending_review: false, task_ids: [] }], tasks: [{ id: '800', title: null, status: 'ready', credits_reward: 10, created_on: '2026-08-01', idea_id: null }] })]) });
   const g = p.S().goalById.get('8');

package/tests/hall_street_deck.mjs

@@ -141,7 +141,6 @@ test('a real answer is the desk row\'s own request, to the route the desk uses',
     'redteam_reports:confirm': 'POST /api/bongos/security/reports/N/confirm',
     'redteam_reports:dispute': 'POST /api/bongos/security/reports/N/dispute',
     'override_requests:release': 'POST /api/bongos/override-requests/N/decide',
-    'autobongos_fence:switch_on': 'POST /api/bongos/autonomy/fence',
     'treasury_spending:answer': 'POST /api/bongos/government/treasury/borrows/N/answer',
   });
   // a blocker's option is its own chip, so its words are the resolution note
@@ -151,8 +150,11 @@ test('a real answer is the desk row\'s own request, to the route the desk uses',
   const cr = K.cardView(lv.city.asks.find((x) => x.id === 'criteria_uat:1000184'), c);
   assert.deepEqual(cr.options.map((o) => o.plan.mode), ['record', 'send', 'note']);
   assert.equal(cr.options[0].plan.id, '1000184');
-  const fence = K.cardView(lv.city.asks.find((x) => x.id === 'autobongos_fence:fence'), c);
-  assert.deepEqual(fence.options.map((o) => o.plan.mode), ['send', 'note']);
+  // the fence is a standing state on the Automation switchboard, never a to-do
+  // (task 1004784): its matter is settled and carries no act, so the switch is
+  // flipped from the switchboard's desk row, not from a card
+  const fence = lv.city.asks.find((x) => x.id === 'autobongos_fence:fence');
+  assert.ok(!fence || fence.state !== 'needs', 'the fence never waits on anyone');
 });
 
 test('a viewer the server hands no acts gets answers marked not from here, never a send', () => {
@@ -492,7 +494,7 @@ test('the page: #deck draws the top card over the street; a key answers it throu
   assert.equal(next.getAttribute('data-ask'), 'blockers:1000143');
   assert.match(next.className, /\bask--rise\b/, 'the next one rises');
   assert.equal(p.cls(p.deck(), 'deck-dock__of')[0].textContent, ' of 8 to do');
-  assert.equal(p.byId.get('hudNeeds').textContent, '37', 'the street\'s header moves with the deck');
+  assert.equal(p.byId.get('hudNeeds').textContent, '36', 'the street\'s header moves with the deck');
 });
 
 test('the page: a refusal keeps the card and counts nothing; S skips to the back', async () => {

package/tests/hall_street_depth.mjs

@@ -276,7 +276,7 @@ test('what needs you lights salmon windows on the floor that holds it, with a ri
   assert.ok(d.windows.some((w) => w.building === 'planning'), 'the viewer leads Planning');
   assert.ok(!d.windows.some((w) => ['review', 'release', 'treasury'].includes(w.building)), 'what waits on another Lead lights nothing');
   // the hub as it is (no Lead read, everything on the owner seat): every docket need is the viewer's own
-  assert.deepEqual(street({ leads: null, docket: fx('government__docket') }).depth.windows.map((w) => w.key), ['needs:automation:0', 'needs:disputes:0', 'needs:planning:2', 'needs:release:0', 'needs:review:1', 'needs:treasury:4']);
+  assert.deepEqual(street({ leads: null, docket: fx('government__docket') }).depth.windows.map((w) => w.key), ['needs:disputes:0', 'needs:planning:2', 'needs:release:0', 'needs:review:1', 'needs:treasury:4']);
   // moving and settled light nothing; nor does a source no floor holds
   const doc2 = clone(doc);
   doc2.matters.forEach((m) => { m.state = 'moving'; });

package/tests/hall_street_desk.mjs

@@ -404,7 +404,8 @@ function actedDocket({ longWords = false, force = true } = {}) {
     desk('people.builders', 'people', buildersRoute.builderDeskRows([{ id: 7, display_name: t('Ana Ruiz'), github_login: 'ana', rank: 'thetes' }, { id: 95, display_name: 'Me', rank: 'archon' }], { viewerId: '95', mayRank: true, mayStop: true, ranks: LADDER })),
     desk('people.ranks', 'people', govFloors.rankDeskRows([{ rank_key: 'tester', label: t('Tester'), is_system: false }, { rank_key: 'archon', label: 'Archon', is_system: true }], [{ builder_id: 7, display_name: 'Ana Ruiz', rank_key: 'tester' }, { builder_id: 8, github_login: 'kai', rank_key: 'metic' }])),
     desk('disputes.confirmed', 'disputes', [reportsRoute.confirmedDeskRow({ id: 3, title: t('token leak'), severity: 'low', confirmed_at: '2026-09-28T10:00:00.000Z' })]),
-    desk('automation.switch', 'automation', autoDocket.switchDeskRows(project)),
+    // the switch is a standing row in either position (the fence matter is settled, never a to-do)
+    desk('automation.switch', 'automation', autoDocket.switchDeskRows({ enabled: false, paused_reason: 'payments touched', goals: [] }).map((r) => ({ ...r, id: 'switch-off' })).concat(autoDocket.switchDeskRows(project))),
     desk('automation.goals', 'automation', autoDocket.goalDeskRows(project)),
     desk('automation.runners', 'automation', autoDocket.runnerDeskRows([{ builder_id: 7, display_name: t('Ana Ruiz'), runners: [{ working_task_id: 12 }] }, { builder_id: 8, owner_paused: true, owner_paused_reason: 'spending too much', runners: [] }], NOW, healthy)),
   ];
@@ -469,10 +470,11 @@ test('Disputes: a report is confirmed or disputed, a confirmed one marked fixed,
 test('Automation: switch on and off, allow a goal from the open goals, first in line, disallow, pause and resume a runner', () => {
   const dk = actedDocket();
   const sw = actedRows(dk, 'automation', 0);
-  const off = sw.find((r) => r.source === 'autobongos_fence');
+  assert.ok(!sw.some((r) => r.source === 'autobongos_fence'), 'the switch is not a to-do: its matter is settled');
+  const off = sw.find((r) => r.actions.some((a) => a.key === 'switch_on'));
   assert.deepEqual(off.actions.map((a) => a.label), ['switch on']);
   assert.deepEqual(j(C.request(off.card, 'switch_on')), { method: 'POST', url: '/api/bongos/autonomy/fence', body: { enabled: true } });
-  const on = sw.find((r) => r.desk);
+  const on = sw.find((r) => r.actions.some((a) => a.key === 'switch_off'));
   assert.deepEqual(j(C.request(on.card, 'switch_off', on.choices.switch_off.options[0].input)).body, { enabled: false, reason: 'pause for now' });
   const goals = actedRows(dk, 'automation', 1);
   const first = goals.find((r) => r.name === 'Governor city');

package/tests/hall_tweak_editor.mjs

@@ -805,6 +805,32 @@ try {
     assert.equal(b.el('tw-frame').hidden, true);
   });
 
+  // task 1004776: a guarded line shows what it must still say under it, and the
+  // note turns to a warning while the artist types words that drop it.
+  await test('a guarded line shows its must-still-say note, and warns as the artist types it away', async () => {
+    const guarded = require('../modules/copy-desk/guarded-lines.js');
+    guarded._setList({ lines: [{ page_id: 'landing:index', file: 'modules/public-landing/public/index.html', must_contain: ['ship the code'], must_still_say: 'Agents ship the code.' }] });
+    try {
+      const ed = editorRead({ draftLines: null });
+      const b = bootEditor({ answers: { 'GET /copy-desk/pages/landing:index/draft': ok(ed) } });
+      await b.settle();
+      assert.equal(b.el('tw-L0004-note').textContent, 'must still say: Agents ship the code.');
+      assert.match(b.el('tw-L0004-note').className, /tw-note--guarded/);
+      b.type('L0004', 'Agents claim the tasks.');
+      assert.equal(b.el('tw-L0004-note').textContent, 'this no longer says what it must · must still say: Agents ship the code.');
+      b.type('L0004', 'Our agents ship the code.');
+      assert.equal(b.el('tw-L0004-note').textContent, 'must still say: Agents ship the code.');
+    } finally {
+      guarded._setList(null);
+    }
+  });
+
+  await test('the submit warning is plain words the editor shows after sending', () => {
+    assert.deepEqual(lib.submitWarningHtml([{ key: 'L0004', must_still_say: 'Agents ship the code.' }]),
+      ['A line you changed no longer says what it must: Agents ship the code. It was sent anyway; the person approving it will see this.']);
+    assert.deepEqual(lib.submitWarningHtml(undefined), []);
+  });
+
   await test('the page writes only the copy-desk routes it names', () => {
     const js = read('tweak-editor.js');
     const writes = [...js.matchAll(/api\.request\('(POST|PUT|PATCH|DELETE)', ([^,]+),/g)].map((m) => `${m[1]} ${m[2]}`);

package/tests/module_promotion.mjs

@@ -0,0 +1,290 @@
+// tests/module_promotion.mjs — the promotion gate: tester to general, and what
+// earns it (task 1003804, ADR 0344 D3; owner decisions 2026-10-23). The rule
+// (decidePromotion) is driven directly; the sweep, the author's standing, the
+// person's release and both routes run against an in-memory stand-in for the
+// four tables they read and the one they write.
+//
+// Run:  node tests/module_promotion.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+const DAY = 24 * 60 * 60 * 1000;
+const NOW = new Date('2026-10-23T12:00:00Z');
+const ago = (days) => new Date(NOW.getTime() - days * DAY).toISOString();
+
+// ---- an in-memory store ---------------------------------------------------
+let state;
+function fresh() {
+  state = {
+    modules: { weather: { module_key: 'weather', title: 'Weather', author_id: 42, status: 'listed' } },
+    versions: [{ id: 7, module_key: 'weather', version: '1.3.0', tarball_sha256: 'x', artifact_path: 'a', published_at: ago(3) }],
+    channels: [{ id: 1, version_id: 7, channel: 'tester', reason: 'new_version', set_by: 9, set_at: ago(3) }],
+    installs: [],
+    errors: [],
+    signals: [
+      { id: 1, version_id: 7, part: 'security', outcome: 'passed', score: null, measured_at: ago(3) },
+      { id: 2, version_id: 7, part: 'tests', outcome: 'scored', score: 100, measured_at: ago(3) },
+    ],
+  };
+  return state;
+}
+fresh();
+
+const newestRow = (vid) => state.channels.filter((c) => String(c.version_id) === String(vid))
+  .sort((a, b) => (b.set_at.localeCompare(a.set_at)) || (b.id - a.id))[0];
+
+const query = async (sql, params = []) => {
+  if (/CROSS JOIN LATERAL/.test(sql)) {
+    const [vid, limit] = params;
+    const ids = [...new Set(state.channels.map((c) => c.version_id))]
+      .filter((id) => vid == null || String(id) === String(vid)).sort((a, b) => a - b);
+    const rows = [];
+    for (const id of ids) {
+      const cur = newestRow(id);
+      if (cur.channel !== 'tester') continue;
+      const v = state.versions.find((x) => x.id === id);
+      const mine = (l) => l.filter((r) => r.version_id === id);
+      rows.push({
+        version_id: id, module_key: v.module_key, version: v.version, current_reason: cur.reason,
+        on_tester_since: mine(state.channels).filter((c) => c.channel === 'tester').map((c) => c.set_at).sort()[0],
+        clean_installs: mine(state.installs).filter((r) => r.ok).length,
+        failed_installs: mine(state.installs).filter((r) => !r.ok).length,
+        runtime_errors: mine(state.errors).reduce((n, e) => n + e.error_count, 0),
+      });
+    }
+    return { rows: rows.slice(0, limit) };
+  }
+  if (/FROM module_assessment_signals/.test(sql)) {
+    const out = new Map();
+    for (const s of [...state.signals].sort((a, b) => b.measured_at.localeCompare(a.measured_at) || b.id - a.id)) {
+      if (!params[0].includes(s.version_id)) continue;
+      const k = `${s.version_id}:${s.part}`;
+      if (!out.has(k)) out.set(k, s);
+    }
+    return { rows: [...out.values()] };
+  }
+  if (/^\s*INSERT INTO store_module_version_channels/.test(sql)) {
+    const [vid, channel, reason, setBy, fromReason] = params;
+    const cur = newestRow(vid);
+    if (!cur || cur.reason !== fromReason) return { rows: [], rowCount: 0 };
+    const id = Math.max(...state.channels.map((c) => c.id)) + 1;
+    // A later set_at than anything already there, so this row is the newest.
+    state.channels.push({ id, version_id: vid, channel, reason, set_by: setBy, set_at: new Date(NOW.getTime() + id).toISOString() });
+    return { rows: [], rowCount: 1 };
+  }
+  if (/SELECT channel, reason, set_by, set_at FROM store_module_version_channels/.test(sql)) {
+    const cur = newestRow(params[0]); return { rows: cur ? [cur] : [] };
+  }
+  if (/FROM store_modules WHERE module_key = \$1/.test(sql)) {
+    const m = state.modules[params[0]]; return { rows: m ? [m] : [] };
+  }
+  if (/FROM store_module_versions WHERE module_key = \$1 AND version = \$2/.test(sql)) {
+    return { rows: state.versions.filter((v) => v.module_key === params[0] && v.version === params[1]) };
+  }
+  return { rows: [] };
+};
+const pool = { connect: async () => ({ query, release() {} }), query };
+const poolPath = require.resolve('../src/bongos/pool.js');
+require.cache[poolPath] = { id: poolPath, filename: poolPath, loaded: true, exports: { pool } };
+
+const {
+  PROMOTE_AFTER_DAYS, EARLY_AFTER_DAYS, EARLY_CLEAN_INSTALLS, decidePromotion, sweepPromotions, readStanding, releaseHeld, start,
+} = require('../src/bongos/module-promotion.js');
+const promo = { PROMOTE_AFTER_DAYS, EARLY_AFTER_DAYS, EARLY_CLEAN_INSTALLS, decidePromotion, sweepPromotions, readStanding, releaseHeld, start };
+const buildModulesRouter = require('../src/bongos/routes/modules.js');
+
+const clean = (n) => { for (let i = 0; i < n; i++) state.installs.push({ version_id: 7, holder_ref: `p${i}`, ok: true }); };
+const current = () => newestRow(7);
+
+// ---- the rule -------------------------------------------------------------
+const ev = (over = {}) => ({
+  onTesterSince: ago(3), held: false, cleanInstalls: 0, failedInstalls: 0, runtimeErrors: 0,
+  security: { outcome: 'passed' }, tests: { outcome: 'scored', score: 100 }, ...over,
+});
+
+test('the owner numbers: 7 days, early from day 2 with 5 clean installs', () => {
+  assert.equal(promo.PROMOTE_AFTER_DAYS, 7);
+  assert.equal(promo.EARLY_AFTER_DAYS, 2);
+  assert.equal(promo.EARLY_CLEAN_INSTALLS, 5);
+});
+
+test('seven days on tester promotes, even with no tester at all', () => {
+  const d = promo.decidePromotion(ev({ onTesterSince: ago(7) }), NOW);
+  assert.equal(d.action, 'promote');
+  assert.equal(d.reason, 'promoted_after_7_days');
+  assert.equal(promo.decidePromotion(ev({ onTesterSince: ago(6.9) }), NOW).action, 'wait');
+});
+
+test('early: day 2 and 5 clean installs; not before day 2, not with 4', () => {
+  assert.equal(promo.decidePromotion(ev({ onTesterSince: ago(2), cleanInstalls: 5 }), NOW).reason, 'promoted_early_clean_installs');
+  assert.equal(promo.decidePromotion(ev({ onTesterSince: ago(1.9), cleanInstalls: 50 }), NOW).action, 'wait');
+  assert.equal(promo.decidePromotion(ev({ onTesterSince: ago(5), cleanInstalls: 4 }), NOW).action, 'wait');
+});
+
+test('any failed tester install or runtime error holds, whatever the age', () => {
+  for (const over of [{ failedInstalls: 1 }, { runtimeErrors: 1 }, { failedInstalls: 1, onTesterSince: ago(30), cleanInstalls: 99 }]) {
+    const d = promo.decidePromotion(ev(over), NOW);
+    assert.equal(d.action, 'hold');
+    assert.equal(d.reason, 'held_tester_errors');
+  }
+});
+
+test('a held version never moves on its own, even at day 30', () => {
+  const d = promo.decidePromotion(ev({ held: true, onTesterSince: ago(30) }), NOW);
+  assert.equal(d.action, 'wait');
+  assert.equal(d.reason, 'held_until_released');
+});
+
+test('security and tests (ADR 0343): moves only when both pass; never held for them', () => {
+  const old = { onTesterSince: ago(10) };
+  assert.equal(promo.decidePromotion(ev({ ...old, security: { outcome: 'failed' } }), NOW).reason, 'checks_not_passed');
+  assert.equal(promo.decidePromotion(ev({ ...old, security: null }), NOW).reason, 'checks_not_passed');
+  assert.equal(promo.decidePromotion(ev({ ...old, tests: { outcome: 'scored', score: 80 } }), NOW).reason, 'checks_not_passed');
+  assert.equal(promo.decidePromotion(ev({ ...old, tests: { outcome: 'pending' } }), NOW).reason, 'checks_not_passed');
+  assert.equal(promo.decidePromotion(ev({ ...old, tests: { outcome: 'no_data' } }), NOW).action, 'promote', 'no tests is not a fail');
+});
+
+// ---- the sweep ------------------------------------------------------------
+test('the sweep promotes early on clean installs, with a new system row', async () => {
+  fresh(); clean(5);
+  const out = await promo.sweepPromotions({ db: pool, now: NOW });
+  assert.deepEqual(out.promoted.map((p) => p.reason), ['promoted_early_clean_installs']);
+  assert.equal(current().channel, 'general');
+  assert.equal(current().set_by, null, 'the system moved it');
+  assert.equal(state.channels.length, 2, 'a move is a new row; the tester row stays');
+  const again = await promo.sweepPromotions({ db: pool, now: NOW });
+  assert.equal(again.promoted.length + again.held.length, 0, 'a general version is not swept again');
+});
+
+test('the sweep holds on an error, once, and the hold outlives day 7', async () => {
+  fresh(); clean(9);
+  state.errors.push({ version_id: 7, error_count: 2 });
+  const out = await promo.sweepPromotions({ db: pool, now: NOW });
+  assert.equal(out.held.length, 1);
+  assert.equal(current().channel, 'tester');
+  assert.equal(current().reason, 'held_tester_errors');
+  assert.equal(current().set_by, null);
+  const later = await promo.sweepPromotions({ db: pool, now: new Date(NOW.getTime() + 30 * DAY) });
+  assert.equal(later.held.length + later.promoted.length, 0, 'no second hold row, no promotion');
+  assert.equal(state.channels.length, 2);
+});
+
+test('the sweep moves an untested version at day 7 and leaves a young one', async () => {
+  fresh();
+  assert.equal((await promo.sweepPromotions({ db: pool, now: NOW })).promoted.length, 0);
+  const out = await promo.sweepPromotions({ db: pool, now: new Date(NOW.getTime() + 4 * DAY) });
+  assert.deepEqual(out.promoted.map((p) => p.reason), ['promoted_after_7_days']);
+});
+
+// ---- the author's standing ------------------------------------------------
+test('an author reads the rule and where their version stands', async () => {
+  fresh(); clean(2);
+  const s = await promo.readStanding(7, { db: pool, now: NOW });
+  assert.equal(s.channel, 'tester');
+  assert.equal(s.moved_by, '9');
+  assert.match(s.rule, /7 days/);
+  assert.match(s.rule, /2 days once 5 or more testers/);
+  assert.equal(s.next.action, 'wait');
+  assert.equal(s.next.clean_installs, 2);
+  assert.equal(s.next.days_on_tester, 3);
+  assert.equal(s.next.general_on, new Date(new Date(ago(3)).getTime() + 7 * DAY).toISOString());
+});
+
+// ---- the person's release -------------------------------------------------
+test('only a held version can be released, and the person is recorded', async () => {
+  fresh();
+  const early = await promo.releaseHeld(7, 3, { db: pool });
+  assert.equal(early.ok, false);
+  assert.equal(early.code, 'not_held');
+  state.installs.push({ version_id: 7, holder_ref: 'p', ok: false });
+  await promo.sweepPromotions({ db: pool, now: NOW });
+  const r = await promo.releaseHeld(7, 3, { db: pool });
+  assert.equal(r.ok, true);
+  assert.equal(current().channel, 'general');
+  assert.equal(current().reason, 'released_by_person');
+  assert.equal(current().set_by, 3);
+  assert.equal((await promo.releaseHeld(7, 3, { db: pool })).code, 'not_held', 'a second release is refused');
+});
+
+// ---- the routes -----------------------------------------------------------
+function handlerFor(router, method, p) {
+  const layer = router.stack.find((l) => l.route && l.route.path === p && l.route.methods[method]);
+  assert.ok(layer, `no ${method.toUpperCase()} ${p} on the router`);
+  const stack = layer.route.stack;
+  return { handle: stack[stack.length - 1].handle, depth: stack.length };
+}
+async function invoke(handle, { key = 'weather', version = '1.3.0', body = {} } = {}) {
+  const res = {
+    statusCode: 200, body: undefined,
+    json(b) { this.body = b; return this; },
+    status(c) { this.statusCode = c; return this; },
+    set() { return this; },
+    fail(code, opts, details) { const o = typeof opts === 'number' ? { status: opts, details } : (opts || {}); this.statusCode = o.status; this.body = { error: code, ...o }; return this; },
+  };
+  let nextErr = null;
+  await handle({ params: { key, version }, body, builder: { id: 3 } }, res, (err) => { nextErr = err; });
+  if (nextErr) throw nextErr;
+  return res;
+}
+const router = buildModulesRouter();
+const release = handlerFor(router, 'post', '/store/modules/:key/versions/:version/release');
+const channel = handlerFor(router, 'get', '/store/modules/:key/versions/:version/channel');
+
+test('release is gated on module.delist (owner, no new permission) and pinned', () => {
+  assert.ok(release.depth >= 3, 'requireBuilder + requirePermission sit in front of the handler');
+  const src = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/modules.js'), 'utf8');
+  assert.match(src, /router\.post\('\/store\/modules\/:key\/versions\/:version\/release', auth\.requireBuilder, auth\.requirePermission\('module\.delist'\)/);
+  const pins = fs.readFileSync(path.join(ROOT, 'src/bongos/route-rank-check.js'), 'utf8');
+  assert.match(pins, /'POST \/store\/modules\/:key\/versions\/:version\/release': 'perm:module\.delist'/);
+  const { byKey } = require('../modules/government/catalog.js');
+  assert.match(byKey('module.delist').guards, /POST \/store\/modules\/:key\/versions\/:version\/release/);
+});
+
+test('release needs a reason, refuses a version not held, and releases a held one', async () => {
+  fresh();
+  for (const body of [{}, { reason: '  ' }]) assert.equal((await invoke(release.handle, { body })).body.error, 'reason_required');
+  assert.equal((await invoke(release.handle, { body: { reason: 'r', channel: 'general' } })).statusCode, 400, 'unknown fields are refused');
+  assert.equal((await invoke(release.handle, { version: '9.9.9', body: { reason: 'r' } })).statusCode, 404);
+  const notHeld = await invoke(release.handle, { body: { reason: 'r' } });
+  assert.equal(notHeld.statusCode, 409);
+  assert.equal(notHeld.body.error, 'not_held');
+  state.errors.push({ version_id: 7, error_count: 1 });
+  await promo.sweepPromotions({ db: pool, now: NOW });
+  const ok = await invoke(release.handle, { body: { reason: 'the error was the tester\'s own config' } });
+  assert.equal(ok.statusCode, 200);
+  assert.equal(ok.body.channel, 'general');
+});
+
+test('the channel read: any signed-in builder, the standing, 404 for no version', async () => {
+  fresh();
+  assert.equal(channel.depth, 2, 'requireBuilder only — the author must be able to read it');
+  const res = await invoke(channel.handle);
+  assert.equal(res.statusCode, 200);
+  assert.equal(res.body.channel, 'tester');
+  assert.equal(res.body.module_key, 'weather');
+  assert.ok(res.body.next);
+  assert.equal((await invoke(channel.handle, { version: '2.0.0' })).statusCode, 404);
+  state.channels = [];
+  const none = await invoke(channel.handle);
+  assert.equal(none.statusCode, 404);
+  assert.equal(none.body.error, 'version_has_no_channel', 'a version with no channel row says so');
+  fresh();
+  assert.equal((await invoke(channel.handle, { key: 'Bad_Key' })).statusCode, 400);
+});
+
+test('the sweep is started by the server after listen, never by a test, and can be switched off', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'src/platform-server.js'), 'utf8');
+  assert.match(src, /require\('\.\/bongos\/module-promotion'\); startPromotionSweep\(\)/);
+  const start = src.indexOf('function startBackgroundServices');
+  const body = src.slice(start, src.indexOf('}', start));
+  assert.doesNotMatch(body, /module-promotion/);
+  assert.equal(promo.start({ env: { MODULE_PROMOTION_DISABLED: '1' } }), false);
+});

package/tests/rebase_gate_set_aside.mjs

@@ -0,0 +1,73 @@
+// tests/rebase_gate_set_aside.mjs — one stuck land must not block every claim
+// (task 1004788). DB-free half: the shared predicate (rebase-gate.js), the 409
+// hint's wording, and that all three claim surfaces call the ONE predicate. The
+// real-DB half (claimTask, claimTasksBatch, validateClaimBatch end to end) is
+// cases 8-10 of tests/claim_gate_rebase.mjs.
+//
+// Run:  node tests/rebase_gate_set_aside.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const gate = require('../modules/lifecycle/rebase-gate.js');
+const { rebaseRequiredHint } = require('../modules/lifecycle/routes/claims.js');
+const { test, summary } = makeRunner();
+
+const row = (id, reason) => ({ id, title: `t${id}`, needs_rebase_reason: reason, needs_rebase_at: null });
+const GUARD = 'strand:branch_modifies_executed_code:.gitattributes,scripts/gds/git-merge-regen.js';
+
+await test('a strand parked on a server-side guard is set aside: it never gates', () => {
+  const s = gate.splitRebaseGate([row(1, GUARD)], { limit: 1 });
+  assert.equal(s.gates, false);
+  assert.deepEqual(s.gating, []);
+  assert.equal(s.waiting.length, 1);
+  assert.match(s.waiting[0].waits_on, /server-side guard/);
+});
+
+await test('an explicit waiting:<what> hold is set aside with what it waits on', () => {
+  assert.equal(gate.waitsOn('waiting:the owner'), 'the owner');
+  assert.equal(gate.waitsOn('strand:unresolvable_conflict:docs/x.json'), null);
+  assert.equal(gate.waitsOn('strand:pr_not_landed'), null);
+  assert.equal(gate.waitsOn(null), null, 'an unknown reason is the builder\'s, never silently waived');
+});
+
+await test('fixable strands gate only at the limit (default 3), not on the first', () => {
+  delete process.env.REBASE_GATE_LIMIT;
+  assert.equal(gate.REBASE_GATE_LIMIT, 3);
+  const one = [row(1, 'strand:pr_not_landed')];
+  const three = [...one, row(2, 'strand:pr_not_landed'), row(3, 'strand:unresolvable_conflict:a')];
+  assert.equal(gate.splitRebaseGate(one).gates, false);
+  assert.equal(gate.splitRebaseGate(three.slice(0, 2)).gates, false);
+  const s = gate.splitRebaseGate([...three, row(9, GUARD)]);
+  assert.equal(s.gates, true);
+  assert.deepEqual(s.gating.map((t) => t.id), [1, 2, 3], 'the waiting one never counts toward the limit');
+  const tasks = gate.rebaseRefusalTasks(s);
+  assert.deepEqual(tasks.map((t) => [t.id, !!t.waiting]), [[1, false], [2, false], [3, false], [9, true]]);
+});
+
+await test('the refusal says which tasks gate and lists the rest as waiting, not on you', () => {
+  const s = gate.splitRebaseGate([row(1, 'strand:pr_not_landed'), row(2, 'strand:pr_not_landed'), row(3, 'strand:pr_not_landed'), row(9, GUARD)]);
+  const h = rebaseRequiredHint(gate.rebaseRefusalTasks(s));
+  assert.match(h, /3 confirmed task\(s\) of yours are waiting to land and need you \(task 1, task 2, task 3\)/);
+  assert.match(h, /Waiting, not on you .*task 9 \(a server-side guard/);
+  assert.match(h, /\/strand-fix N/);
+});
+
+await test('all three claim surfaces call the ONE predicate', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/lifecycle/db-claims.js'), 'utf8');
+  const calls = src.match(/splitRebaseGate\(await gatingRebaseTasksForBuilder\(builderId, (client|pool)\)\)/g) || [];
+  assert.equal(calls.length, 3, 'claimTask, claimTasksBatch and validateClaimBatch');
+  for (const fn of ['async function claimTask(', 'async function claimTasksBatch(', 'async function validateClaimBatch(']) {
+    const start = src.indexOf(fn);
+    const next = src.indexOf('\nasync function ', start + 10);
+    assert.ok(src.slice(start, next < 0 ? undefined : next).includes('splitRebaseGate('), `${fn} uses the shared predicate`);
+  }
+});
+
+summary();

package/tests/reward_mode_surfacing.mjs

@@ -164,5 +164,17 @@ test('hall: the tooltip names the mode and what actually pays', () => {
   assert.match(note, /guide, not a payout/i);
 });
 
+// task 1004782 — abandoned and merged-away tasks are worth 0 wherever a total
+// adds them up, on every reward mode.
+test('hall: an abandoned or merged-away task is worth 0, whatever its estimate', () => {
+  for (const mode of [CPO, PAYS, undefined]) {
+    const B = loadBrandApply(mode);
+    assert.equal(B.taskCreditValue({ status: 'abandoned', credits_reward: 60 }), 0);
+    assert.equal(B.taskCreditValue({ status: 'abandoned', credits_reward: 60, credits_awarded: 12 }), 0);
+    assert.equal(B.taskCreditValue({ status: 'ready', credits_reward: 60, merged_into_task_id: 9 }), 0);
+    assert.equal(B.taskCreditValue(READY_TASK), 60, 'live work keeps its value');
+  }
+});
+
 console.log(`\nreward_mode_surfacing: ${passed} passed, ${failed} failed`);
 process.exit(failed ? 1 : 0);