@bongos/core 1.21.163 → 1.21.165

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/page_notes_panel.mjs

@@ -1,10 +1,10 @@
 // tests/page_notes_panel.mjs — the hall side of the artist's page feedback doc
-// (task 1004496): the palette tool craft-mode.js puts in the top bar, and the
-// reader in page-notes.js. The server half is tests/page_notes.mjs.
+// (task 1004496): the docked review panel craft-mode.js puts at the right edge
+// in Artistry (task 1004771: no top-bar button), and the reader in page-notes.js. The server half is tests/page_notes.mjs.
 //
-// Runs the REAL craft-mode.js over a small DOM: the palette shows in Artistry
-// alone and leaves when the mode changes, pressing it loads page-notes.js once
-// (same ?v as craft-mode.js) and a ?note= link opens the doc in any mode. Then
+// Runs the REAL craft-mode.js over a small DOM: the panel docks in Artistry
+// alone and closes when the mode changes, page-notes.js loads once (same ?v as
+// craft-mode.js) and a ?note= link opens the doc in any mode. Then
 // the REAL page-notes.js reader: it escapes the doc and shows only this module's
 // own images, which is what keeps a doc from pulling a picture off another site.
 import assert from 'node:assert/strict';
@@ -63,7 +63,7 @@ function boot({ session = {}, search = '' } = {}) {
   // "Loading" page-notes.js: record the tag, then define the API it would define.
   head.onAppend = (tag) => {
     loaded.push(tag.src);
-    window.OTBPageNotes = { open: () => opened.push('open'), openNote: (id) => opened.push('note ' + id) };
+    window.OTBPageNotes = { open: () => opened.push('open'), openNote: (id) => opened.push('note ' + id), dock: () => opened.push('dock'), close: () => opened.push('close') };
     tag.onload();
   };
   const sandbox = { window, document, Promise, CustomEvent: class { constructor(t, i) { this.type = t; Object.assign(this, i); } } };
@@ -74,36 +74,31 @@ function boot({ session = {}, search = '' } = {}) {
 }
 const flush = () => new Promise((r) => setTimeout(r, 0));
 
-test('THE PALETTE: in the top bar in Artistry alone, right before the switch, and gone when the mode changes', () => {
+test('THE PANEL: docked at the edge in Artistry alone, with no top-bar button, and closed when the mode changes', async () => {
   const p = boot({ session: { 'hall-craft': 'artistry' } });
-  assert.deepEqual(p.tools().map((t) => t.id), ['craft-tool-palette', 'craft-tool-paintbrush'], 'the palette, then the paintbrush (task 1004497)');
-  // Task 1004686: the palette sits in its split pill (Review + the review-mode chevron).
-  const pill = p.tools()[0].parentNode;
-  assert.equal(pill.id, 'craft-review', 'the palette rides the Review split pill');
-  assert.equal(pill.nextSibling, p.tools()[1], 'the palette comes first');
-  assert.equal(p.tools()[1].nextSibling, p.sw, 'and the pair sits right before the mode switch');
-  assert.equal(p.tools()[0].getAttribute('aria-label'), 'Artist review: write feedback on this page', 'one name with the public site\'s button (task 1004499)');
-  for (const m of ['building', 'governing']) {
-    p.craft.choose(m);
-    assert.equal(p.tools().length, 0, `no palette in ${m}`);
-  }
+  await flush();
+  assert.deepEqual(p.tools().map((t) => t.id), ['craft-tool-paintbrush'], 'the top bar keeps Edit words alone (task 1004771)');
+  assert.equal(p.tools()[0].nextSibling, p.sw, 'right before the mode switch');
+  assert.deepEqual(p.opened, ['dock'], 'the review panel docks instead');
+  for (const m of ['building', 'governing']) p.craft.choose(m);
+  assert.deepEqual(p.opened, ['dock', 'close', 'close'], 'and leaves with Artistry');
   p.craft.choose('ideating');
-  assert.deepEqual(p.tools().map((t) => t.id), ['craft-tool-lightbulb'], 'Ideating swaps them for its lightbulb alone (task 1004498)');
-  p.craft.choose('artistry');
+  assert.deepEqual(p.tools().map((t) => t.id), ['craft-tool-lightbulb'], 'Ideating shows its lightbulb alone (task 1004498)');
   p.craft.choose('artistry');
-  assert.equal(p.tools().length, 2, 'choosing Artistry twice draws one palette and one paintbrush');
-  assert.equal(boot().tools().length, 0, 'and none with no mode at all');
+  await flush();
+  assert.equal(p.opened.filter((x) => x === 'dock').length, 2, 'back in Artistry it docks again');
+  const none = boot();
+  await flush();
+  assert.equal(none.tools().length, 0, 'no tools with no mode at all');
+  assert.deepEqual(none.loaded, [], 'and nothing loads');
 });
 
-test('pressing it loads page-notes.js once, at the same version as craft-mode.js, and opens it', async () => {
+test('the panel script loads once, at the same version as craft-mode.js', async () => {
   const p = boot({ session: { 'hall-craft': 'artistry' } });
-  assert.deepEqual(p.loaded, [], 'nothing loads until the palette is pressed');
-  p.tools()[0].click();
   await flush();
-  p.tools()[0].click();
+  p.craft.choose('artistry');
   await flush();
   assert.deepEqual(p.loaded, ['/builders/page-notes.js?v=2026-10-04-test']);
-  assert.deepEqual(p.opened, ['open', 'open']);
 });
 
 test('a ?note= link opens that doc on arrival, in any mode', async () => {
@@ -152,6 +147,145 @@ test('colours live in the sheets, and the panel and tool are styled there', () =
   // the hall pulls it in through style.css, ahead of every rule.
   const pn = fs.readFileSync(path.join(HALL, 'page-notes.css'), 'utf8');
   for (const sel of ['.pn {', '.pn__panel {', '.pn__text {', '.pn-doc__img {']) assert.ok(pn.includes(sel) && !css.includes(sel), sel);
+  // Task 1004771: the docked, scrimless look is the review panel's alone
+  // (.pn--dock). The lightbulb rides plain .pn and keeps its scrim and its
+  // scroll lock, so docking the review panel cannot quietly change it.
+  assert.match(pn, /html\.pn-open \{ overflow: hidden; \}/, 'the lightbulb keeps its scroll lock');
+  assert.match(pn, /\.pn \{[^}]*inset: 0;[^}]*background: var\(--pn-scrim\);/, 'and its scrim');
+  assert.match(pn, /\.pn\.pn--dock \{[^}]*background: none;/, 'the docked review panel drops both');
+  assert.match(NOTES, /sheet\.className = docked \? 'pn pn--dock' : 'pn';/, 'and only a docked review panel wears it');
+  const bulb = fs.readFileSync(path.join(HALL, 'lightbulb.js'), 'utf8');
+  assert.doesNotMatch(bulb, /pn--dock/, 'the lightbulb does not');
   const at = css.indexOf('@import url("page-notes.css");');
   assert.ok(at !== -1 && at < css.indexOf('{'), 'style.css imports the sheet before any rule');
 });
+
+// ---------- the docked panel, REAL page-notes.js (task 1004771) ----------
+// A small DOM that runs the real sheet: querySelector hands back one cached
+// fake per selector, so the tab, the X and the mode row are real listeners.
+function dockedPanel({ reviewing = null, opened = false } = {}) {
+  const calls = [];
+  let sheet = null;
+  const fake = (name) => {
+    const attrs = {}, listeners = {}, classes = new Set();
+    const kids = {};
+    const el = {
+      name, innerHTML: '', parentNode: null, id: '', className: '',
+      setAttribute(k, v) { attrs[k] = String(v); }, getAttribute(k) { return k in attrs ? attrs[k] : null; },
+      hasAttribute(k) { return k in attrs; }, removeAttribute(k) { delete attrs[k]; },
+      classList: { add: (c) => classes.add(c), remove: (c) => classes.delete(c), contains: (c) => classes.has(c),
+        toggle: (c, on) => { if (on === undefined) on = !classes.has(c); if (on) classes.add(c); else classes.delete(c); return on; } },
+      addEventListener(t, fn) { (listeners[t] ||= []).push(fn); },
+      fire(t, ev = {}) { (listeners[t] || []).forEach((fn) => fn({ target: el, preventDefault() {}, ...ev })); },
+      querySelector(sel) { return (kids[sel] ||= Object.assign(fake(sel), { parentNode: el })); },
+      querySelectorAll() { return []; },
+      contains(n) { for (let x = n; x; x = x.parentNode) if (x === el) return true; return false; },
+      focus() { document.activeElement = el; },
+    };
+    return el;
+  };
+  const body = fake('body');
+  body.appendChild = (c) => { c.parentNode = body; return c; };
+  body.removeChild = (c) => { c.parentNode = null; return c; };
+  body.dataset = { page: 'studio', pageTitle: 'Studio' };
+  const docKeys = [];
+  const document = {
+    body, activeElement: null, title: 'Studio — hall', documentElement: fake('html'),
+    createElement: () => (sheet = fake('div')),
+    addEventListener: (t, fn) => { if (t === 'keydown') docKeys.push(fn); },
+    removeEventListener() {},
+  };
+  const fetch = (url, opts) => {
+    calls.push(opts.method + ' ' + url);
+    return Promise.resolve({ ok: true, json: () => Promise.resolve({ note: { id: 9, status: 'draft', body_md: '' }, images: [], notes: [] }) });
+  };
+  const craft = {
+    reviewing: () => reviewing,
+    review: (id) => { reviewing = id; calls.push('review ' + id); },
+    stopReview: () => { reviewing = null; calls.push('stop'); },
+    experiences: () => [{ id: 'ideating', label: 'Ideator experience', short: 'Ideating' }, { id: 'building', label: 'Building experience', short: 'Building' }],
+    iconHtml: () => '<svg></svg>',
+  };
+  const window = { location: { pathname: '/studio' }, OTBCraftMode: craft };
+  const sandbox = { window, document, fetch, setTimeout, clearTimeout, Promise };
+  vm.createContext(sandbox);
+  vm.runInContext(NOTES, sandbox, { filename: 'page-notes.js' });
+  const api = window.OTBPageNotes;
+  if (opened) api.open(); else api.dock();
+  const press = (attr, value = '') => {
+    const btn = fake('button');
+    btn.setAttribute(attr, value);
+    sheet.fire('click', { target: { closest: () => btn } });
+  };
+  return { api, calls, document, docKeys, body, press, html: document.documentElement, get sheet() { return sheet; }, collapsed: () => sheet.classList.contains('pn--collapsed') };
+}
+
+test('DOCKED: it waits collapsed behind its tab and asks for no draft until it is first shown', async () => {
+  const p = dockedPanel();
+  await flush();
+  assert.ok(p.collapsed(), 'tucked away on arrival');
+  assert.equal(p.sheet.parentNode, p.body, 'but on the page, so its tab shows');
+  assert.deepEqual(p.calls, [], 'no request while nobody has looked');
+  p.sheet.querySelector('[data-pn-tab]').fire('pointerenter', { pointerType: 'mouse' });
+  await flush();
+  assert.ok(!p.collapsed(), 'a mouse on the tab opens it');
+  assert.ok(p.calls.some((c) => /^POST /.test(c)), 'and the draft opens the first time it is shown');
+  const drafts = p.calls.filter((c) => /^POST /.test(c)).length;
+  p.sheet.fire('pointerleave', { pointerType: 'mouse' });
+  assert.ok(p.collapsed(), 'leaving the panel for the page tucks it away');
+  p.sheet.querySelector('[data-pn-tab]').fire('pointerenter', { pointerType: 'mouse' });
+  await flush();
+  assert.equal(p.calls.filter((c) => /^POST /.test(c)).length, drafts, 'showing it again opens no second draft');
+});
+
+test('DOCKED: a touch never peeks, the tab click toggles, Escape and the X tuck it away and keep the tab', async () => {
+  const p = dockedPanel();
+  p.sheet.querySelector('[data-pn-tab]').fire('pointerenter', { pointerType: 'touch' });
+  assert.ok(p.collapsed(), 'a touch is not a hover');
+  p.press('data-pn-tab');
+  await flush();
+  assert.ok(!p.collapsed(), 'the tab click opens it (touch and keyboard)');
+  assert.equal(p.sheet.querySelector('[data-pn-tab]').getAttribute('aria-expanded'), 'true');
+  p.sheet.querySelector('[data-pn-close]').focus();
+  p.docKeys.forEach((fn) => fn({ key: 'Escape', preventDefault() {} }));
+  assert.ok(p.collapsed(), 'Escape inside the panel tucks it away');
+  assert.equal(p.sheet.querySelector('[data-pn-tab]').getAttribute('aria-expanded'), 'false');
+  p.press('data-pn-tab');
+  p.press('data-pn-close');
+  assert.ok(p.collapsed(), 'docked, the X tucks it away too');
+  assert.equal(p.sheet.parentNode, p.body, 'and leaves the tab on the page, the only way back in');
+  p.api.close();
+  assert.equal(p.sheet.parentNode, null, 'leaving Artistry (close) is what removes it');
+});
+
+test('THE MODE ROW names each mode in the mode switch word and starts a review on a press', () => {
+  const p = dockedPanel();
+  assert.match(p.sheet.innerHTML, /<span>Ideating<\/span>/, 'the switch says Ideating, so the row does');
+  assert.doesNotMatch(p.sheet.innerHTML, />Ideator</);
+  assert.doesNotMatch(p.sheet.innerHTML, /Stop reviewing/, 'no way out of a review that has not started');
+  p.press('data-pn-mode', 'building');
+  assert.ok(p.calls.includes('review building'));
+  assert.match(p.sheet.querySelector('#pn-modes').innerHTML, /data-pn-mode="building" aria-pressed="true"/, 'the row repaints with the live one pressed');
+  assert.match(p.sheet.querySelector('#pn-modes').innerHTML, /Stop reviewing/);
+  p.press('data-pn-mode', '');
+  assert.ok(p.calls.includes('stop'), 'Stop reviewing ends it');
+});
+
+test('OPENED, not docked (the public site Artist review button): the modal sheet it always was', async () => {
+  const p = dockedPanel({ opened: true });
+  await flush();
+  assert.equal(p.sheet.className, 'pn', 'no docked look: the scrim and full-viewport sheet stay');
+  assert.ok(p.html.classList.contains('pn-open'), 'the page behind is scroll-locked');
+  assert.match(p.sheet.innerHTML, /role="dialog" aria-modal="true"/);
+  assert.doesNotMatch(p.sheet.innerHTML, /data-pn-tab/, 'no tab');
+  assert.ok(p.calls.some((c) => /^POST /.test(c)), 'the draft opens straight away');
+  p.sheet.fire('pointerleave', { pointerType: 'mouse' });
+  assert.ok(!p.collapsed(), 'a pointer leaving does not tuck a modal sheet');
+  p.docKeys.forEach((fn) => fn({ key: 'Escape', preventDefault() {} }));
+  assert.equal(p.sheet.parentNode, null, 'Escape closes it');
+  assert.ok(!p.html.classList.contains('pn-open'), 'and lifts the scroll lock');
+  const q = dockedPanel({ opened: true });
+  const s = q.sheet;
+  s.fire('click', { target: s });
+  assert.equal(s.parentNode, null, 'a click on the scrim closes it');
+});

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();