@bongos/core 1.21.173 → 1.21.175

package/tests/artist_review_goal.mjs

@@ -0,0 +1,119 @@
+// tests/artist_review_goal.mjs
+//
+// Every version's ARTIST REVIEW goal (task 1004819): the find-or-create behind
+// createTask's `artistReview` switch and createVersion. DB-free: a recording fake
+// client stands in for Postgres, and the statement order is the contract — the
+// version gate before anything else, the advisory lock before the read, and the
+// two standing criteria written only when the goal is new.
+//
+// Run:  node tests/artist_review_goal.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { makeRunner } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+
+const require = createRequire(import.meta.url);
+const { ensureArtistReviewGoal, artistReviewGoalTitle, ARTIST_REVIEW_CRITERIA } = require('../modules/lifecycle/artist-review-goal.js');
+const { createTask } = require('../modules/lifecycle/db.js');
+
+const { test, summary } = makeRunner();
+const norm = (s) => String(s).replace(/\s+/g, ' ').trim();
+
+// One version, at most one goal: the fake answers like the tables would.
+function fakeClient({ status = 'building', goal = null } = {}) {
+  const queries = [];
+  const state = { goal, criteria: [], tasks: [] };
+  const client = {
+    queries, state,
+    async query(sql, params = []) {
+      const q = norm(sql);
+      queries.push({ sql: q, params });
+      if (/^(BEGIN|COMMIT|ROLLBACK)$/.test(q)) return { rows: [] };
+      if (/^SELECT status FROM versions WHERE id = \$1/.test(q)) return { rows: status ? [{ status }] : [] };
+      if (/pg_advisory_xact_lock/.test(q)) return { rows: [] };
+      if (/^SELECT id, version_id, title FROM goals WHERE version_id = \$1 AND title = \$2/.test(q)) {
+        return { rows: state.goal && state.goal.title === params[1] ? [state.goal] : [] };
+      }
+      if (/^INSERT INTO goals/.test(q)) { state.goal = { id: 91, version_id: params[0], title: params[1] }; return { rows: [state.goal] }; }
+      if (/^INSERT INTO done_when_criteria/.test(q)) { state.criteria.push({ id: params[1], goal: params[3] }); return { rows: [] }; }
+      if (/^SELECT scope_modules FROM goals WHERE id = \$1/.test(q)) return { rows: [{ scope_modules: [] }] };
+      if (/^INSERT INTO tasks/.test(q)) { const t = { id: 1, goal_id: params[22] }; state.tasks.push(t); return { rows: [t] }; }
+      return { rows: [] };
+    },
+    release() {},
+  };
+  return client;
+}
+
+await test('the title is the version plus " — artist review" (em dash)', () => {
+  assert.equal(artistReviewGoalTitle('BONGOS-V3'), 'BONGOS-V3 — artist review');
+  assert.deepEqual(ARTIST_REVIEW_CRITERIA.map((c) => c.criterion_id), ['artist-every-page-reviewed', 'artist-pages-simple-to-use']);
+});
+
+await test('a new goal is made with its two criteria, after the version gate and the lock', async () => {
+  const c = fakeClient();
+  const g = await ensureArtistReviewGoal('BONGOS-V3', { client: c });
+  assert.equal(g.title, 'BONGOS-V3 — artist review');
+  const order = c.queries.map((q) => q.sql.split(' ').slice(0, 3).join(' '));
+  const at = (re) => c.queries.findIndex((q) => re.test(q.sql));
+  assert.ok(at(/FROM versions/) < at(/pg_advisory_xact_lock/), 'the version is checked first');
+  assert.ok(at(/pg_advisory_xact_lock/) < at(/FROM goals WHERE version_id/), 'the lock is taken before the read');
+  assert.equal(c.queries.find((q) => /pg_advisory_xact_lock/.test(q.sql)).params[0], 'BONGOS-V3 — artist review', 'locked on the title');
+  assert.deepEqual(c.state.criteria, [{ id: 'artist-every-page-reviewed', goal: 91 }, { id: 'artist-pages-simple-to-use', goal: 91 }]);
+  assert.ok(/ON CONFLICT \(version_id, criterion_id\) DO NOTHING/.test(c.queries.find((q) => /INSERT INTO done_when_criteria/.test(q.sql)).sql),
+    'a criterion already on the version is left alone', order);
+});
+
+await test('an existing goal is reused, never duplicated, and still carries the two criteria', async () => {
+  // A goal of this title made by hand before the first studio write is found,
+  // and its criteria are seeded (ON CONFLICT DO NOTHING keeps any already there).
+  const c = fakeClient({ goal: { id: 1000134, version_id: 'BONGOS-V2', title: 'BONGOS-V2 — artist review' } });
+  const g = await ensureArtistReviewGoal('BONGOS-V2', { client: c });
+  assert.equal(g.id, 1000134);
+  assert.equal(c.queries.some((q) => /^INSERT INTO goals/.test(q.sql)), false, 'no second goal');
+  assert.deepEqual(c.state.criteria, [{ id: 'artist-every-page-reviewed', goal: 1000134 }, { id: 'artist-pages-simple-to-use', goal: 1000134 }]);
+});
+
+await test('a closed or missing version gets no goal, and nothing is locked or written', async () => {
+  for (const status of ['shipped', null]) {
+    const c = fakeClient({ status });
+    assert.equal(await ensureArtistReviewGoal('V0', { client: c }), null);
+    assert.equal(c.queries.length, 1, 'only the version read ran');
+  }
+  const planning = fakeClient({ status: 'planning' });
+  assert.ok(await ensureArtistReviewGoal('V4', { client: planning }), 'a planning version takes one, so a new version is born with it');
+});
+
+await test('with no caller transaction it opens its own, so the lock means something', async () => {
+  const c = fakeClient();
+  const pool = { connect: async () => c, query: (...a) => c.query(...a) };
+  await ensureArtistReviewGoal('BONGOS-V3', { pool });
+  const sqls = c.queries.map((q) => q.sql);
+  assert.equal(sqls[0], 'BEGIN');
+  assert.equal(sqls.at(-1), 'COMMIT');
+});
+
+await test('createTask with artistReview lands in the goal; without one the catch-all still answers', async () => {
+  const c = fakeClient();
+  await createTask({ versionId: 'BONGOS-V3', title: 'Tweak: Home (builders:home)', discipline: 'artist', artistReview: true }, { client: c });
+  assert.equal(c.state.tasks[0].goal_id, 91, 'the studio task names the artist review goal');
+  await assert.rejects(
+    () => createTask({ versionId: 'BONGOS-V3', title: 'plain', discipline: 'engineer' }, { client: fakeClient() }),
+    /goalId is required/, 'an ordinary goal-less create still throws');
+});
+
+await test('a create with no caller transaction (a copy proposal) puts goal and task in ONE transaction', async () => {
+  const c = fakeClient();
+  const pool = { connect: async () => c, query: () => { throw new Error('nothing may run outside the transaction'); } };
+  await createTask({ versionId: 'BONGOS-V3', title: 'Reword the Home heading', discipline: 'artist', artistReview: true }, { pool });
+  const sqls = c.queries.map((q) => q.sql);
+  const begins = sqls.filter((q) => q === 'BEGIN').length;
+  assert.equal(begins, 1, 'exactly one transaction');
+  assert.ok(sqls.indexOf('BEGIN') < sqls.findIndex((q) => /^INSERT INTO goals/.test(q)), 'the goal is made inside it');
+  assert.ok(sqls.findIndex((q) => /^INSERT INTO tasks/.test(q)) < sqls.lastIndexOf('COMMIT'), 'and the task too, before the one COMMIT');
+  assert.equal(c.state.tasks[0].goal_id, 91);
+});
+
+summary();

