@bongos/core 1.23.20 → 1.23.22

package/tests/fixtures/per-row-loops-legacy.cjs

@@ -0,0 +1,245 @@
+'use strict';
+
+// tests/fixtures/per-row-loops-legacy.cjs — the FOUR one-query-per-row loops as
+// they stood before task 1004929 batched them, kept verbatim (comments trimmed)
+// so tests/batched_writes_parity.mjs and tests/government_routes.mjs can run the
+// old and the new code over the same fake database and compare what each one
+// returns and leaves behind. A frozen reference, not live code: nothing in src/
+// or modules/ may require it.
+
+const { nonTerminalSql, isTerminalStatus } = require('../../modules/lifecycle/task-status');
+const { cancelPendingMembershipRequests } = require('../../modules/lifecycle/goal-close-sweep.js');
+
+// modules/government/routes/government.js — POST /government/rank-sets/apply,
+// the try-block body. `db` is the government db slice, `rankSet` the
+// recommendedRankSet output. Returns { created, skipped } as the reply carried.
+async function legacyApplyRankSet({ db, catalog, rankSet, builderId }) {
+  const set = rankSet;
+  const created = [];
+  const skipped = [];
+  for (const r of set.ranks) {
+    if (await db.getRankByKey(r.rank_key)) { skipped.push({ rank_key: r.rank_key, label: r.label }); continue; }
+    let rank;
+    try {
+      rank = await db.createRank({ rankKey: r.rank_key, label: r.label, description: r.description, createdBy: builderId });
+    } catch (err) {
+      if (err && err.code === '23505') { skipped.push({ rank_key: r.rank_key, label: r.label }); continue; }
+      throw err;
+    }
+    const granted = [];
+    for (const key of r.permissions) {
+      if (!catalog.byKey(key) || !catalog.isGrantableTo(key, rank)) continue;
+      if (await db.grantRankPermission({ rankKey: r.rank_key, permissionKey: key })) granted.push(key);
+    }
+    created.push({ rank_key: r.rank_key, label: r.label, permissions: granted });
+  }
+  return { created, skipped };
+}
+
+// modules/lifecycle/db-goals.js — archiveGoalWithDispositions, the plan loop.
+// Runs on an open client (the caller has already locked the goal). Returns the
+// applied list, or throws what the loop threw.
+async function legacyArchiveLoop(client, { goalId, plan = [], reason }) {
+  const applied = [];
+  for (const step of plan) {
+    const { rows: tRows } = await client.query(
+      `SELECT id, title, status FROM tasks WHERE id = $1 AND goal_id = $2 FOR UPDATE`,
+      [step.taskId, goalId]
+    );
+    if (!tRows[0]) { applied.push({ task_id: String(step.taskId), verb: step.verb, result: 'skipped_not_in_goal' }); continue; }
+    if (isTerminalStatus(tRows[0].status)) {
+      applied.push({ task_id: String(step.taskId), verb: step.verb, result: 'skipped_already_terminal', status: tRows[0].status });
+      continue;
+    }
+
+    const { rows: claimed } = await client.query(
+      `SELECT id FROM claims WHERE task_id = $1 AND released_at IS NULL LIMIT 1`, [step.taskId]
+    );
+    if (claimed[0]) {
+      throw Object.assign(new Error('task has an active claim'), {
+        code: 'TASK_HAS_ACTIVE_CLAIM', taskId: String(step.taskId), taskTitle: tRows[0].title,
+      });
+    }
+
+    if (step.verb === 'abandon') {
+      await client.query(
+        `UPDATE tasks SET status = 'abandoned',
+                          value_summary = COALESCE(NULLIF($2, ''), value_summary),
+                          updated_at = now()
+          WHERE id = $1`,
+        [step.taskId, `Abandoned: ${reason}`]
+      );
+      applied.push({ task_id: String(step.taskId), verb: 'abandon', result: 'abandoned' });
+    } else {
+      const { rows: dest } = await client.query(
+        `SELECT id, status FROM goals WHERE id = $1 FOR SHARE`, [step.toGoalId]
+      );
+      if (!dest[0]) {
+        throw Object.assign(new Error('move target not found'), { code: 'MOVE_TARGET_NOT_FOUND', toGoalId: String(step.toGoalId) });
+      }
+      if (dest[0].status !== 'open') {
+        throw Object.assign(new Error('move target is not open'), {
+          code: 'MOVE_TARGET_NOT_OPEN', toGoalId: String(step.toGoalId), targetStatus: dest[0].status,
+        });
+      }
+      await client.query(`UPDATE tasks SET goal_id = $2, updated_at = now() WHERE id = $1`, [step.taskId, step.toGoalId]);
+      applied.push({ task_id: String(step.taskId), verb: 'move', result: 'moved', to_goal_id: String(step.toGoalId) });
+    }
+  }
+  return applied;
+}
+
+// modules/lifecycle/db-versions.js — closeVersion, the plan loop. Same contract.
+async function legacyCloseLoop(client, { versionId, plan = [], reason, planningVersionId = null }) {
+  const applied = [];
+  for (const step of plan) {
+    const { rows: gRows } = await client.query(
+      `SELECT id, title, status FROM goals WHERE id = $1 AND version_id = $2 FOR UPDATE`,
+      [step.goalId, versionId]
+    );
+    if (!gRows[0]) { applied.push({ goal_id: String(step.goalId), verb: step.verb, result: 'skipped_not_on_version' }); continue; }
+    if (gRows[0].status !== 'open') {
+      applied.push({ goal_id: String(step.goalId), verb: step.verb, result: 'skipped_already_closed', status: gRows[0].status });
+      continue;
+    }
+
+    if (step.verb === 'abandon') {
+      const { rows: killed } = await client.query(
+        `UPDATE tasks SET status = 'abandoned',
+                          value_summary = COALESCE(NULLIF($2, ''), value_summary),
+                          updated_at = now()
+          WHERE goal_id = $1 AND ${nonTerminalSql('status')}
+            AND title NOT LIKE '\\_\\_smoke\\_\\_%' ESCAPE '\\'
+          RETURNING id`,
+        [step.goalId, `Abandoned: ${reason}`]
+      );
+      await client.query(`UPDATE goals SET status = 'archived', updated_at = now() WHERE id = $1`, [step.goalId]);
+      await cancelPendingMembershipRequests(client, step.goalId);
+      applied.push({ goal_id: String(step.goalId), verb: 'abandon', result: 'archived', tasks_abandoned: killed.length });
+    } else {
+      if (!planningVersionId) {
+        throw Object.assign(new Error('roll_forward with no planning version'), {
+          code: 'NO_PLANNING_VERSION', goalId: String(step.goalId),
+        });
+      }
+      const { rows: made } = await client.query(
+        `WITH next_order AS (
+           SELECT COALESCE(MAX(sort_order) + 1, 0) AS n FROM goals WHERE version_id = $2
+         )
+         INSERT INTO goals (version_id, title, subtitle, description, scope_modules,
+                            status, visibility, accepting_requests, created_by, sort_order, category_id, working_area)
+         SELECT $2, g.title, g.subtitle, g.description, g.scope_modules,
+                'open', g.visibility, g.accepting_requests, g.created_by, next_order.n, g.category_id, g.working_area
+           FROM goals g, next_order
+          WHERE g.id = $1
+         RETURNING id`,
+        [step.goalId, planningVersionId]
+      );
+      const successorId = made[0].id;
+
+      await client.query(
+        `INSERT INTO goal_members (goal_id, builder_id, membership_kind)
+         SELECT $2, builder_id, membership_kind FROM goal_members WHERE goal_id = $1
+         ON CONFLICT DO NOTHING`,
+        [step.goalId, successorId]
+      );
+
+      const { rows: moved } = await client.query(
+        `UPDATE tasks SET goal_id = $2, version_id = $3, updated_at = now()
+          WHERE goal_id = $1 AND ${nonTerminalSql('status')}
+            AND title NOT LIKE '\\_\\_smoke\\_\\_%' ESCAPE '\\'
+          RETURNING id`,
+        [step.goalId, successorId, planningVersionId]
+      );
+
+      await client.query(
+        `UPDATE goals SET succeeded_by_goal_id = $2, updated_at = now() WHERE id = $1`,
+        [step.goalId, successorId]
+      );
+      await client.query(`UPDATE goals SET status = 'archived', updated_at = now() WHERE id = $1`, [step.goalId]);
+      await cancelPendingMembershipRequests(client, step.goalId);
+
+      applied.push({
+        goal_id: String(step.goalId), verb: 'roll_forward', result: 'succeeded',
+        successor_goal_id: String(successorId), tasks_moved: moved.length,
+      });
+    }
+  }
+  return applied;
+}
+
+// modules/lifecycle/db-analytics.js — tallyPeerVotes, the whole function, with
+// the transaction primitive passed in (it was api.withTx).
+const PEER_VOTE_KARMA_LAG_DAYS = 7;
+async function legacyTallyPeerVotes(withTx) {
+  return withTx(async (client) => {
+    const { rows: matured } = await client.query(
+      `SELECT pv.id, t.shipped_by AS builder_id, pv.vote
+         FROM peer_votes pv
+         JOIN tasks t ON t.id = pv.target_task_id
+        WHERE pv.tallied_at IS NULL
+          AND pv.recorded_at <= now() - ($1::int * interval '1 day')
+          AND t.shipped_by IS NOT NULL
+        FOR UPDATE OF pv`,
+      [PEER_VOTE_KARMA_LAG_DAYS]
+    );
+    const netByBuilder = new Map();
+    const voteIds = [];
+    for (const r of matured) {
+      voteIds.push(r.id);
+      netByBuilder.set(r.builder_id, (netByBuilder.get(r.builder_id) || 0) + r.vote);
+    }
+    const ideaVoteIds = [];
+    const { rows: [{ has: hasIdeaVotes }] } = await client.query(
+      `SELECT to_regclass('ideas_votes') IS NOT NULL AS has`
+    );
+    if (hasIdeaVotes) {
+      const { rows: maturedIdeas } = await client.query(
+        `SELECT iv.id, i.captured_by AS builder_id, iv.vote
+           FROM ideas_votes iv
+           JOIN idea_inbox i ON i.id = iv.target_idea_id
+          WHERE iv.tallied_at IS NULL
+            AND iv.recorded_at <= now() - ($1::int * interval '1 day')
+            AND i.captured_by IS NOT NULL
+          FOR UPDATE OF iv`,
+        [PEER_VOTE_KARMA_LAG_DAYS]
+      );
+      for (const r of maturedIdeas) {
+        ideaVoteIds.push(r.id);
+        netByBuilder.set(r.builder_id, (netByBuilder.get(r.builder_id) || 0) + r.vote);
+      }
+    }
+    const karmaRows = [];
+    for (const [builderId, net] of netByBuilder) {
+      if (net === 0) continue;
+      await client.query(
+        `INSERT INTO karma_log (builder_id, delta, reason, granted_by)
+         VALUES ($1, $2, 'peer_vote_weekly', NULL)`,
+        [builderId, net]
+      );
+      karmaRows.push({ builder_id: builderId, delta: net });
+    }
+    if (voteIds.length) {
+      await client.query(
+        `UPDATE peer_votes SET tallied_at = now() WHERE id = ANY($1::bigint[])`,
+        [voteIds]
+      );
+    }
+    if (ideaVoteIds.length) {
+      await client.query(
+        `UPDATE ideas_votes SET tallied_at = now() WHERE id = ANY($1::bigint[])`,
+        [ideaVoteIds]
+      );
+    }
+    return {
+      ok: true,
+      votes_tallied: voteIds.length + ideaVoteIds.length,
+      idea_votes_tallied: ideaVoteIds.length,
+      builders_credited: karmaRows.length,
+      karma: karmaRows,
+      lag_days: PEER_VOTE_KARMA_LAG_DAYS,
+    };
+  });
+}
+
+module.exports = { legacyApplyRankSet, legacyArchiveLoop, legacyCloseLoop, legacyTallyPeerVotes };

