@bongos/core 1.21.163 → 1.21.164

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.163",
+  "version": "1.21.164",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -10020,5 +10020,19 @@
       "id": "1004773",
       "text": "The Private option on the account page now opens with the artist line \"you are a ninja.\", and still tells people Private hides their page from everyone, them included."
     }
+  ],
+  "1.21.164": [
+    {
+      "id": "1004772",
+      "text": "Promoting an idea from the home page's Triage button no longer fails with \"discipline was not supplied\". The Promote form now has a Craft choice (Engineer by default), so every promoted idea becomes a task."
+    },
+    {
+      "id": "1004775",
+      "text": "Approved page tweaks now land on their own. When two rounds were applied from the same main, the second used to hit a conflict in the page readings file and wait for a person; that file now merges page by page, so the second r"
+    },
+    {
+      "id": "1004774",
+      "text": "Home got the owner's reshuffle: a slimmer banner with the version's progress bar under it; your picture and rank at the top right, opening on hover into your standing card with a View full profile link; every Needs-attention s"
+    }
   ]
 }

package/scripts/gds/copy-apply.js

@@ -458,17 +458,73 @@ function applyBatchToSources({ batch, registry, readSource }) {
   return { applied: applied.sort(byOrder).map(({ order, ...rest }) => rest), refused, sources };
 }
 
+// findPinningTests({ applied, listTests, readFile }) -> [{ key, tests: [rel…] }]
+//
+// Task 1004775. A test that asserts a line's OLD words verbatim goes red the
+// moment the round lands, which used to surface only in CI, after the artist had
+// approved, and needed a person. So at APPLY time every applied line's old text is
+// searched for in the test files (tests/ and every module's own tests folder), and each test that
+// still carries it is named in the applied block and shown in the Approval queue.
+// Nothing is edited: a test may be guarding what the words MEAN, and only a person
+// can tell that apart from a test that pins the wording alone.
+//
+// The needle is the line's old text; where it has {…} holes, its longest literal
+// run between them, and a needle under MIN_PIN_NEEDLE characters is skipped (a
+// two-word label matches half the suite and would name nothing useful).
+const MIN_PIN_NEEDLE = 12;
+const PIN_TEST_RE = /\.(mjs|cjs|js)$/;
+
+function pinNeedle(text) {
+  const runs = String(text == null ? '' : text).split('{…}').map((s) => s.trim());
+  const longest = runs.reduce((a, b) => (b.length > a.length ? b : a), '');
+  return longest.length >= MIN_PIN_NEEDLE ? longest : null;
+}
+
+function listTestFiles({ root = REPO_ROOT, fsImpl = fs } = {}) {
+  const out = [];
+  const walk = (rel) => {
+    let ents;
+    try { ents = fsImpl.readdirSync(path.join(root, rel), { withFileTypes: true }); } catch { return; }
+    for (const e of ents) {
+      const r = `${rel}/${e.name}`;
+      if (e.isDirectory()) { if (e.name !== 'node_modules' && e.name !== 'fixtures') walk(r); } else if (PIN_TEST_RE.test(e.name)) out.push(r);
+    }
+  };
+  walk('tests');
+  let mods = [];
+  try { mods = fsImpl.readdirSync(path.join(root, 'modules'), { withFileTypes: true }); } catch { mods = []; }
+  for (const m of mods) if (m.isDirectory()) walk(`modules/${m.name}/tests`);
+  return out.sort();
+}
+
+function findPinningTests({ applied, listTests = listTestFiles, readFile = (rel) => fs.readFileSync(path.join(REPO_ROOT, rel), 'utf8') }) {
+  const wants = (applied || []).map((a) => ({ key: a.key, needle: pinNeedle(a.before) })).filter((w) => w.needle);
+  if (!wants.length) return [];
+  const hits = new Map();
+  for (const rel of listTests()) {
+    let src;
+    try { src = readFile(rel); } catch { continue; }
+    for (const w of wants) {
+      if (!src.includes(w.needle)) continue;
+      if (!hits.has(w.key)) hits.set(w.key, []);
+      hits.get(w.key).push(rel);
+    }
+  }
+  return wants.filter((w) => hits.has(w.key)).map((w) => ({ key: w.key, tests: hits.get(w.key) }));
+}
+
 // The ```page-tweak-applied``` block's content, from the page's NEW reading.
 // lines_after is the non-shared lines' texts: shared shell lines are left out of
 // drift on both sides (D8, builder pick 7), so they must be left out here too or
 // every one of them would read as "removed" on the next drift check.