package/tests/blockers_hall.mjs

@@ -54,7 +54,9 @@ test('goal-inbox.js renders blocker rows through the SHARED lib, not a re-implem
 });
 
 test('the blocker row carries .ginbox__item, so the card\'s count-pill and visibility include it', () => {
-  assert.match(GOAL_INBOX_SRC, /function blockerRowHtml[\s\S]*?class="ginbox__item"/);
+  // task 1004820: the row is the city's ask card, drawn by OTBAsk with the item class
+  assert.match(GOAL_INBOX_SRC, /function blockerRowHtml[\s\S]*?OTBAsk\.html\(\{[\s\S]*?cls: 'ginbox__item'/);
+  assert.match(GOAL_INBOX_SRC, /function blockerRowHtml[\s\S]*?label: 'Resolve it'/, 'the home blocker row is actionable');
 });
 
 test('the mount() boot sequence actually calls loadBlockers(), in its place in the order', () => {

package/tests/copy_desk_page_claim.mjs

@@ -86,8 +86,13 @@ try {
     assert.equal(db.tasks.length, 1);
     assert.deepEqual(
       [t.source, t.source_ref, t.title, t.kind, t.discipline, t.credits_reward, t.version_id, t.goal_id, t.status],
-      ['page-tweak', 'page-tweak/builders:studio/r1', 'Tweak: Studio (builders:studio)', 'feature', 'artist', 30, 'V9', '77', 'active']
+      ['page-tweak', 'page-tweak/builders:studio/r1', 'Tweak: Studio (builders:studio)', 'feature', 'artist', 30, 'V9', '88', 'active']
     );
+    // task 1004819: the round lands in the version's artist review goal, made on
+    // first use with its two standing criteria — never the catch-all.
+    assert.equal(db.artistGoal.title, 'V9 — artist review');
+    assert.deepEqual(db.criteria.map((x) => [x.criterion_id, x.goal_id]),
+      [['artist-every-page-reviewed', '88'], ['artist-pages-simple-to-use', '88']]);
     assert.deepEqual(t.touches, F.STUDIO_FILES, 'touches are the inventory page files');
     const c = db.claims[0];
     assert.deepEqual([c.builder_id, c.worktree_name, c.creator_session_id], [ALICE, null, null], 'a web claim: no worktree, no session');

package/tests/copy_desk_page_submit.mjs

@@ -208,7 +208,7 @@ try {
       `page-tweak-unplaced/${studioTask().id}/L0005`,
     ]);
     for (const t of eng) {
-      assert.deepEqual([t.status, t.discipline, t.kind, t.version_id, t.goal_id, t.created_by], ['backlog', 'engineer', 'feature', 'V9', '77', ALICE]);
+      assert.deepEqual([t.status, t.discipline, t.kind, t.version_id, t.goal_id, t.created_by], ['backlog', 'engineer', 'feature', 'V9', '88', ALICE], 'an unplaced line lands in the artist review goal (task 1004819)');
       assert.match(t.description, /builders:studio/);
     }
     const quiet = eng.find((t) => t.source_ref.endsWith('/L0005'));

package/tests/fixtures/page-ledger.mjs

@@ -36,6 +36,7 @@ export function installPageLedger(api, { builders }) {
   // first commits or rolls back.
   const locks = new Map();
   async function lock(key, owner) {
+    if (locks.has(key) && locks.get(key).owner === owner) return; // re-entrant, as Postgres is for one session
     while (locks.has(key)) await locks.get(key).done;
     let release;
     const done = new Promise((r) => { release = r; });
@@ -109,6 +110,18 @@ export function installPageLedger(api, { builders }) {
     if (/FROM goals g JOIN versions v ON v\.id = g\.version_id WHERE g\.version_id = \$1 AND g\.title = \$2/.test(q)) {
       return { rows: [{ id: '77', version_status: 'building' }] };
     }
+    // task 1004819: studio work lands in the version's artist review goal, found
+    // (or made, with its two criteria) on the same transaction client.
+    if (/^SELECT status FROM versions WHERE id = \$1/.test(q)) return { rows: [{ status: 'building' }] };
+    if (/^SELECT id, version_id, title FROM goals WHERE version_id = \$1 AND title = \$2/.test(q)) {
+      assert.ok(owner, 'the artist review goal must be found on the transaction client');
+      return { rows: db.artistGoal ? [{ ...db.artistGoal }] : [] };
+    }
+    if (/^INSERT INTO goals \(version_id, title, description, scope_modules, status, created_by, sort_order\)/.test(q)) {
+      db.artistGoal = { id: '88', version_id: p[0], title: p[1] };
+      return { rows: [{ ...db.artistGoal }] };
+    }
+    if (/^INSERT INTO done_when_criteria/.test(q)) { (db.criteria = db.criteria || []).push({ version_id: p[0], criterion_id: p[1], goal_id: p[3] }); return { rows: [] }; }
     if (/^SELECT scope_modules FROM goals WHERE id = \$1/.test(q)) return { rows: [{ scope_modules: [] }] };
     if (/^INSERT INTO tasks \(version_id, title, description, status, touches,/.test(q)) {
       assert.ok(owner, 'the round must be created inside the claim transaction');

package/tests/hall_city_rewording.mjs

@@ -49,3 +49,14 @@ test('the "?" asks before it sends: the send lives behind a confirm button', ()
   assert.match(fn, /Send this to Claude to rewrite\?/);
   assert.match(fn, /Nothing is decided or changed/);
 });
+
+test('a card never cuts what it says: the whole text is one tap away, and only when there is more', () => {
+  const G = boot();
+  const m = { id: 'override_requests:1', title: 'Override: a long title', detail: 'The whole story, word for word.' };
+  assert.equal(G.fullText(m, { question: 'Release it?' }), 'Override: a long title\n\nThe whole story, word for word.');
+  assert.equal(G.fullText(m, { question: 'Override: a long title' }), 'The whole story, word for word.', 'the question is not repeated');
+  assert.equal(G.fullText({ id: 'x:1', title: 'Same' }, { question: 'Same' }), '', 'nothing more to show, no opener');
+  assert.equal(G.fullText(null, { question: 'Q?' }), '');
+  const src = fs.readFileSync(path.join(PUB, 'city-decide.js'), 'utf8');
+  assert.match(src, /str\(o\.input && o\.input\.label\) \|\| str\(o\.label\)/, 'an answer uses its full words, not the desk chip cut to fit');
+});

package/tests/home_attention_cards.mjs

@@ -16,6 +16,7 @@ const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const lib = require(path.join(ROOT, 'modules', 'ui-design', 'kit', 'lib.js'));
 const GOAL_INBOX = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'goal-inbox.js'), 'utf8');
+const HALL_ASK = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'hall-ask.js'), 'utf8');
 
 let browser = null;
 try { browser = await lib.launchBrowser(); } catch (e) { if (!(e instanceof lib.NoBrowserError)) throw e; }
@@ -48,6 +49,7 @@ async function bootInbox() {
   const page = await ctx.newPage();
   await page.setContent(PAGE);
   await page.addScriptTag({ content: STUBS });
+  await page.addScriptTag({ content: HALL_ASK }); // task 1004820: the rows are OTBAsk cards
   await page.addScriptTag({ content: GOAL_INBOX });
   await page.evaluate(() => window.__widget.mount(document.getElementById('attention-scroll')));
   await page.waitForFunction(() => document.querySelectorAll('.attn-card').length === 2);

package/tests/rot_inbox.mjs

@@ -593,14 +593,14 @@ test('the slice lands in the EXISTING attention card — never a new Home card',
 });
 
 test('rot rows carry .ginbox__item, so the card\'s count-pill and visibility include them', () => {
-  assert.match(GOAL_INBOX_SRC, /function rotRowHtml[\s\S]*?class="ginbox__item"/,
+  assert.match(GOAL_INBOX_SRC, /function rotRowHtml[\s\S]*?cls: 'ginbox__item'/,
     'a rot row that does not carry the shared item class would be invisible to OTBAttention.refresh()');
 });
 
 test('the client renders SERVER-declared verbs rather than a hardcoded button list', () => {
   assert.match(GOAL_INBOX_SRC, /\(Array\.isArray\(r\.verbs\) \? r\.verbs : \[\]\)\.map/,
     'the buttons must come from the row\'s verbs array — a hardcoded list is a second copy of the tier→verb mapping');
-  assert.match(GOAL_INBOX_SRC, /data-rot-path=/, 'each button carries the server-declared path');
+  assert.match(GOAL_INBOX_SRC, /'data-rot-path':/, 'each button carries the server-declared path');
 });
 
 test('row builders emit the CSS classes style.css actually defines, not ginbox__main/ginbox__acts (task 1003284)', () => {
@@ -610,10 +610,10 @@ test('row builders emit the CSS classes style.css actually defines, not ginbox__
     '.ginbox__main is undefined in style.css — with it the row title and sub-line run together inline instead of stacking');
   assert.doesNotMatch(GOAL_INBOX_SRC, /ginbox__acts\b/,
     '.ginbox__acts is undefined in style.css — with it the action button loses its flex sizing');
-  assert.match(GOAL_INBOX_SRC, /function nodRowHtml[\s\S]*?class="ginbox__body"[\s\S]*?class="ginbox__actions"/,
-    'nodRowHtml must emit the defined ginbox__body/ginbox__actions classes');
-  assert.match(GOAL_INBOX_SRC, /function rotRowHtml[\s\S]*?class="ginbox__body"[\s\S]*?class="ginbox__actions"/,
-    'rotRowHtml must emit the defined ginbox__body/ginbox__actions classes');
+  // task 1004820: the nod and rot rows are the city's ask card, whose classes hall-ask.css defines
+  for (const fn of ['nodRowHtml', 'rotRowHtml']) {
+    assert.match(GOAL_INBOX_SRC, new RegExp(`function ${fn}[\\s\\S]*?OTBAsk\\.html\\(`), `${fn} draws the ask card`);
+  }
 });
 
 test('the nod, removal and rot lists use the defined .ginbox list class, not ginbox__list (task 1003982)', () => {
@@ -635,6 +635,9 @@ test('rotRowHtml escapes the row href like every sibling field (task 1003631)',
   const start = GOAL_INBOX_SRC.indexOf('function rotRowHtml');
   const body = GOAL_INBOX_SRC.slice(start, GOAL_INBOX_SRC.indexOf('\n  }\n', start));
   assert.ok(start > 0, 'rotRowHtml exists');
-  assert.match(body, /href="\$\{escapeHtml\(href\)\}"/, 'href goes through escapeHtml');
+  // task 1004820: the href is handed to OTBAsk, which escapes every attribute
+  assert.match(body, /qHref: href/, 'href is handed to OTBAsk');
+  const ask = require('../modules/hall-ui/public/hall-ask.js');
+  assert.match(ask.html({ q: 'x', qHref: '/t?a="<b>' }), /href="\/t\?a=&quot;&lt;b&gt;"/, 'OTBAsk escapes the href');
   assert.doesNotMatch(body, /href="\$\{href\}"/, 'no raw href interpolation');
 });

package/tests/task_goal_required.mjs

@@ -113,12 +113,11 @@ test('POST /tasks does NOT pass the escape hatch — this door always has a goal
 
 const OPT_INS = [
   ['modules/onboarding/newcomer-restock.js', 'the beginner queue, stamped from templates'],
-  ['modules/copy-desk/routes/copy-desk.js', 'copy-change proposals'],
   ['modules/lifecycle/kickoff-seed.js', "the founder's first board, on an instance with no goals at all"],
   ['modules/lifecycle/cascade.js', 'a follow-up off a parent task that is itself goal-less'],
 ];
 
-test('exactly four vectors opt in, and each says why', () => {
+test('exactly three vectors opt in, and each says why', () => {
   for (const [file, why] of OPT_INS) {
     const body = src(file);
     assert.match(body, /allowCatchAll/, `${file} should opt in (${why})`);
@@ -127,6 +126,17 @@ test('exactly four vectors opt in, and each says why', () => {
   }
 });
 
+// task 1004819: studio work names its home instead of the catch-all. Each of the
+// three studio create vectors passes artistReview, which lands it in the
+// version's artist review goal; none of them opts into the catch-all any more.
+test('the three studio vectors land in the artist review goal, not the catch-all', () => {
+  for (const file of ['modules/copy-desk/routes/copy-desk.js', 'modules/lifecycle/page-tweak-claim.js', 'modules/lifecycle/page-tweak-write.js']) {
+    const body = src(file);
+    assert.match(body, /artistReview: true/, `${file} should name the artist review goal`);
+    assert.equal(/allowCatchAll/.test(body), false, `${file} must not opt into the catch-all`);
+  }
+});
+
 test('cascade opts in ONLY when inheritance actually failed', () => {
   // The others opt in unconditionally because they have no goal to name at all.
   // A cascade normally inherits its parent's goal and must keep doing so — the