@bongos/core 1.23.21 → 1.23.22

package/scripts/bongos/strand-watch.js

@@ -31,7 +31,8 @@
 //
 // Usage:
 //   node scripts/bongos/strand-watch.js                 # human-readable report
-//   node scripts/bongos/strand-watch.js --line          # ONE line, or nothing; always exit 0
+//   node scripts/bongos/strand-watch.js --line          # ONE line, or nothing; always exit 0 (cached; see linePlan)
+//   node scripts/bongos/strand-watch.js --refresh-line  # refresh that cache; prints nothing (spawned detached by --line)
 //   node scripts/bongos/strand-watch.js --json          # machine shape
 //   node scripts/bongos/strand-watch.js --hours N       # override the `completed` threshold
 //
@@ -273,6 +274,77 @@ function report(r) {
   console.log('');
 }
 
+// ---- the SessionStart line, kept off the critical path (task 1004928) --------
+//
+// THE MEASUREMENT. The credit-burn audit timed this hook at 8.2 s — the slowest SessionStart
+// producer, and so the floor for every session start. The shared cache it used (task 1003689)
+// lived 60 s, which only helps sessions opened together; the next session an hour later paid
+// the whole ledger read again, up to 8 s per call (and the held-tweak pass can add another).
+//
+// THE FIX. A strand is measured in hours (one hour for `confirmed`, twelve for `completed`), so
+// an answer a few minutes old is as true as a fresh one. So: keep the answer LINE_FRESH_MS and
+// print it at once; past that, up to LINE_STALE_MAX_MS, print it at once LABELLED WITH ITS AGE
+// and refresh the cache in a detached child for the next session; with nothing usable, read the
+// ledger but give up after LINE_DEADLINE_MS. An undetermined read is never cached — a stored
+// silence would pass for a clean board for the whole fresh window.
+const LINE_CACHE_KEY = 'strand-watch-line';
+const LINE_FRESH_MS = 15 * 60 * 1000;
+const LINE_STALE_MAX_MS = 2 * 60 * 60 * 1000;
+const LINE_DEADLINE_MS = 4000;
+
+// PURE — what to do with the cached record: 'fresh' (print it), 'stale' (print it with its age
+// and refresh in the background) or 'miss' (read the ledger now, time-boxed). A record from the
+// future means the clock moved, and is treated as a miss rather than trusted.
+function linePlan(record, nowMs, { freshMs = LINE_FRESH_MS, staleMaxMs = LINE_STALE_MAX_MS } = {}) {
+  if (!record || typeof record.at !== 'number' || !Number.isFinite(nowMs)) return 'miss';
+  const age = nowMs - record.at;
+  if (age < 0) return 'miss';
+  if (age < freshMs) return 'fresh';
+  if (age < staleMaxMs) return 'stale';
+  return 'miss';
+}
+
+// PURE — the line as printed from a stale cache: the same words, plus how old they are, so a
+// reader can weigh them. A clean (null) answer stays silent: there is nothing to label.
+function labelStale(text, ageMs) {
+  if (!text) return null;
+  return `${text} (Checked ${humanAge(ageMs)} ago; refreshing for the next session.)`;
+}
+
+// The ledger read for the line, bounded as a WHOLE (check() bounds each call, not the sum).
+// Throws on an undetermined read so probe-cache stores nothing.
+async function produceLine(opts, deadlineMs) {
+  let timer;
+  const deadline = new Promise((_, rej) => { timer = setTimeout(() => rej(new Error('deadline')), deadlineMs); });
+  try {
+    const r = await Promise.race([check({ ...opts, timeoutMs: Math.min(deadlineMs, DEFAULT_TIMEOUT_MS) }), deadline]);
+    if (!r || r.undetermined) throw new Error('undetermined');
+    return line(r);
+  } finally { clearTimeout(timer); }
+}
+
+function readLineRecord() {
+  try {
+    const { cachePath } = require('./probe-cache.js');
+    return JSON.parse(require('node:fs').readFileSync(cachePath(LINE_CACHE_KEY), 'utf8'));
+  } catch { return null; }
+}
+
+// Detached + unref'd + hidden, so the session start never waits on it (windowsHide: a detached
+// child on Windows otherwise flashes a console window). --hours is passed through so the
+// refreshed answer uses the same threshold.
+function spawnRefresh() {
+  try {
+    const args = [__filename, '--refresh-line'];
+    const hours = arg('--hours');
+    if (hours) args.push('--hours', String(hours));
+    const child = require('node:child_process').spawn(process.execPath, args, {
+      detached: true, stdio: 'ignore', windowsHide: true, cwd: process.cwd(),
+    });
+    child.unref();
+  } catch { /* the next session reads the ledger itself */ }
+}
+
 async function main() {
   const hours = Number(arg('--hours'));
   const opts = Number.isFinite(hours) && hours > 0 ? { completedStaleMs: hours * 3600000 } : {};
@@ -285,16 +357,39 @@ async function main() {
   // deploy-divergence's identical comment).
   if (hasFlag('--line')) {
     try {
-      // SHARED ACROSS CONCURRENT SESSION STARTS (task 1003689). Four sessions opened
-      // within three seconds — one worktree per claim, the normal pattern here — used
-      // to make this same call four times and ALL of them timed out, which produces no
-      // line at all. Silence from a truth-teller is indistinguishable from 'nothing to
-      // report', so the brief was lost without a symptom. The first session to ask now
-      // answers for the rest.
+      // SHARED ACROSS SESSION STARTS (task 1003689, widened by task 1004928). Four sessions
+      // opened within three seconds — one worktree per claim, the normal pattern here — used
+      // to make this same call four times and ALL of them timed out, which produces no line
+      // at all. The first session to ask answers for the rest; see linePlan for how long.
+      const rec = readLineRecord();
+      const plan = linePlan(rec, Date.now());
+      if (plan === 'fresh') {
+        if (rec.value) console.log(rec.value);
+      } else if (plan === 'stale') {
+        const one = labelStale(rec.value, Date.now() - rec.at);
+        if (one) console.log(one);
+        spawnRefresh();
+      } else {
+        const { cached } = require('./probe-cache.js');
+        const { value: one, from } = await cached(LINE_CACHE_KEY, () => produceLine(opts, LINE_DEADLINE_MS), { ttlMs: LINE_FRESH_MS });
+        // A sibling holds the lock and the cache handed back its last answer, however old:
+        // say how old, so a long-expired line is never passed off as current.
+        const shown = from === 'stale-while-locked' && rec && typeof rec.at === 'number'
+          ? labelStale(one, Date.now() - rec.at) : one;
+        if (shown) console.log(shown);
+      }
+    } catch { /* no session, offline, unreadable, past the deadline — all silence */ }
+    process.exitCode = 0;
+    return;
+  }
+
+  // --refresh-line: the detached child spawnRefresh starts. ttlMs 0 forces a fresh read; a
+  // sibling already refreshing holds the lock, and then this child simply stops. Prints nothing.
+  if (hasFlag('--refresh-line')) {
+    try {
       const { cached } = require('./probe-cache.js');
-      const { value: one } = await cached('strand-watch-line', async () => line(await check(opts)));
-      if (one) console.log(one);
-    } catch { /* no session, offline, unreadable — all silence */ }
+      await cached(LINE_CACHE_KEY, () => produceLine(opts, DEFAULT_TIMEOUT_MS * 2), { ttlMs: 0 });
+    } catch { /* the next session reads the ledger itself */ }
     process.exitCode = 0;
     return;
   }
@@ -311,5 +406,6 @@ if (require.main === module) {
 
 module.exports = {
   check, line, report, classifyStrand, rankStrands, humanAge,
+  linePlan, labelStale, produceLine, LINE_FRESH_MS, LINE_STALE_MAX_MS, LINE_DEADLINE_MS,
   CONFIRMED_STALE_MS, COMPLETED_STALE_MS, STRAND_REASON_PREFIX, WATCHED, PAGE_LIMIT,
 };

package/src/bongos/module-scope-map.js

@@ -182,6 +182,10 @@ const MODULE_GLOBS = {
   'page-notes': [
     'modules/page-notes/',
   ],
+  // AI generation for artists (task 1004916, ADR 0392): keys, prepaid balance, generate.
+  'ai-studio': [
+    'modules/ai-studio/',
+  ],
   // The /raise investor page (task 1004847, ADR 0384): hub-only.
   raise: [
     'modules/raise/',

package/src/module-api.js

@@ -81,7 +81,7 @@ const { sleep } = require('./sleep');
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.23.21'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.23.22'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/src/platform-server.js

@@ -142,6 +142,24 @@ function stampAssets(html) {
     assetStamp(url) ? `${attr}="${url}?v=${assetStamp(url)}"` : m);
 }
 
+// The cache lifetime a landing asset is served with (task 1004925). A URL whose
+// ?v= is the file's CURRENT stamp can never name different bytes — a new file
+// means a new stamp, so a new URL — so the browser may keep it for a year instead
+// of re-fetching it after Cloudflare's four-hour default runs out. Only an exact
+// match earns that, the hall's rule (serve-internal.js, task 1004855): a stale or
+// made-up ?v=, or a bare URL, keeps whatever lifetime it had. Images and fonts
+// that no page stamps (a css url(), a script-built src) get one day, up from four
+// hours; everything else is left to the default. Returns null for "no header".
+const MEDIA_ASSET = /\.(?:png|jpe?g|webp|avif|gif|svg|ico|woff2?|ttf|otf)$/i;
+function landingAssetCache(urlPath, v) {
+  if (typeof urlPath !== 'string') return null;
+  if (typeof v === 'string' && /^[0-9a-f]{8}$/.test(v) && assetStamp(urlPath) === v) {
+    return 'public, max-age=31536000, immutable';
+  }
+  if (MEDIA_ASSET.test(urlPath)) return 'public, max-age=86400';
+  return null;
+}
+
 const _landingPages = new Map(); // memoized per file; '' if absent (instance ships no landing)
 function landingPage(file) {
   if (!_landingPages.has(file)) {
@@ -364,7 +382,15 @@ function buildPlatformApp() {
   });
   // Assets fall through to the 404 tail when no module claims the apex root — the
   // handler is not mounted at all rather than pointed at a missing directory.
-  const landingAssets = landingDir() && express.static(landingDir(), { index: false, fallthrough: true });
+  const landingAssets = landingDir() && express.static(landingDir(), {
+    index: false,
+    fallthrough: true,
+    setHeaders: (res) => {
+      const req = res.req || {};
+      const cache = landingAssetCache(req.path, req.query && req.query.v);
+      if (cache) res.setHeader('Cache-Control', cache);
+    },
+  });
   if (landingAssets) {
     app.use((req, res, next) => {
       if (!isApexHost(req)) return next();

package/tests/batched_writes_parity.mjs

@@ -0,0 +1,340 @@
+// tests/batched_writes_parity.mjs — the batched goal archive, version close and
+// weekly karma tally give the SAME results as the one-query-per-row loops they
+// replaced (task 1004929).
+//
+// Each case runs the old loop (tests/fixtures/per-row-loops-legacy.cjs, a
+// verbatim copy) and the new code over the SAME seeded fake database, then
+// compares what each returned or threw AND what each left in the tables. The
+// fake is a small interpreter for exactly the statements both versions send —
+// old per-row reads and new batched reads answer from one store — and it hands
+// bigint ids back as STRINGS, as node-pg does, so a plan that carries numbers is
+// matched back to rows the way production matches them. BEGIN snapshots the
+// store and ROLLBACK restores it, so a thrown run is compared on what survived.
+//
+// The rank-set apply parity lives in tests/government_routes.mjs, where the real
+// router is already standing.
+//
+// Run:  node --test tests/batched_writes_parity.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const { archiveGoalWithDispositions, closeVersion } = require('../modules/lifecycle/db.js');
+const { tallyPeerVotes } = require('../modules/lifecycle/db-analytics.js');
+const { idKey } = require('../modules/lifecycle/db-shared.js');
+const pgPool = require('../src/bongos/pool').pool;
+const legacy = require('./fixtures/per-row-loops-legacy.cjs');
+
+const TERMINAL = new Set(['shipped', 'abandoned']);
+const same = (a, b) => String(a) === String(b);
+const inIds = (arr, v) => arr.some((x) => same(idKey(x), idKey(v)));
+const clone = (v) => JSON.parse(JSON.stringify(v));
+
+// ---- the fake database -------------------------------------------------------
+
+function fakeDb(seed) {
+  let st = clone(seed);
+  let snap = null;
+  const queries = [];
+  const task = (id) => st.tasks.find((t) => same(t.id, idKey(id)));
+  const goal = (id) => st.goals.find((g) => same(g.id, idKey(id)));
+  const out = (row) => (row ? { ...row, id: String(row.id) } : row);
+  const openWork = (t) => !TERMINAL.has(t.status) && !t.title.startsWith('__smoke__');
+
+  async function query(sql, p = []) {
+    const s = String(sql).replace(/\s+/g, ' ').trim();
+    queries.push(s);
+    if (s === 'BEGIN') { snap = clone(st); return { rows: [] }; }
+    if (s === 'COMMIT') { snap = null; return { rows: [] }; }
+    if (s === 'ROLLBACK') { if (snap) st = snap; snap = null; return { rows: [] }; }
+
+    // ---- goal archive -------------------------------------------------------
+    if (/^SELECT .* FROM goals WHERE id = \$1 FOR UPDATE$/.test(s)) return { rows: [goal(p[0])].filter(Boolean).map(out) };
+    if (/FROM tasks WHERE id = \$1 AND goal_id = \$2 FOR UPDATE$/.test(s)) {
+      const t = task(p[0]);
+      return { rows: t && same(t.goal_id, p[1]) ? [out(t)] : [] };
+    }
+    if (/FROM tasks WHERE id = ANY\(\$1::bigint\[\]\) AND goal_id = \$2 ORDER BY id FOR UPDATE$/.test(s)) {
+      return { rows: st.tasks.filter((t) => inIds(p[0], t.id) && same(t.goal_id, p[1])).sort((a, b) => a.id - b.id).map(out) };
+    }
+    if (/^SELECT id FROM claims WHERE task_id = \$1 AND released_at IS NULL LIMIT 1$/.test(s)) {
+      return { rows: st.claims.filter((c) => same(c.task_id, idKey(p[0])) && !c.released_at).slice(0, 1).map((c) => ({ id: String(c.id) })) };
+    }
+    if (/^SELECT DISTINCT task_id FROM claims WHERE task_id = ANY\(\$1::bigint\[\]\) AND released_at IS NULL$/.test(s)) {
+      const ids = [...new Set(st.claims.filter((c) => inIds(p[0], c.task_id) && !c.released_at).map((c) => String(c.task_id)))];
+      return { rows: ids.map((task_id) => ({ task_id })) };
+    }
+    if (/^UPDATE tasks SET status = 'abandoned', .* WHERE id = \$1$/.test(s)) {
+      const t = task(p[0]); t.status = 'abandoned'; if (p[1]) t.value_summary = p[1];
+      return { rows: [], rowCount: 1 };
+    }
+    if (/^SELECT id, status FROM goals WHERE id = \$1 FOR SHARE$/.test(s)) return { rows: [goal(p[0])].filter(Boolean).map((g) => ({ id: String(g.id), status: g.status })) };
+    if (/^UPDATE tasks SET goal_id = \$2, updated_at = now\(\) WHERE id = \$1$/.test(s)) {
+      task(p[0]).goal_id = Number(p[1]);
+      return { rows: [], rowCount: 1 };
+    }
+    if (/count\(\*\)::int AS n FROM (tasks|goals)/.test(s)) return { rows: [{ n: 0 }] }; // the re-counts are not under test
+    if (/^UPDATE goal_membership_requests/.test(s)) return { rows: [], rowCount: 0 };
+
+    // ---- version close ------------------------------------------------------
+    if (/FROM versions WHERE id = \$1 FOR UPDATE$/.test(s)) return { rows: [{ id: p[0], status: 'building' }] };
+    if (/FROM goals WHERE id = \$1 AND version_id = \$2 FOR UPDATE$/.test(s)) {
+      const g = goal(p[0]);
+      return { rows: g && same(g.version_id, p[1]) ? [out(g)] : [] };
+    }
+    if (/FROM goals WHERE id = ANY\(\$1::bigint\[\]\) AND version_id = \$2 ORDER BY id FOR UPDATE$/.test(s)) {
+      return { rows: st.goals.filter((g) => inIds(p[0], g.id) && same(g.version_id, p[1])).sort((a, b) => a.id - b.id).map(out) };
+    }
+    if (/^UPDATE tasks SET status = 'abandoned', .* WHERE goal_id = \$1 AND .* RETURNING id$/.test(s)) {
+      const hit = st.tasks.filter((t) => same(t.goal_id, idKey(p[0])) && openWork(t));
+      for (const t of hit) { t.status = 'abandoned'; t.value_summary = p[1]; }
+      return { rows: hit.map((t) => ({ id: String(t.id) })) };
+    }
+    if (/^UPDATE goals SET status = 'archived', updated_at = now\(\) WHERE id = \$1/.test(s)) {
+      const g = goal(p[0]); g.status = 'archived';
+      return { rows: [out(g)], rowCount: 1 };
+    }
+    if (/^WITH next_order AS .* INSERT INTO goals/.test(s)) {
+      const src = goal(p[0]);
+      const id = st.nextGoalId++;
+      st.goals.push({ id, version_id: p[1], title: src.title, status: 'open', succeeded_by_goal_id: null });
+      return { rows: [{ id: String(id) }] };
+    }
+    if (/^INSERT INTO goal_members/.test(s)) return { rows: [], rowCount: 0 };
+    if (/^UPDATE tasks SET goal_id = \$2, version_id = \$3, .* RETURNING id$/.test(s)) {
+      const hit = st.tasks.filter((t) => same(t.goal_id, idKey(p[0])) && openWork(t));
+      for (const t of hit) { t.goal_id = Number(p[1]); t.version_id = p[2]; }
+      return { rows: hit.map((t) => ({ id: String(t.id) })) };
+    }
+    if (/^UPDATE goals SET succeeded_by_goal_id = \$2/.test(s)) { goal(p[0]).succeeded_by_goal_id = Number(p[1]); return { rows: [] }; }
+    if (/FROM tasks t LEFT JOIN goals g/.test(s)) return { rows: [] };
+    if (/^UPDATE versions SET status = 'shipped'/.test(s)) return { rows: [{ id: p[0], status: 'shipped' }] };
+
+    // ---- weekly karma tally -------------------------------------------------
+    if (/FROM peer_votes pv JOIN tasks t/.test(s)) {
+      return { rows: st.peerVotes.filter((v) => !v.tallied).map((v) => ({ id: String(v.id), builder_id: String(v.builder_id), vote: v.vote })) };
+    }
+    if (/to_regclass\('ideas_votes'\)/.test(s)) return { rows: [{ has: st.ideaVotes !== null }] };
+    if (/FROM ideas_votes iv JOIN idea_inbox i/.test(s)) {
+      return { rows: st.ideaVotes.filter((v) => !v.tallied).map((v) => ({ id: String(v.id), builder_id: String(v.builder_id), vote: v.vote })) };
+    }
+    if (/^INSERT INTO karma_log .* VALUES \(\$1, \$2, 'peer_vote_weekly', NULL\)$/.test(s)) {
+      st.karma.push({ builder_id: String(p[0]), delta: Number(p[1]), reason: 'peer_vote_weekly', granted_by: null });
+      return { rows: [], rowCount: 1 };
+    }
+    if (/^INSERT INTO karma_log .* FROM unnest\(\$1::bigint\[\], \$2::int\[\]\) WITH ORDINALITY .* ORDER BY k\.ord$/.test(s)) {
+      p[0].forEach((b, i) => st.karma.push({ builder_id: String(b), delta: Number(p[1][i]), reason: 'peer_vote_weekly', granted_by: null }));
+      return { rows: [], rowCount: p[0].length };
+    }
+    if (/^UPDATE (peer_votes|ideas_votes) SET tallied_at = now\(\) WHERE id = ANY/.test(s)) {
+      const list = s.startsWith('UPDATE peer_votes') ? st.peerVotes : st.ideaVotes;
+      for (const v of list) if (inIds(p[0], v.id)) v.tallied = true;
+      return { rows: [], rowCount: p[0].length };
+    }
+
+    throw new Error(`fake db: unhandled statement: ${s.slice(0, 120)}`);
+  }
+  const client = { query, release() {} };
+  return {
+    pool: { connect: async () => client, query },
+    client,
+    queries,
+    get state() { return clone(st); },
+  };
+}
+
+// Run a legacy loop the way its function ran it: inside one transaction, rolled
+// back on a throw. Returns { result } or { error }.
+async function runLegacyTx(db, fn) {
+  await db.client.query('BEGIN');
+  try {
+    const result = await fn(db.client);
+    await db.client.query('COMMIT');
+    return { result };
+  } catch (error) {
+    await db.client.query('ROLLBACK');
+    return { error };
+  }
+}
+async function runNew(fn) {
+  try { return { result: await fn() }; } catch (error) { return { error }; }
+}
+const errShape = (e) => (e ? { code: e.code, taskId: e.taskId, taskTitle: e.taskTitle, goalId: e.goalId, toGoalId: e.toGoalId, targetStatus: e.targetStatus } : null);
+
+// ---- goal archive ------------------------------------------------------------
+
+const ARCHIVE_SEED = {
+  goals: [
+    { id: 7, version_id: 'V1', title: 'the goal being archived', status: 'open' },
+    { id: 8, version_id: 'V1', title: 'a neighbour', status: 'open' },
+    { id: 9, version_id: 'V1', title: 'an open move target', status: 'open' },
+    { id: 10, version_id: 'V1', title: 'a closed move target', status: 'archived' },
+  ],
+  tasks: [
+    { id: 1, goal_id: 7, version_id: 'V1', status: 'ready', title: 'one', value_summary: null },
+    { id: 2, goal_id: 7, version_id: 'V1', status: 'shipped', title: 'two', value_summary: null },
+    { id: 3, goal_id: 8, version_id: 'V1', status: 'ready', title: 'three (elsewhere)', value_summary: null },
+    { id: 4, goal_id: 7, version_id: 'V1', status: 'active', title: 'four (claimed)', value_summary: null },
+    { id: 5, goal_id: 7, version_id: 'V1', status: 'backlog', title: 'five', value_summary: null },
+    { id: 6, goal_id: 7, version_id: 'V1', status: 'ready', title: 'six', value_summary: null },
+  ],
+  claims: [{ id: 99, task_id: 4, released_at: null }, { id: 98, task_id: 6, released_at: '2026-01-01' }],
+  nextGoalId: 100,
+};
+
+const ARCHIVE_PLANS = {
+  'mixed verbs, skips and a move': [
+    { taskId: 1, verb: 'abandon' }, { taskId: 2, verb: 'abandon' }, { taskId: 3, verb: 'abandon' },
+    { taskId: 5, verb: 'move', toGoalId: 9 }, { taskId: 6, verb: 'abandon' },
+  ],
+  'plan order is not id order': [{ taskId: 6, verb: 'abandon' }, { taskId: 1, verb: 'move', toGoalId: 9 }, { taskId: 5, verb: 'abandon' }],
+  'a task named twice reads what the first step left': [
+    { taskId: 1, verb: 'abandon' }, { taskId: 1, verb: 'abandon' },
+    { taskId: 5, verb: 'move', toGoalId: 9 }, { taskId: 5, verb: 'abandon' },
+  ],
+  'ids as strings, as a JSON body carries them': [{ taskId: '1', verb: 'abandon' }, { taskId: '5', verb: 'move', toGoalId: '9' }],
+  'an actively claimed task stops it, after earlier steps': [{ taskId: 1, verb: 'abandon' }, { taskId: 4, verb: 'abandon' }, { taskId: 6, verb: 'abandon' }],
+  'a closed move target stops it': [{ taskId: 1, verb: 'abandon' }, { taskId: 5, verb: 'move', toGoalId: 10 }],
+  'a missing move target stops it': [{ taskId: 5, verb: 'move', toGoalId: 404 }],
+  'a task that does not exist is skipped': [{ taskId: 777, verb: 'abandon' }, { taskId: 6, verb: 'abandon' }],
+  'an empty plan': [],
+};
+
+for (const [name, plan] of Object.entries(ARCHIVE_PLANS)) {
+  test(`goal archive, old loop vs batched: ${name}`, async () => {
+    const args = { goalId: 7, plan, reason: 'cut in review' };
+    const oldDb = fakeDb(ARCHIVE_SEED);
+    const old = await runLegacyTx(oldDb, (c) => legacy.legacyArchiveLoop(c, args));
+    const neuDb = fakeDb(ARCHIVE_SEED);
+    const neu = await runNew(() => archiveGoalWithDispositions(args, { pool: neuDb.pool }));
+
+    assert.deepEqual(errShape(neu.error), errShape(old.error), 'the same refusal, naming the same task');
+    if (!old.error) assert.deepEqual(neu.result.applied, old.result, 'the same applied list, in plan order');
+    assert.deepEqual(neuDb.state.tasks, oldDb.state.tasks, 'the same tasks left behind');
+  });
+}
+
+test('goal archive reads every plan task in ONE locked statement and the claims in one more', async () => {
+  const db = fakeDb(ARCHIVE_SEED);
+  await archiveGoalWithDispositions({ goalId: 7, plan: ARCHIVE_PLANS['mixed verbs, skips and a move'], reason: 'r' }, { pool: db.pool });
+  assert.equal(db.queries.filter((q) => /FROM tasks WHERE id = ANY/.test(q)).length, 1);
+  assert.equal(db.queries.filter((q) => /FROM claims WHERE task_id/.test(q)).length, 1);
+  assert.equal(db.queries.filter((q) => /FROM tasks WHERE id = \$1/.test(q)).length, 0, 'no per-step read is left');
+});
+
+// ---- version close -----------------------------------------------------------
+
+const CLOSE_SEED = {
+  goals: [
+    { id: 1, version_id: 'V1', title: 'g1', status: 'open', succeeded_by_goal_id: null },
+    { id: 2, version_id: 'V1', title: 'g2', status: 'open', succeeded_by_goal_id: null },
+    { id: 3, version_id: 'V1', title: 'g3 (already closed)', status: 'archived', succeeded_by_goal_id: null },
+    { id: 4, version_id: 'V9', title: 'g4 (another version)', status: 'open', succeeded_by_goal_id: null },
+    { id: 5, version_id: 'V1', title: 'g5', status: 'open', succeeded_by_goal_id: null },
+  ],
+  tasks: [
+    { id: 11, goal_id: 1, version_id: 'V1', status: 'ready', title: 'a', value_summary: null },
+    { id: 12, goal_id: 1, version_id: 'V1', status: 'shipped', title: 'b', value_summary: 'done' },
+    { id: 13, goal_id: 1, version_id: 'V1', status: 'ready', title: '__smoke__ fixture', value_summary: null },
+    { id: 21, goal_id: 2, version_id: 'V1', status: 'backlog', title: 'c', value_summary: null },
+    { id: 22, goal_id: 2, version_id: 'V1', status: 'active', title: 'd', value_summary: null },
+    { id: 51, goal_id: 5, version_id: 'V1', status: 'ready', title: 'e', value_summary: null },
+  ],
+  claims: [],
+  nextGoalId: 100,
+};
+
+const CLOSE_CASES = {
+  'abandon and roll forward, with skips': {
+    plan: [{ goalId: 1, verb: 'abandon' }, { goalId: 3, verb: 'abandon' }, { goalId: 4, verb: 'roll_forward' }, { goalId: 2, verb: 'roll_forward' }],
+    planningVersionId: 'V2',
+  },
+  'plan order is not id order': {
+    plan: [{ goalId: 5, verb: 'roll_forward' }, { goalId: 2, verb: 'abandon' }, { goalId: 1, verb: 'roll_forward' }],
+    planningVersionId: 'V2',
+  },
+  'a goal named twice reads archived the second time': {
+    plan: [{ goalId: 1, verb: 'abandon' }, { goalId: 1, verb: 'roll_forward' }, { goalId: 2, verb: 'roll_forward' }, { goalId: 2, verb: 'abandon' }],
+    planningVersionId: 'V2',
+  },
+  'ids as strings': { plan: [{ goalId: '2', verb: 'abandon' }, { goalId: '5', verb: 'roll_forward' }], planningVersionId: 'V2' },
+  'a roll forward with no planning version throws after earlier steps': {
+    plan: [{ goalId: 1, verb: 'abandon' }, { goalId: 2, verb: 'roll_forward' }],
+    planningVersionId: null,
+  },
+  'an empty plan': { plan: [], planningVersionId: 'V2' },
+};
+
+for (const [name, { plan, planningVersionId }] of Object.entries(CLOSE_CASES)) {
+  test(`version close, old loop vs batched: ${name}`, async () => {
+    const args = { versionId: 'V1', plan, reason: 'V1 is done', planningVersionId };
+    const oldDb = fakeDb(CLOSE_SEED);
+    const old = await runLegacyTx(oldDb, (c) => legacy.legacyCloseLoop(c, args));
+    const neuDb = fakeDb(CLOSE_SEED);
+    const neu = await runNew(() => closeVersion(args, { pool: neuDb.pool }));
+
+    assert.deepEqual(errShape(neu.error), errShape(old.error), 'the same refusal');
+    if (!old.error) assert.deepEqual(neu.result.applied, old.result, 'the same applied list, in plan order');
+    assert.deepEqual(neuDb.state.goals, oldDb.state.goals, 'the same goals, successors included');
+    assert.deepEqual(neuDb.state.tasks, oldDb.state.tasks, 'the same tasks');
+  });
+}
+
+test('version close locks every plan goal in ONE statement, in id order', async () => {
+  const db = fakeDb(CLOSE_SEED);
+  await closeVersion({ versionId: 'V1', plan: CLOSE_CASES['plan order is not id order'].plan, reason: 'r', planningVersionId: 'V2' }, { pool: db.pool });
+  const locks = db.queries.filter((q) => /FROM goals WHERE id = ANY\(\$1::bigint\[\]\) AND version_id = \$2 ORDER BY id FOR UPDATE/.test(q));
+  assert.equal(locks.length, 1);
+  assert.equal(db.queries.filter((q) => /FROM goals WHERE id = \$1 AND version_id/.test(q)).length, 0, 'no per-step lock is left');
+});
+
+// ---- weekly karma tally ------------------------------------------------------
+
+const TALLY_SEED = {
+  goals: [], tasks: [], claims: [], nextGoalId: 1, karma: [],
+  peerVotes: [
+    { id: 1, builder_id: 30, vote: 1 }, { id: 2, builder_id: 10, vote: 1 }, { id: 3, builder_id: 30, vote: 1 },
+    { id: 4, builder_id: 20, vote: 1 }, { id: 5, builder_id: 20, vote: -1 }, // nets to zero: no row
+    { id: 6, builder_id: 40, vote: -1 },
+  ],
+  ideaVotes: [{ id: 7, builder_id: 10, vote: 1 }, { id: 8, builder_id: 50, vote: 1 }],
+};
+
+async function withFakePool(db, fn) {
+  const had = Object.prototype.hasOwnProperty.call(pgPool, 'connect');
+  const real = pgPool.connect;
+  pgPool.connect = db.pool.connect;
+  try { return await fn(); } finally { if (had) pgPool.connect = real; else delete pgPool.connect; }
+}
+const fakeWithTx = (db) => async (fn) => {
+  await db.client.query('BEGIN');
+  try { const r = await fn(db.client); await db.client.query('COMMIT'); return r; } catch (e) { await db.client.query('ROLLBACK'); throw e; }
+};
+
+for (const [name, seed] of Object.entries({
+  'task and idea votes, a zero net, first-seen order': TALLY_SEED,
+  'no ideas module': { ...TALLY_SEED, ideaVotes: null },
+  'nothing matured': { ...TALLY_SEED, peerVotes: [], ideaVotes: [] },
+})) {
+  test(`weekly karma tally, old loop vs batched: ${name}`, async () => {
+    const oldDb = fakeDb(seed);
+    const old = await legacy.legacyTallyPeerVotes(fakeWithTx(oldDb));
+    const neuDb = fakeDb(seed);
+    const neu = await withFakePool(neuDb, () => tallyPeerVotes());
+
+    assert.deepEqual(neu, old, 'the same reply');
+    assert.deepEqual(neuDb.state.karma, oldDb.state.karma, 'the same karma_log rows, in the same order');
+    assert.deepEqual(neuDb.state.peerVotes, oldDb.state.peerVotes, 'the same votes stamped');
+    assert.deepEqual(neuDb.state.ideaVotes, oldDb.state.ideaVotes);
+  });
+}
+
+test('the tally writes every credited builder in ONE insert', async () => {
+  const db = fakeDb(TALLY_SEED);
+  const r = await withFakePool(db, () => tallyPeerVotes());
+  assert.equal(r.builders_credited, 4);
+  assert.equal(db.queries.filter((q) => /^INSERT INTO karma_log/.test(q)).length, 1);
+});

package/tests/conductor_main_e2e.mjs

@@ -161,6 +161,10 @@ await test('asking for the next how-to step twice in one session reaches the AI
   const r = await runHook(mePayload(), { prompts: ["what's next in the tutorial", "what's next in the tutorial"] });
   assert.equal(r.outs.length, 2);
   for (const [i, out] of r.outs.entries()) assert.ok(out.includes('npx bongos howto next'), `ask ${i + 1} was swallowed; stdout: ${JSON.stringify(out.slice(0, 200))}`);
+  // task 1004742: the second ask prints the how-to answer ALONE; the rest of the
+  // block (here, the interaction profile) was already shown this session.
+  assert.ok(r.outs[0].includes(INTERACTION), 'the first prompt carries the whole block');
+  assert.ok(!r.outs[1].includes(INTERACTION), `the repeat re-printed the whole block; stdout: ${JSON.stringify(r.outs[1].slice(0, 300))}`);
 });
 
 summary();