-function appliedBlockFor({ pageId, readingPage, refused, appliedAt }) {
+function appliedBlockFor({ pageId, readingPage, refused, appliedAt, pinnedTests = [] }) {
   return {
     page_id: pageId,
     applied_at: appliedAt,
     reading_hash_after: readingPage ? readingPage.reading_hash : null,
     lines_after: readingPage ? (readingPage.lines || []).filter((l) => l && l.placement !== 'shared').map((l) => String(l.text)) : [],
     refused: (refused || []).map((x) => ({ key: x.key, code: x.code })),
+    ...(pinnedTests && pinnedTests.length ? { pinned_tests: pinnedTests.map((p) => ({ key: p.key, tests: p.tests.slice() })) } : {}),
   };
 }
 
@@ -564,7 +620,10 @@ async function batchMain({ taskId, batchFile, dryRun, pageId = null, now = () =>
     return 4;
   }
   const readingPage = (deps.readingFor || ((id) => readingFor(id, { readFile })))(batch.page_id);
-  const block = appliedBlockFor({ pageId: batch.page_id, readingPage, refused: result.refused, appliedAt: now() });
+  const oldText = new Map(batch.lines.map((l) => [l.key, l.before]));
+  const pinnedTests = (deps.findPinningTests || findPinningTests)({ applied: result.applied.map((a) => ({ key: a.key, before: oldText.get(a.key) })) });
+  for (const p of pinnedTests) log(`  ${p.key} the old words are still asserted by: ${p.tests.join(', ')} (update the test or it fails once this lands)`);
+  const block = appliedBlockFor({ pageId: batch.page_id, readingPage, refused: result.refused, appliedAt: now(), pinnedTests });
   if (batchFile) {
     log('copy-apply --batch: the page-tweak-applied block (a --batch-file run writes no task):');
     log(pages.composeAppliedBlock(block));
@@ -684,6 +743,10 @@ module.exports = {
   applyBatchToSources,
   appliedBlockFor,
   batchMain,
+  // task 1004775: tests that still assert a rewritten line's old words.
+  findPinningTests,
+  listTestFiles,
+  pinNeedle,
   surfaceRootFor,
   checkPatchPath,
   locateOccurrence,

package/scripts/gds/git-merge-regen.js

@@ -115,6 +115,8 @@ const REGENERABLE = new Set([
   'docs/session-log-index.md',
   'docs/copy-inventory.md',
   'docs/copy-registry.json',
+  // task 1004775: merged per page (page-reader.js mergeReadingDocs), see the rule below.
+  'docs/page-readings.json',
   ...G.NESTED_DIRS.map((d) => `${d}/CLAUDE.md`),
   ...API_DOC_FILES,
   ...API_CLIENT_FILES,
@@ -170,6 +172,18 @@ function regenerateResolved(relpath, { base = '', ours = '', theirs = '' } = {})
   if (relpath === 'docs/copy-registry.json') {
     return { content: `${JSON.stringify(CI.buildRegistry(), null, 2)}\n`, ok: true };
   }
+  // docs/page-readings.json (task 1004775): one entry per page, and a re-read needs a
+  // browser no merge has. Two approved page-tweak rounds re-read DIFFERENT pages and
+  // both rewrite the top counts line, so every pair conflicted and the second round
+  // stranded for a person. Merge it per page from the three sides and recompute the
+  // counts (page-reader.js mergeReadingDocs). Unlike the scans above it reads the
+  // merge sides, not the tree, so it is not provisional; a page BOTH sides re-read
+  // differently is a real conflict and stays one.
+  if (relpath === 'docs/page-readings.json') {
+    const PR = require('./page-reader');
+    const m = PR.mergeReadingDocs({ base, ours, theirs });
+    return m.ok ? { content: m.content, ok: true } : { content: null, ok: false };
+  }
   if (relpath === 'docs/copy-inventory.md') {
     return { content: CI.renderReport(CI.buildRegistry()), ok: true };
   }

package/scripts/gds/page-reader.js

@@ -600,6 +600,50 @@ function mergeReadings(inventory, previous, fresh) {
   return inventory.pages.map((p) => byId.get(p.id)).filter(Boolean);
 }
 
+// mergeReadingDocs({ base, ours, theirs }) -> { ok, content, conflicted }
+//
+// The merge rule for docs/page-readings.json (task 1004775). Two approved page
+// tweak rounds branched from the same main each re-read THEIR page, and both
+// rewrite the top `counts` line — so git conflicts on every pair, and the second
+// round stranded as unresolvable_conflict until a person merged it by hand. A
+// re-read needs a browser, which a merge never has, but it does not need one: the
+// file is one entry per page, so the merge is per page. A page only one side
+// changed takes that side's reading; a page both changed the same way takes it; a
+// page both changed DIFFERENTLY is a real conflict (two rounds re-read one page —
+// their source files conflict too) and is named, never guessed. The summary counts
+// are recomputed from the merged pages and the whole file re-serialized, so the
+// result is byte-for-byte what the reader itself would write for those pages.
+// Pages keep ours' order; a page only theirs has goes where theirs had it.
+function mergeReadingDocs({ base, ours, theirs }) {
+  const parse = (s) => { try { return s && String(s).trim() ? JSON.parse(s) : { pages: [] }; } catch { return null; } };
+  const b = parse(base), o = parse(ours), t = parse(theirs);
+  if (!b || !o || !t) return { ok: false, content: null, conflicted: ['(unreadable json)'] };
+  const map = (d) => new Map((d.pages || []).map((p) => [p.id, p]));
+  const B = map(b), O = map(o), T = map(t);
+  const same = (x, y) => JSON.stringify(x === undefined ? null : x) === JSON.stringify(y === undefined ? null : y);
+  const order = [...O.keys()];
+  for (const id of T.keys()) {
+    if (order.includes(id)) continue;
+    const at = (t.pages || []).findIndex((p) => p.id === id);
+    const prev = at > 0 ? t.pages[at - 1].id : null;
+    const i = prev ? order.indexOf(prev) : -1;
+    order.splice(i + 1, 0, id);
+  }
+  const pages = [];
+  const conflicted = [];
+  for (const id of order) {
+    const bv = B.get(id), ov = O.get(id), tv = T.get(id);
+    let pick;
+    if (same(ov, tv)) pick = ov;
+    else if (same(ov, bv)) pick = tv;
+    else if (same(tv, bv)) pick = ov;
+    else { conflicted.push(id); continue; }
+    if (pick) pages.push(pick);
+  }
+  if (conflicted.length) return { ok: false, content: null, conflicted };
+  return { ok: true, content: serialize(buildDoc(pages)), conflicted: [] };
+}
+
 function loadPrevious() {
   try { return readJsonFile(READINGS_REL); } catch { return null; }
 }
@@ -671,6 +715,8 @@ module.exports = {
   filesHash, readingHash, buildMatcher, placeText, collectStrings, holeData,
   mergeStates, assembleReading, serialize, buildDoc, checkReadings, planRenders,
   captureInPage, mergeReadings,
+  // task 1004775: the merge driver's per-page rule for docs/page-readings.json.
+  mergeReadingDocs,
   // task 1004322: /tweak renders the page the reader reads, through the same harness.
   startHarness, SURFACE_MODULE, PINNED_CLOCK,
 };

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.163'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.164'; // 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/tests/conflict_resolve.mjs

@@ -591,7 +591,13 @@ test('1003546 every REGENERABLE artifact has a producer, and every producer is i
       .map((p) => [p, 'scripts/gds/gen-api-client.js']),
   ]);
 
+  // task 1004775 — docs/page-readings.json is merged per page FROM THE THREE MERGE
+  // SIDES (page-reader.js mergeReadingDocs), never by scanning the tree, so the
+  // driver's result is already final; its only producer opens a browser, which the
+  // server never has. It is the one REGENERABLE entry with no post-merge generator.
+  const MERGED_FROM_SIDES = new Set(['docs/page-readings.json']);
   for (const p of regen.REGENERABLE) {
+    if (MERGED_FROM_SIDES.has(p)) continue;
     const producer = PRODUCED_BY.get(p);
     assert.ok(producer, `REGENERABLE knows ${p} but this test has no producer for it — name the generator that writes it`);
     assert.ok(

package/tests/hall_approval_queue.mjs

@@ -380,4 +380,20 @@ await test('the dialog fits the viewport at every width: capped by the screen, t
   assert.match(rule('.aq-line__text'), /overflow-wrap: anywhere/, 'a long word breaks inside its column');
 });
 
+// task 1004775: a test the applier found still asserting a line's old words is
+// shown on that line, so the artist knows before approving, not CI after.
+await test('a line whose old words a test still checks says so, through the real composer', () => {
+  const description = [
+    pages.composeBatchBlock({ page_id: 'landing:index', reading_hash: 'h', submitted_at: '2026-09-19T00:00:00Z', lines: [
+      { key: 'L0003', section: 'hero', before: 'AI agents claim tasks and ship the code.', after: 'Agents write the code.', placement: 'placed', file: 'x.html', line: 1, string_id: 'a' },
+    ] }),
+    pages.composeAppliedBlock({ page_id: 'landing:index', applied_at: '2026-09-21T00:00:00Z', reading_hash_after: 'h2', lines_after: ['Agents write the code.'], refused: [], pinned_tests: [{ key: 'L0003', tests: ['tests/landing_page.mjs'] }] }),
+  ].join('\n\n');
+  const tasks = [{ id: 51, status: 'completed', grade_passed: true, description, source_ref: pages.roundSourceRef('landing:index', 1), holder_id: null, artist_id: ME, artist_login: 'me' }];
+  const q = pageStatus.composeApprovals({ inventory: INVENTORY, tasks, builderId: ME, crafts: ['artist'] });
+  const line = q.queue[0].lines[0];
+  assert.deepEqual(line.pinned_by, ['tests/landing_page.mjs']);
+  assert.equal(lib.lineRow(line, 'after').pinned, 'A test still checks the old words: tests/landing_page.mjs. It needs updating when this ships.');
+});
+
 summary();

package/tests/hall_board_world.mjs

@@ -266,7 +266,7 @@ test('the Standing card is the mock\'s: an identity line and a three-row fact le
   assert.match(block[0], /class="home-who"/, 'the identity line');
   assert.match(block[0], /<dt>\$\{escapeHtml\(curLabel\(true\)\)\}<\/dt>/,
     'the currency row takes its label from the branding contract at render time — a data-currency-label attribute is rebranded once at load, before this row exists');
-  for (const label of ['On the board', 'Preferred work']) {
+  for (const label of ['Leaderboard place', 'Preferred work']) {
     assert.match(block[0], new RegExp(`<dt>${label}</dt>`), `the ledger row: ${label}`);
   }
   assert.match(block[0], /: PREFS_EMPTY\}/, 'the empty-preference copy is the one string both Standing surfaces share');
@@ -278,7 +278,8 @@ test('the Standing card is the mock\'s: an identity line and a three-row fact le
 });
 
 test('the system notices are inbox LINES, first in the card, and counted by its refresh()', () => {
-  const mount = goalInboxJs.match(/host\.innerHTML =([\s\S]*?);/);
+  // Anchored on the statement AFTER the markup, so a ';' inside the markup or its comments cannot cut it short.
+  const mount = goalInboxJs.match(/host\.innerHTML =([\s\S]*?);\n    host\.addEventListener/);
   assert.ok(mount, 'the inbox mounts its slices');
   const sys = mount[1].indexOf('id="attention-system"');
   const goals = mount[1].indexOf('id="attention-goals"');
@@ -378,7 +379,7 @@ test('RUN: the greeting names the builder, and the sub-line says how far the ver
   const { api, el } = bootHallRender({ me: ME, progress: PROGRESS, claimable: 5 });
   api.renderGreeting();
   assert.match(el('hall-h1').textContent, /^Good (morning|afternoon|evening), Percy Jackson$/);
-  assert.equal(el('hall-sub').textContent, 'BONGOS-V1 is 75 percent shipped. Five tasks are claimable right now.');
+  assert.equal(el('hall-sub').textContent, 'BONGOS-V1 is 75 percent complete. Five tasks are claimable right now.');
   assert.equal(el('hall-sub').hidden, false);
 });
 
@@ -388,7 +389,7 @@ test('RUN: each half of the sentence renders as its data lands, and the line hid
   assert.equal(none.el('hall-sub').hidden, true, 'nothing to say yet');
   const onlyProgress = bootHallRender({ me: ME, progress: PROGRESS });
   onlyProgress.api.renderGreeting();
-  assert.equal(onlyProgress.el('hall-sub').textContent, 'BONGOS-V1 is 75 percent shipped.');
+  assert.equal(onlyProgress.el('hall-sub').textContent, 'BONGOS-V1 is 75 percent complete.');
   const zero = bootHallRender({ me: ME, progress: PROGRESS, claimable: 0 });
   zero.api.renderGreeting();
   assert.match(zero.el('hall-sub').textContent, /Nothing is claimable right now\.$/);
@@ -409,13 +410,13 @@ test('RUN: the Standing card carries the three facts, the place as "2nd of 4", a
   // written from curLabel(true), not a data-currency-label attribute: brand-apply
   // rebrands those once at load, and this row is stamped after /me answers
   assert.match(html, /<dt>Credits<\/dt><dd>14,441<\/dd>/);
-  assert.match(html, /<dt>On the board<\/dt><dd>2nd of 4<\/dd>/);
+  assert.match(html, /<dt>Leaderboard place<\/dt><dd>2nd of 4<\/dd>/);
   assert.match(html, /<dt>Preferred work<\/dt><dd>Not set yet<\/dd>/, 'the mock\'s copy for an empty preference');
   assert.doesNotMatch(html, /profile__(needs|budget|rebase)/, 'the banners are not in the card');
   const withPrefs = bootHallRender({ me: ME, leaderboard: [] });
   withPrefs.api.renderProfile({ ...ME.builder, preferred_disciplines: ['engineer', 'ui'] });
   assert.match(withPrefs.el('home-standing-body').innerHTML, /<dd>engineer, ui<\/dd>/);
-  assert.match(withPrefs.el('home-standing-body').innerHTML, /<dt>On the board<\/dt><dd>—<\/dd>/, 'no roll yet: a dash, not a wrong place');
+  assert.match(withPrefs.el('home-standing-body').innerHTML, /<dt>Leaderboard place<\/dt><dd>—<\/dd>/, 'no roll yet: a dash, not a wrong place');
 });
 
 test('RUN: the three notices are inbox lines with a kind, a line and — where one exists — a door', () => {

package/tests/home_attention_cards.mjs

@@ -0,0 +1,119 @@
+// tests/home_attention_cards.mjs — the Needs-attention CARDS and their window (task 1004774).
+//
+// WHY. Home's attention inbox became one card per slice, and a click moves the slice itself into a
+// <dialog> so its buttons keep working through the one delegated handler. That is DOM behaviour —
+// moving nodes, the native dialog's open/close, a card derived from a heading — so it runs the REAL
+// goal-inbox.js in a real browser (the ui-design kit's launcher) over stubbed feeds, rather than
+// grepping the source. Skips when the machine has no system Edge or Chrome, as ui_design_kit_fit does.
+import assert from 'node:assert/strict';
+import { test, after } 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 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');
+
+let browser = null;
+try { browser = await lib.launchBrowser(); } catch (e) { if (!(e instanceof lib.NoBrowserError)) throw e; }
+after(() => browser && browser.close());
+
+// Two feeds answer: the blockers queue (2 rows shown of a server total of 7) and the rot feed
+// (1 row, with its timer). Every other feed 404s, which the inbox treats as "nothing here".
+const STUBS = `
+  window.__FEEDS = {
+    '/api/bongos/blockers?limit=5': { blockers: [{ id: 1, title: 'Key needed' }, { id: 2, title: 'Pick a host' }], page: { total: 7 } },
+    '/api/bongos/inbox/rotting': { timer: { rot_days: 30 }, rows: [{ tier: 'task', id: 9, title: 'Old task', status: 'ready', goal_id: 3,
+      verbs: [{ verb: 'water', label: 'Water', path: '/api/bongos/tasks/:id/water' }] }] },
+  };
+  window.BongosClient = { createClient: () => ({ request: async (m, p) => {
+    const d = window.__FEEDS[p];
+    return d ? { ok: true, status: 200, data: d } : { ok: false, status: 404, data: null };
+  } }) };
+  window.OTBKit = { esc: (s) => String(s), fmtAbsDate: () => 'Oct 1' };
+  window.OTBBlockersLib = { blockerFacts: (b) => ({ titleHtml: '<a class="ginbox__goal">' + b.title + '</a>', factsHtml: '', noteHtml: '' }) };
+  window.OTB = {
+    escapeHtml: (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'),
+    toast() {}, rankLabel: (r) => r,
+    contributeHallWidget(w) { window.__widget = w; },
+  };`;
+
+const PAGE = '<!doctype html><html><body><section id="attention-scroll"></section></body></html>';
+
+async function bootInbox() {
+  const ctx = await browser.newContext({ viewport: { width: 1280, height: 800 } });
+  const page = await ctx.newPage();
+  await page.setContent(PAGE);
+  await page.addScriptTag({ content: STUBS });
+  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);
+  return { ctx, page };
+}
+
+const cards = (page) => page.evaluate(() => [...document.querySelectorAll('.attn-card')].map((c) => ({
+  open: c.getAttribute('data-attn-open'),
+  n: c.querySelector('.attn-card__n').textContent,
+  t: c.querySelector('.attn-card__t').textContent,
+  s: c.querySelector('.attn-card__s') ? c.querySelector('.attn-card__s').textContent : null,
+})));
+
+test('one card per non-empty slice, titled from its heading, carrying the SERVER total', { skip: !browser && 'no system Edge or Chrome' }, async () => {
+  const { ctx, page } = await bootInbox();
+  const got = await cards(page);
+  await ctx.close();
+  // Slice order is the card order: blockers sit before rot in the mount.
+  assert.deepEqual(got, [
+    { open: 'attention-blockers', n: '7', t: 'Requires project owner fix', s: null },
+    { open: 'attention-rot', n: '1', t: 'Things not moving', s: 'untouched 30+ days' },
+  ], 'the blockers card says 7 (page.total), not the 2 rows the slice drew; empty slices get no card');
+});
+
+test('a card opens its slice in the window, and the X puts it back', { skip: !browser && 'no system Edge or Chrome' }, async () => {
+  const { ctx, page } = await bootInbox();
+  await page.click('[data-attn-open="attention-rot"]');
+  const opened = await page.evaluate(() => ({
+    open: document.getElementById('attention-dialog').open,
+    title: document.getElementById('attention-dialog-h').textContent,
+    inDialog: !!document.querySelector('#attention-dialog-body > #attention-rot'),
+    verb: !!document.querySelector('#attention-dialog [data-rot-verb="water"]'),
+  }));
+  assert.deepEqual(opened, { open: true, title: 'Things not moving', inDialog: true, verb: true },
+    'the SAME slice node moved into the dialog, with its action buttons');
+  await page.click('#attention-dialog-x');
+  const closed = await page.evaluate(() => ({
+    open: document.getElementById('attention-dialog').open,
+    back: !!document.querySelector('#attention-slices > #attention-rot'),
+    cards: document.querySelectorAll('.attn-card').length,
+  }));
+  await ctx.close();
+  assert.deepEqual(closed, { open: false, back: true, cards: 2 });
+});
+
+test('closing natively (Escape) also returns the slice, so a reopen still finds it', { skip: !browser && 'no system Edge or Chrome' }, async () => {
+  const { ctx, page } = await bootInbox();
+  await page.click('[data-attn-open="attention-blockers"]');
+  await page.keyboard.press('Escape');
+  await page.waitForFunction(() => !document.getElementById('attention-dialog').open);
+  const back = await page.evaluate(() => !!document.querySelector('#attention-slices > #attention-blockers'));
+  assert.equal(back, true, 'the dialog close event moves the slice home');
+  await page.click('[data-attn-open="attention-blockers"]');
+  const rows = await page.evaluate(() => document.querySelectorAll('#attention-dialog-body .ginbox__item').length);
+  await ctx.close();
+  assert.equal(rows, 2, 'the reopened window shows the slice rows again');
+});
+
+test('a window whose slice empties while open closes itself', { skip: !browser && 'no system Edge or Chrome' }, async () => {
+  const { ctx, page } = await bootInbox();
+  await page.click('[data-attn-open="attention-rot"]');
+  await page.evaluate(() => { document.getElementById('attention-rot').innerHTML = ''; window.OTBAttention.refresh(); });
+  const state = await page.evaluate(() => ({
+    open: document.getElementById('attention-dialog').open,
+    cards: [...document.querySelectorAll('.attn-card')].map((c) => c.getAttribute('data-attn-open')),
+  }));
+  await ctx.close();
+  assert.deepEqual(state, { open: false, cards: ['attention-blockers'] });
+});

package/tests/home_bounded_reads.mjs

@@ -60,7 +60,7 @@ await test('no Home read downloads a feed and slices it in the browser', () => {
 });
 
 await test('the two cards ask for exactly the rows they draw', () => {
-  assert.match(BUILDERS_JS, /\$\{API\}\/tasks\/claimable\?limit=2/, 'Next up draws two rows');
+  assert.match(BUILDERS_JS, /\$\{API\}\/tasks\/claimable\?limit=5/, 'Next up draws five rows, level with Recently shipped');
   assert.match(BUILDERS_JS, /\$\{API\}\/inbox\?limit=5/, 'the triage card draws five');
   // …and no longer re-slices what came back.
   const src = noComments(BUILDERS_JS);

package/tests/promote_goal_id.mjs

@@ -227,6 +227,14 @@ await test('BEHAVIOUR: a failed create throws with the status, it does not retur
 // STATIC — the surfaces a unit test cannot invoke (browser DOM strings, docs).
 // ==========================================================================
 
+// The hall promote once sent no discipline, and an idea whose wording names no
+// craft was refused "discipline was not supplied and could not be inferred".
+await test('BOTH PATHS: the hall promote payload always sends a discipline', () => {
+  assert.match(HALL, /discipline: \(form\.discipline && form\.discipline\.value\) \|\| 'engineer'/,
+    'hall: discipline must reach the create payload, defaulting to engineer');
+  assert.match(HALL, /<select name="discipline">/, 'hall: the promote form offers a Craft picker');
+});
+
 // ---- 4. both paths send goal_id -------------------------------------------
 
 await test('BOTH PATHS: the CLI createTask and the hall payload each send goal_id', () => {

package/tests/tweak_batch_apply.mjs

@@ -198,6 +198,8 @@ function harness({ batch, source = 'page-tweak', registryOverride = null, reread
     registry: REG,
     regenerateRegistry: () => ({ reg: registryOverride || registryOver(Object.fromEntries(Object.keys(tree).map((rel) => [rel, files.get(abs(rel))]))) }),
     reread: () => (rereadOk ? { ok: true } : { ok: false, code: 'no_browser' }),
+    // Hermetic by default: the real finder scans the repo's own tests (task 1004775's case below injects a tree).
+    findPinningTests: () => [],
     readingFor: () => ({ reading_hash: 'r-after', lines: [{ key: 'L0001', text: 'Skip to content', placement: 'shared' }, { key: 'L0002', text: 'Welcome to your studio', placement: 'placed' }] }),
     api: async (method, url, body) => {
       calls.push({ method, url, body });
@@ -299,4 +301,42 @@ await test("--page: the round's own page applies as usual", async () => {
   assert.ok(h.writes.length > 0);
 });
 
+// task 1004775: a test that asserts a rewritten line's OLD words verbatim is named
+// in the applied block at apply time, not discovered by CI after the artist approved.
+await test('copy-apply names a test that pins a line\'s old text in the applied block', async () => {
+  const testTree = {
+    'tests/landing_fixture.mjs': "assert.match(html, /x/);\nassert.ok(html.includes('Take a page and rewrite every word of it.'));\n",
+    'modules/copy-desk/tests/other.mjs': "assert.ok(s.includes('nothing relevant here'));\n",
+    'tests/short_label.mjs': "assert.ok(s.includes('Take next'));\n",
+  };
+  const h = harness({ batch: BATCH() });
+  h.deps.findPinningTests = (args) => apply.findPinningTests({ ...args, listTests: () => Object.keys(testTree), readFile: (rel) => testTree[rel] });
+  const logs = [];
+  h.deps.log = (s) => logs.push(s);
+  const code = await apply.batchMain({ taskId: '5001', now: () => 't' }, h.deps);
+  assert.equal(code, 0);
+  const applied = pages.parseAppliedBlock(h.calls.find((c) => c.method === 'PATCH').body.description);
+  assert.deepEqual(applied.applied.pinned_tests, [{ key: 'L0002', tests: ['tests/landing_fixture.mjs'] }],
+    'the pinning test is named against its line; a short label (Take next) is too common to search for');
+  assert.ok(logs.some((l) => /L0002 the old words are still asserted by: tests\/landing_fixture\.mjs/.test(l)), 'and said on the terminal');
+  assert.equal(testTree['tests/landing_fixture.mjs'].includes('rewrite every word'), true, 'the test itself is never edited');
+});
+
+await test('a hole in the old text searches its longest literal run', () => {
+  assert.equal(apply.pinNeedle('You have {…} pages waiting for review'), 'pages waiting for review');
+  assert.equal(apply.pinNeedle('Take next'), null);
+  const hits = apply.findPinningTests({
+    applied: [{ key: 'L0003', before: 'You have {…} pages waiting for review' }],
+    listTests: () => ['tests/a.mjs'], readFile: () => '`You have ${n} pages waiting for review`',
+  });
+  assert.deepEqual(hits, [{ key: 'L0003', tests: ['tests/a.mjs'] }]);
+});
+
+await test('the real test lister walks tests/ and modules/*/tests/, skipping fixtures', () => {
+  const list = apply.listTestFiles();
+  assert.ok(list.includes('tests/tweak_batch_apply.mjs'));
+  assert.ok(list.includes('modules/copy-desk/tests/copy_page_status.mjs'));
+  assert.ok(!list.some((f) => f.includes('/fixtures/')));
+});
+
 summary();