package/tests/goal_archive_disposition.mjs

@@ -244,7 +244,7 @@ test('the whole disposition + archive runs inside ONE transaction', async () =>
   const pool = txPool((sql) => {
     const q = String(sql).replace(/\s+/g, ' ');
     if (/^SELECT .* FROM goals WHERE id = \$1 FOR UPDATE/.test(q.trim())) return { rows: [{ id: 7, status: 'open' }] };
-    if (/FROM tasks WHERE id = \$1 AND goal_id = \$2 FOR UPDATE/.test(q)) return { rows: [{ id: 1, title: 't1', status: 'ready' }] };
+    if (/FROM tasks WHERE id = ANY\(\$1::bigint\[\]\) AND goal_id = \$2 ORDER BY id FOR UPDATE/.test(q)) return { rows: [{ id: 1, title: 't1', status: 'ready' }] };
     if (/FROM claims WHERE task_id/.test(q)) return { rows: [] };
     if (/count\(\*\)::int AS n FROM tasks/.test(q)) return { rows: [{ n: 0 }] };
     if (/UPDATE goals SET status = 'archived'/.test(q)) return { rows: [{ id: 7, status: 'archived' }] };
@@ -270,7 +270,7 @@ test('the goal row is locked BEFORE the plan is applied', async () => {
   const pool = txPool((sql) => {
     const q = String(sql).replace(/\s+/g, ' ');
     if (/FROM goals WHERE id = \$1 FOR UPDATE/.test(q)) return { rows: [{ id: 7, status: 'open' }] };
-    if (/FROM tasks WHERE id = \$1 AND goal_id = \$2 FOR UPDATE/.test(q)) return { rows: [{ id: 1, title: 't', status: 'ready' }] };
+    if (/FROM tasks WHERE id = ANY\(\$1::bigint\[\]\) AND goal_id = \$2 ORDER BY id FOR UPDATE/.test(q)) return { rows: [{ id: 1, title: 't', status: 'ready' }] };
     if (/FROM claims/.test(q)) return { rows: [] };
     if (/count\(\*\)::int AS n/.test(q)) return { rows: [{ n: 0 }] };
     if (/UPDATE goals/.test(q)) return { rows: [{ id: 7, status: 'archived' }] };
@@ -287,8 +287,8 @@ test('an actively-claimed task stops the archive and rolls it back', async () =>
   const pool = txPool((sql) => {
     const q = String(sql).replace(/\s+/g, ' ');
     if (/FROM goals WHERE id = \$1 FOR UPDATE/.test(q)) return { rows: [{ id: 7, status: 'open' }] };
-    if (/FROM tasks WHERE id = \$1 AND goal_id = \$2 FOR UPDATE/.test(q)) return { rows: [{ id: 1, title: 'busy', status: 'active' }] };
-    if (/FROM claims WHERE task_id/.test(q)) return { rows: [{ id: 99 }] };   // someone is on it
+    if (/FROM tasks WHERE id = ANY\(\$1::bigint\[\]\) AND goal_id = \$2 ORDER BY id FOR UPDATE/.test(q)) return { rows: [{ id: 1, title: 'busy', status: 'active' }] };
+    if (/FROM claims WHERE task_id/.test(q)) return { rows: [{ task_id: 1 }] };   // someone is on it
     return { rows: [] };
   });
   await assert.rejects(
@@ -307,7 +307,7 @@ test('the invariant is re-checked against committed state, not against the plan'
   const pool = txPool((sql) => {
     const q = String(sql).replace(/\s+/g, ' ');
     if (/FROM goals WHERE id = \$1 FOR UPDATE/.test(q)) return { rows: [{ id: 7, status: 'open' }] };
-    if (/FROM tasks WHERE id = \$1 AND goal_id = \$2 FOR UPDATE/.test(q)) return { rows: [{ id: 1, title: 't', status: 'ready' }] };
+    if (/FROM tasks WHERE id = ANY\(\$1::bigint\[\]\) AND goal_id = \$2 ORDER BY id FOR UPDATE/.test(q)) return { rows: [{ id: 1, title: 't', status: 'ready' }] };
     if (/FROM claims/.test(q)) return { rows: [] };
     if (/count\(\*\)::int AS n FROM tasks/.test(q)) return { rows: [{ n: 3 }] };   // three snuck in
     return { rows: [] };

package/tests/government_routes.mjs

@@ -149,6 +149,9 @@ const stub = {
   }),
   createRank: async (a) => ({ rank_key: a.rankKey, label: a.label, description: a.description ?? null, is_system: false, seeded_rank: null, created_by: a.createdBy, created_at: 't' }),
   grantRankPermission: async () => true,
+  // task 1004929: the rank-set apply's one-transaction write. The apply tests
+  // swap in the REAL function over a fake SQL store (withRealRankDb below).
+  applyRankSet: async () => new Map(),
   revokeRankPermission: async () => true,
   resetRankGrants: async ({ permissionKeys }) => permissionKeys.length,
   // task 1004481: `deleteAnswer` scripts what the locked delete found.
@@ -265,35 +268,155 @@ test('GET /government/assignments returns builder↔role rows', async () => {
 
 // --- recommended rank sets (task 1004400) -------------------------------------
 
+// task 1004929: the apply is now ONE transaction written by db.applyRankSet. These
+// tests run the REAL route into the REAL db functions, over a small fake of the
+// two tables that understands exactly the statements the old per-row loop and
+// the new batched write send. That is what lets the parity test below run the
+// old loop (tests/fixtures/per-row-loops-legacy.cjs, verbatim) and the new route
+// over the same starting tables and compare the replies AND what was written.
+//
+// `existing` are ranks already there; `race` are ranks another caller creates
+// between this call's read and its insert (invisible to the read, a conflict on
+// the insert) — the case the old loop caught as a 23505.
+function rankStore({ existing = [], race = [], failOnGrant = false } = {}) {
+  let st = { ranks: existing.map((k) => ({ rank_key: k, label: 'Theirs', description: null, created_by: 7 })), grants: [] };
+  let snap = null;
+  const raced = new Set(race);
+  const queries = [];
+  const has = (k) => st.ranks.some((r) => r.rank_key === k);
+  const conflicts = (k) => {
+    if (raced.has(k)) { raced.delete(k); st.ranks.push({ rank_key: k, label: 'Raced', description: null, created_by: 8 }); }
+    return has(k);
+  };
+  const addRank = (k, label, description, createdBy) => {
+    const row = { rank_key: k, label, description: description ?? null, created_by: Number(createdBy) };
+    st.ranks.push(row);
+    return { ...row, is_system: false, seeded_rank: null, created_at: 't' };
+  };
+  const addGrant = (rk, pk) => {
+    if (failOnGrant) throw new Error('grant insert failed');
+    if (st.grants.some((g) => g.rank_key === rk && g.permission_key === pk)) return false;
+    st.grants.push({ rank_key: rk, permission_key: pk });
+    return true;
+  };
+  async function query(sql, p = []) {
+    const s = String(sql).replace(/\s+/g, ' ').trim();
+    queries.push(s);
+    if (s === 'BEGIN') { snap = JSON.parse(JSON.stringify(st)); return { rows: [] }; }
+    if (s === 'COMMIT') { snap = null; return { rows: [] }; }
+    if (s === 'ROLLBACK') { if (snap) st = snap; snap = null; return { rows: [] }; }
+    if (/^SELECT rank_key, label, description, is_system, seeded_rank, created_by, created_at FROM government_ranks WHERE rank_key = \$1$/.test(s)) {
+      return { rows: st.ranks.filter((r) => r.rank_key === p[0]).map((r) => ({ ...r, is_system: false, seeded_rank: null })) };
+    }
+    if (/^INSERT INTO government_ranks \(.*\) VALUES \(\$1, \$2, \$3, false, NULL, \$4\) RETURNING/.test(s)) {
+      if (conflicts(p[0])) throw Object.assign(new Error('duplicate key'), { code: '23505' });
+      return { rows: [addRank(p[0], p[1], p[2], p[3])] };
+    }
+    if (/^INSERT INTO government_rank_permissions \(rank_key, permission_key\) VALUES \(\$1, \$2\) ON CONFLICT/.test(s)) {
+      return { rows: [], rowCount: addGrant(p[0], p[1]) ? 1 : 0 };
+    }
+    if (/^SELECT rank_key FROM government_ranks WHERE rank_key = ANY\(\$1::text\[\]\)$/.test(s)) {
+      return { rows: st.ranks.filter((r) => p[0].includes(r.rank_key)).map((r) => ({ rank_key: r.rank_key })) };
+    }
+    if (/^INSERT INTO government_ranks .* FROM unnest\(\$1::text\[\], \$2::text\[\], \$3::text\[\]\) WITH ORDINALITY .* ORDER BY r\.ord ON CONFLICT DO NOTHING RETURNING rank_key$/.test(s)) {
+      const rows = [];
+      p[0].forEach((k, i) => { if (!conflicts(k)) { addRank(k, p[1][i], p[2][i], p[3]); rows.push({ rank_key: k }); } });
+      return { rows };
+    }
+    if (/^INSERT INTO government_rank_permissions .* FROM unnest\(\$1::text\[\], \$2::text\[\]\) WITH ORDINALITY .* ORDER BY g\.ord ON CONFLICT \(rank_key, permission_key\) DO NOTHING RETURNING rank_key, permission_key$/.test(s)) {
+      const rows = [];
+      p[0].forEach((rk, i) => { if (addGrant(rk, p[1][i])) rows.push({ rank_key: rk, permission_key: p[1][i] }); });
+      return { rows };
+    }
+    throw new Error(`rank store: unhandled statement: ${s.slice(0, 120)}`);
+  }
+  return { query, client: { query, release() {} }, queries, get state() { return JSON.parse(JSON.stringify(st)); } };
+}
+
+// Point the REAL government db functions at a rankStore for the length of `fn`.
+const pgPool = require(path.join(ROOT, 'src', 'bongos', 'pool.js')).pool;
+const RANK_DB_FNS = ['getRankByKey', 'createRank', 'grantRankPermission', 'applyRankSet'];
+async function withRealRankDb(store, fn) {
+  const saved = Object.fromEntries(RANK_DB_FNS.map((k) => [k, stub[k]]));
+  const own = { query: Object.prototype.hasOwnProperty.call(pgPool, 'query'), connect: Object.prototype.hasOwnProperty.call(pgPool, 'connect') };
+  const realQuery = pgPool.query;
+  const realConnect = pgPool.connect;
+  for (const k of RANK_DB_FNS) stub[k] = REAL[k];
+  pgPool.query = store.query;
+  pgPool.connect = async () => store.client;
+  try { return await fn(); } finally {
+    Object.assign(stub, saved);
+    if (own.query) pgPool.query = realQuery; else delete pgPool.query;
+    if (own.connect) pgPool.connect = realConnect; else delete pgPool.connect;
+  }
+}
+
 test('POST /government/rank-sets/apply creates the missing ranks with their grants and leaves existing ones alone', async () => {
-  const realGet = stub.getRankByKey;
   // 'design-lead' already exists: it must be skipped, never re-granted.
-  stub.getRankByKey = async (k) => (k === 'design-lead' ? { rank_key: k, label: 'Mine', is_system: false, seeded_rank: null } : null);
-  try {
-    const r = await call('POST', '/government/rank-sets/apply', { type: 'game', headcount: 20 });
-    assert.equal(r.status, 200);
-    assert.deepEqual(r.json.skipped, [{ rank_key: 'design-lead', label: 'Design lead' }], 'a kept rank is named by its label, not its key (task 1004478)');
-    assert.deepEqual(r.json.created.map((c) => c.rank_key), ['playtester']);
-    const creates = calls.filter(([k]) => k === 'createRank');
-    assert.equal(creates.length, 1);
-    assert.equal(creates[0][1].createdBy, 42, 'created_by is the session builder');
-    const grants = calls.filter(([k]) => k === 'grantRankPermission').map(([, a]) => a);
-    assert.ok(grants.length > 0 && grants.every((g) => g.rankKey === 'playtester'), 'an existing rank is never re-granted');
-    assert.ok(grants.every((g) => catalog.isGrantableTo(g.permissionKey, { is_system: false, seeded_rank: null })));
-  } finally { stub.getRankByKey = realGet; }
+  const store = rankStore({ existing: ['design-lead'] });
+  const r = await withRealRankDb(store, () => call('POST', '/government/rank-sets/apply', { type: 'game', headcount: 20 }));
+  assert.equal(r.status, 200);
+  assert.deepEqual(r.json.skipped, [{ rank_key: 'design-lead', label: 'Design lead' }], 'a kept rank is named by its label, not its key (task 1004478)');
+  assert.deepEqual(r.json.created.map((c) => c.rank_key), ['playtester']);
+  const { ranks, grants } = store.state;
+  assert.deepEqual(ranks.map((x) => [x.rank_key, x.label, x.created_by]), [['design-lead', 'Theirs', 7], ['playtester', 'Playtester', 42]],
+    'the kept rank is untouched and created_by is the session builder');
+  assert.ok(grants.length > 0 && grants.every((g) => g.rank_key === 'playtester'), 'an existing rank is never re-granted');
+  assert.ok(grants.every((g) => catalog.isGrantableTo(g.permission_key, { is_system: false, seeded_rank: null })));
+  assert.deepEqual(r.json.created[0].permissions, grants.map((g) => g.permission_key), 'the reply names exactly what was granted');
+  assert.equal(store.queries.filter((q) => q === 'BEGIN').length, 1, 'one transaction');
+  assert.equal(store.queries.filter((q) => /^INSERT/.test(q)).length, 2, 'one rank insert and one grant insert, however many grants');
 });
 
 test('POST /government/rank-sets/apply needs a headcount and does nothing at founding size', async () => {
   const bad = await call('POST', '/government/rank-sets/apply', { type: 'game' });
   assert.equal(bad.status, 400);
-  const realGet = stub.getRankByKey;
-  stub.getRankByKey = async () => null;
-  try {
-    const solo = await call('POST', '/government/rank-sets/apply', { type: 'game', headcount: 1 });
-    assert.equal(solo.status, 200);
-    assert.deepEqual(solo.json.created, []);
-    assert.equal(calls.filter(([k]) => k === 'createRank').length, 0);
-  } finally { stub.getRankByKey = realGet; }
+  const store = rankStore();
+  const solo = await withRealRankDb(store, () => call('POST', '/government/rank-sets/apply', { type: 'game', headcount: 1 }));
+  assert.equal(solo.status, 200);
+  assert.deepEqual(solo.json.created, []);
+  assert.deepEqual(store.queries, [], 'an empty set touches nothing');
+});
+
+test('POST /government/rank-sets/apply: a failure part-way writes NOTHING (one transaction)', async () => {
+  const store = rankStore({ failOnGrant: true });
+  const r = await withRealRankDb(store, () => call('POST', '/government/rank-sets/apply', { type: 'business', headcount: 200 }));
+  assert.equal(r.status, 500);
+  assert.deepEqual(r.json.error.details, { created: [], skipped: [] }, 'nothing was written, so nothing is reported as added');
+  assert.deepEqual(store.state, { ranks: [], grants: [] }, 'the ranks inserted before the failure are rolled back');
+  assert.ok(store.queries.includes('ROLLBACK'));
+});
+
+test('POST /government/rank-sets/apply: the batched write gives the SAME reply and tables as the old per-row loop', async () => {
+  const legacy = require(path.join(ROOT, 'tests', 'fixtures', 'per-row-loops-legacy.cjs'));
+  const recommendations = require(path.join(ROOT, 'modules', 'government', 'recommendations.js'));
+  const realDb = { getRankByKey: REAL.getRankByKey, createRank: REAL.createRank, grantRankPermission: REAL.grantRankPermission };
+  let compared = 0;
+  for (const { key: type } of recommendations.PROJECT_TYPES) {
+    for (const headcount of [1, 5, 20, 80, 200]) {
+      const keys = recommendations.recommendedRankSet(type, headcount).ranks.map((x) => x.rank_key);
+      const scenarios = {
+        'nothing there yet': {},
+        'the first rank exists': { existing: keys.slice(0, 1) },
+        'every rank exists': { existing: keys },
+        'the last rank is created by someone else mid-call': { race: keys.slice(-1) },
+      };
+      for (const [name, opts] of Object.entries(scenarios)) {
+        const label = `${type} × ${headcount}: ${name}`;
+        const oldStore = rankStore(opts);
+        const old = await withRealRankDb(oldStore, () => legacy.legacyApplyRankSet({
+          db: realDb, catalog, rankSet: recommendations.recommendedRankSet(type, headcount), builderId: 42,
+        }));
+        const newStore = rankStore(opts);
+        const neu = await withRealRankDb(newStore, () => call('POST', '/government/rank-sets/apply', { type, headcount }));
+        assert.equal(neu.status, 200, label);
+        assert.deepEqual({ created: neu.json.created, skipped: neu.json.skipped }, old, `${label}: the same reply`);
+        assert.deepEqual(newStore.state, oldStore.state, `${label}: the same ranks and grants written, in the same order`);
+        compared += 1;
+      }
+    }
+  }
+  assert.ok(compared >= 20, `compared ${compared} cases`);
 });
 
 // --- create role -------------------------------------------------------------

package/tests/grader.mjs

@@ -789,6 +789,37 @@ test('buildContextBundle reads changed files once, skips binaries/missing, respe
   assert.equal(bundle.total_chars, files['src/a.js'].length + files['docs/b.md'].length);
 });
 
+// task 1004932 — the bundle rides in EVERY worker prompt, so its total is capped at
+// 60k chars (was 120k), and it is filled most-changed first so the cap drops the
+// lightly touched files, never the heart of the change.
+const CAP_FILE = 15_000; // under the 16k per-file cap, so nothing truncates
+function capFiles(names) { return Object.fromEntries(names.map((n) => [n, `// ${n}\n` + 'x'.repeat(CAP_FILE)])); }
+function diffAdding(counts) {
+  return Object.entries(counts).map(([f, n]) =>
+    `diff --git a/${f} b/${f}\n--- a/${f}\n+++ b/${f}\n@@ -1 +1,${n} @@\n` +
+    Array.from({ length: n }, (_, i) => `+const line_${i}_of_${f.replace(/\W/g, '_')} = ${i};`).join('\n')).join('\n');
+}
+
+test('buildContextBundle caps the shared bundle at 60k chars (task 1004932)', () => {
+  const names = ['a.js', 'b.js', 'c.js', 'd.js', 'e.js'];
+  const files = capFiles(names);
+  const bundle = grader.buildContextBundle({ changedFiles: names, cwd: '/r', fsImpl: fakeFsFor(files) });
+  assert.ok(bundle.total_chars <= 60_000, `bundle is ${bundle.total_chars} chars — over the 60k cap`);
+  assert.ok(bundle.total_chars > 45_000, 'the cap is not lower than 60k: three ~15k files still fit');
+  assert.deepEqual(bundle.files.map((f) => f.file), ['a.js', 'b.js', 'c.js'], 'no diff: the caller order is kept');
+  assert.deepEqual(bundle.skipped, ['d.js', 'e.js'], 'what does not fit is named in skipped, never silent');
+});
+
+test('buildContextBundle fills most-changed first, so the cap drops the lightly touched files (task 1004932)', () => {
+  const names = ['docs/index.md', 'docs/map.md', 'tests/x.mjs', 'README.md', 'src/heart.js'];
+  const files = capFiles(names);
+  const diff = diffAdding({ 'docs/index.md': 1, 'docs/map.md': 1, 'tests/x.mjs': 20, 'README.md': 2, 'src/heart.js': 60 });
+  const bundle = grader.buildContextBundle({ changedFiles: names, cwd: '/r', diff, fsImpl: fakeFsFor(files) });
+  assert.deepEqual(bundle.files.map((f) => f.file), ['src/heart.js', 'tests/x.mjs', 'README.md'],
+    'the file the diff is mostly about comes first, even when it is listed last');
+  assert.deepEqual(bundle.skipped, ['docs/index.md', 'docs/map.md'], 'ties keep their listed order, and one-line touches are what falls off');
+});
+
 test('buildContextBundle truncates oversized files and marks them', () => {
   const big = 'x'.repeat(20_000);
   const bundle = grader.buildContextBundle({

package/tests/hall_city.mjs

@@ -289,6 +289,14 @@ test('the city sits in the hall chrome, behind the shell\'s full-screen switch',
   // gov-feeds.js, its one reader per page (shared with the shell's tally), load before it
   // task 1004702: the card answers its first ask in place, so the deck's card and sender (and the desk rows under them) load before the page
   assert.deepEqual(scripts, ['dom-utils', 'shell-trail', 'craft-mode', 'shell', 'palette', 'gov-living', 'gov-feeds', 'city-draw', 'hall-kit', 'street-draw', 'street-card', 'street-inside', 'street-desk', 'street-deck', 'city-decide', 'city-switchboard', 'city'], 'the shell first, as on every hall page');
+  // task 1004925: every script but dom-utils.js is deferred, so none holds up the
+  // parser; defer runs them in document order, which is why the order above still
+  // holds. dom-utils.js stays synchronous: the one-escaper guard
+  // (scripts/bongos/escape-helper-guard.js) requires window.OTB before anything runs.
+  const tags = [...html.matchAll(/<script\b[^>]*>/g)].map((m) => m[0]);
+  assert.equal(tags.length, scripts.length, 'no inline script runs ahead of the deferred ones');
+  assert.doesNotMatch(tags[0], /\b(defer|async)\b/, 'dom-utils.js loads synchronously, first');
+  for (const tag of tags.slice(1)) assert.match(tag, /\sdefer(?=[\s>])/, `${tag} is deferred`);
   const css = read('city.css').replace(/\/\*[\s\S]*?\*\//g, '');
   assert.match(css, /\.city-main \{ position: fixed; top: var\(--topbar-h, 56px\); left: var\(--sidebar-w-rail, 64px\);[^}]*contain: layout paint;/);
   assert.match(css, /html\[data-fullscreen="on"\] \.city-main \{ top: 0; left: 0; \}/);

package/tests/hook_shell_tools.mjs

@@ -57,13 +57,19 @@ function entries() {
   return out;
 }
 
+// A hook may ALSO have an entry for the file-writing tools only (secret-gate does,
+// since task 1004931 moved its shell half into the shell-hooks.js dispatcher). What
+// must never exist is an entry naming SOME shell tools but not all — the bug above.
 test('every shell-reading hook is registered, and its matcher names every shell tool', () => {
   const all = entries();
   for (const hook of SHELL_HOOKS) {
     const found = all.filter((e) => e.command.includes(hook));
     assert.ok(found.length > 0, `${hook} is not registered in settings.json at all`);
+    let coversShell = false;
     for (const e of found) {
       const named = e.matcher.split('|').map((s) => s.trim());
+      const shellNamed = SHELL_TOOLS.filter((tool) => named.includes(tool));
+      if (shellNamed.length === 0) continue; // a file-writing-tools entry
       for (const tool of SHELL_TOOLS) {
         assert.ok(
           named.includes(tool),
@@ -71,7 +77,9 @@ test('every shell-reading hook is registered, and its matcher names every shell
             'that shell tool reaches the hook not at all, silently',
         );
       }
+      coversShell = true;
     }
+    assert.ok(coversShell, `${hook} has no entry whose matcher names the shell tools`);
   }
 });
 

package/tests/hooks_drain.mjs

@@ -20,7 +20,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const HOOKS = ['recall-hints', 'rank-change-greeting', 'conductor', 'pull-memory', 'edit-hints', 'stuck-detector'].map((n) => path.join(ROOT, '.claude', 'hooks', `${n}.js`));
+const HOOKS = ['recall-hints', 'module-skills', 'rank-change-greeting', 'conductor', 'pull-memory', 'edit-hints', 'stuck-detector'].map((n) => path.join(ROOT, '.claude', 'hooks', `${n}.js`));
 // The SessionStart/SessionEnd scripts that did network work and then process.exit()ed — 59 recorded
 // UV_HANDLE_CLOSING aborts in three days (task 1003548). Same contract: exit 0 on their own, no abort.
 // session-digest requires `pg` at load (via db-kernel), so it can only be exercised where node_modules

package/tests/host_topology_skips.mjs

@@ -40,6 +40,7 @@ const ALLOWED = {
   first_run_engine_check: '.claude/hooks/session-start.js (package-excluded)',
   hook_core_resolve: '.claude/hooks/_core-resolve.js (package-excluded)',
   'lifecycle-card': '.claude/hooks/lifecycle-card.js (package-excluded)',
+  module_skills_hook: '.claude/hooks/module-skills.js (package-excluded)',
   pre_compact: '.claude/hooks/pre-compact.js (package-excluded)',
   preview_server: 'src/preview-server.js (game module, not in the core)',
   recall_hints: '.claude/hooks/recall-hints.js (package-excluded)',
@@ -47,6 +48,7 @@ const ALLOWED = {
   run_routine_two_root: '.claude/hooks/_core-resolve.js (package-excluded)',
   'session-cards': '.claude/hooks/session-cards.js (package-excluded)',
   session_start_freshness: '.claude/hooks/session-start.js (package-excluded)',
+  shell_hooks: '.claude/hooks/shell-hooks.js (package-excluded)',
   stop_refcheck: '.claude/hooks/stop-refcheck.js (package-excluded; the task-1002234 precedent)',
   stuck_detector: '.claude/hooks/stuck-strikes.js (package-excluded)',
   worktree_guard: '.claude/hooks/worktree-guard.js (package-excluded)',

package/tests/howto_moments.mjs

@@ -119,6 +119,23 @@ test('ordinary prompts are not guide requests', () => {
   }
 });
 
+// Task 1004744: a pasted handoff quoting "skip the tutorial" made the Conductor tell
+// the AI to run `npx bongos howto skip` unasked. Only a prompt that IS the request counts.
+test('a long or multi-line prompt that merely quotes a request is not one', () => {
+  const handoff = [
+    'Continue the onboarding chain from task 1004636.',
+    'Context: the owner said "skip the tutorial" is a valid phrase the guide must accept.',
+    'Next: wire the hall card.',
+  ].join('\n');
+  assert.equal(m.guideRequest(handoff), null, 'multi-line handoff');
+  const oneLong = 'Reviewing the copy for the how-to card: the button reads "skip the tutorial", which matches what the guide accepts, so leave it.';
+  assert.ok(oneLong.length > 100);
+  assert.equal(m.guideRequest(oneLong), null, 'one long line');
+  assert.equal(m.guideRequest('  skip the tutorial  \n'), 'skip', 'surrounding whitespace is still the request');
+  const a = howtoAdvisory({ howto: { read: [] }, prompt: handoff, firstPrompt: false, activeClaims: [] });
+  assert.ok(!a || !String(a.id).startsWith('howto-request:'), 'the Conductor gives no howto command for the handoff');
+});
+
 test('each request tells the AI the command that changes the stored state', () => {
   for (const kind of ['show', 'next', 'skip', 'reset']) assert.match(m.renderRequestForAi(kind), new RegExp(`npx bongos howto ${kind}`));
 });

package/tests/module_loader.mjs

@@ -278,7 +278,7 @@ test('the live tree discovers the extracted modules cleanly (BV1.R43/R48/R47/R49
   // That is precisely how the agents regression reached an open PR (task 1002485).
   loader._reset();
   const snap = loader.loaderSnapshot();
-  assert.deepEqual(snap.loaded, ['agents', 'autonomy', 'builder-settings', 'copy-desk', 'design-styles', 'discord', 'economy', 'government', 'grading', 'hall-ui', 'ideas', 'lifecycle', 'memory', 'npm-release', 'onboarding', 'page-notes', 'pixel-art', 'platform-identity', 'provisioning', 'public-landing', 'raise', 'render-deploy', 'security', 'sessions', 'specialities', 'status-ui', 'ui-design']);
+  assert.deepEqual(snap.loaded, ['agents', 'ai-studio', 'autonomy', 'builder-settings', 'copy-desk', 'design-styles', 'discord', 'economy', 'government', 'grading', 'hall-ui', 'ideas', 'lifecycle', 'memory', 'npm-release', 'onboarding', 'page-notes', 'pixel-art', 'platform-identity', 'provisioning', 'public-landing', 'raise', 'render-deploy', 'security', 'sessions', 'specialities', 'status-ui', 'ui-design']);
   assert.deepEqual(snap.errors, []);
   assert.deepEqual(snap.skipped, []);
   loader._reset();