@bongos/core 1.19.1066 → 1.19.1068

package/tests/hall_studio_home.mjs

@@ -0,0 +1,429 @@
+// tests/hall_studio_home.mjs — the studio home (task 1003971 / BV2.TW16, ADR
+// 0341 D2, D5, D8 and D11; docs/design/mocks/tweak-mode/Main.dc.html).
+//
+// Two halves. The pure rules (studio-lib.js) run over what the REAL composers
+// (modules/copy-desk/page-status.js) answer for a small ledger, so the words the
+// studio shows are tested on the routes' own shapes, never on a literal of them.
+// Then the REAL page: studio.html's own body in a mini-DOM, with the real
+// dom-utils.js, tweak-editor-lib.js, studio-lib.js and studio.js in a vm over a
+// stub client, driven the way an artist would: the tally, Resume, the three
+// panels, "take it", and the studio's own words typed over in place.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { makeRunner, makeEl, parseInto, walk, settle } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules/hall-ui/public');
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+const lib = require('../modules/hall-ui/public/studio-lib.js');
+const pages = require('../modules/copy-desk/pages.js');
+const ps = require('../modules/copy-desk/page-status.js');
+
+const { test, summary } = makeRunner();
+
+// ── a small ledger, through the real composers ──────────────────────────────
+const ME = '7';
+const NOW = new Date('2026-09-28T12:00:00.000Z');
+const day = (n) => new Date(NOW.getTime() - n * 86400000).toISOString();
+const INV = {
+  surfaces: [{ id: 'landing' }, { id: 'builders' }, { id: 'status' }],
+  pages: [
+    { id: 'landing:index', surface: 'landing', title: '{{productName}}: {{tagline}}', path: '/', files: [] },
+    { id: 'landing:projects', surface: 'landing', title: '{{productName}} — projects', path: '/projects', files: [] },
+    { id: 'builders:studio', surface: 'builders', title: 'Studio', path: '/studio', files: [] },
+    { id: 'builders:work', surface: 'builders', title: 'Tasks', path: '/work', files: [] },
+    { id: 'status:index', surface: 'status', title: 'Status', path: '/', files: [] },
+  ],
+};
+const page = (id) => INV.pages.find((p) => p.id === id);
+const TASKS = [
+  { id: '11', source: 'page-tweak', source_ref: pages.roundSourceRef('landing:index', 1), status: 'shipped', shipped_at: day(9), artist_id: ME, description: pages.roundTaskBody(page('landing:index'), 1) },
+  { id: '12', source: 'page-tweak', source_ref: pages.roundSourceRef('status:index', 1), status: 'shipped', shipped_at: day(2), artist_id: ME, description: pages.roundTaskBody(page('status:index'), 1) },
+  { id: '13', source: 'page-tweak', source_ref: pages.roundSourceRef('landing:index', 2), status: 'active', holder_id: ME, holder_login: 'me', holder_worktree: false, description: pages.roundTaskBody(page('landing:index'), 2) },
+];
+const CREDITS = [
+  { reason: 'tweak.page_approved:11', delta: 30, recorded_at: day(9) },
+  { reason: 'tweak.page_approved:12', delta: 30, recorded_at: day(2) },
+];
+const ASKS = [{ page_id: 'landing:projects', askers: 2, oldest_ask_at: day(3) }];
+const TALLY = ps.composeTally({ builderId: ME, tasks: TASKS, creditRows: CREDITS, now: NOW });
+const PAGES = ps.composePages({ inventory: INV, readings: null, tasks: TASKS });
+const NEXT = ps.composeNext({ inventory: INV, readings: null, tasks: TASKS, asks: ASKS, builderId: ME });
+
+// The studio's own reading (the shape page-reader.js writes): the greeting, the
+// sub-line's template, and a generic holed line that must never win.
+const L = (key, section, text, placement) => ({ key, section, text, placement, file: 'modules/hall-ui/public/studio.html', line: 1, string_id: key });
+const STUDIO_READING = {
+  id: 'builders:studio',
+  reading_hash: 'rs-1',
+  lines: [
+    L('L0001', 'skip link', 'Skip to content', 'shared'),
+    L('L0002', 'Good evening.', 'Good evening.', 'placed'),
+    L('L0003', 'Good evening.', '{…}, on the {…} page, is where you left it. {…} of its {…} lines are yours so far.', 'placed'),
+    L('L0004', 'Good evening.', '{…} of {…}', 'placed'),
+    L('L0005', 'Good evening.', 'Approval queue', 'placed'),
+  ],
+};
+function studioRead({ held = false, draftLines = null } = {}) {
+  let description = pages.roundTaskBody(page('builders:studio'), 1);
+  if (draftLines) {
+    const r = pages.resolveDraft({ readingPage: STUDIO_READING, body: { reading_hash: 'rs-1', lines: draftLines }, savedAt: day(1) });
+    assert.equal(r.ok, true, JSON.stringify(r));
+    description += '\n\n' + pages.composeDraftBlock(r.draft);
+  }
+  const round = held ? { id: 70, status: 'active', holder_id: ME, holder_login: 'me', holder_worktree: false, description } : null;
+  return ps.composeEditor({ page: page('builders:studio'), readingPage: STUDIO_READING, round, builderId: ME });
+}
+const RESUME_READ = { ok: true, counter: { changed: 12, total: 38 } };
+
+// ── the mini-DOM over the page's own markup ─────────────────────────────────
+const HTML = read('studio.html');
+const BODY = /<body[^>]*>([\s\S]*)<\/body>/.exec(HTML)[1].replace(/<script[\s\S]*?<\/script>/g, '');
+const SOURCES = ['dom-utils.js', 'tweak-editor-lib.js', 'studio-lib.js', 'studio.js'].map((f) => [f, read(f)]);
+let boot = null;
+
+function augment(el) {
+  if (el._aug) return el;
+  el._aug = true;
+  const classes = () => String(el.className || '').split(/\s+/).filter(Boolean);
+  el.classList = {
+    add: (c) => { const s = new Set(classes()); s.add(c); el.className = [...s].join(' '); },
+    remove: (c) => { el.className = classes().filter((x) => x !== c).join(' '); },
+    toggle: (c, force) => { const on = force === undefined ? !classes().includes(c) : !!force; if (on) el.classList.add(c); else el.classList.remove(c); return on; },
+    contains: (c) => classes().includes(c),
+  };
+  for (const attr of ['hidden', 'disabled']) {
+    Object.defineProperty(el, attr, { get() { return attr in el.attrs; }, set(v) { if (v) el.attrs[attr] = ''; else delete el.attrs[attr]; }, configurable: true });
+  }
+  Object.defineProperty(el, 'href', { get() { return el.attrs.href || ''; }, set(v) { el.attrs.href = String(v); }, configurable: true });
+  Object.defineProperty(el, 'innerHTML', {
+    get() { return el._html === null ? '' : el._html; },
+    set(v) { el._html = String(v); parseInto(el, el._html); walk(el, (c) => { augment(c); return null; }); },
+    configurable: true,
+  });
+  el.focus = () => { boot.focused = el; };
+  el.blur = () => el.fire('blur', { target: el });
+  return el;
+}
+
+function bootStudio({ answers = {}, signedIn = true } = {}) {
+  const root = augment(makeEl('body', {}));
+  root.innerHTML = BODY;
+  const byId = (id) => walk(root, (c) => (c.id === id ? c : null));
+  const docListeners = {};
+  const requests = [];
+  const htmlEl = augment(makeEl('html', {}));
+  const documentObj = {
+    body: root,
+    documentElement: htmlEl,
+    getElementById: byId,
+    querySelector: (sel) => root.querySelector(sel),
+    querySelectorAll: (sel) => root.querySelectorAll(sel),
+    createElement: (tag) => augment(makeEl(tag, {})),
+    addEventListener: (type, fn) => { (docListeners[type] = docListeners[type] || []).push(fn); },
+    execCommand() {},
+  };
+  const client = {
+    request: async (method, url, body) => {
+      requests.push({ method, url, body });
+      const key = `${method} ${url.replace(/^\/api\/bongos/, '')}`;
+      if (key === 'GET /me') return signedIn ? ok({ builder: { id: ME, display_name: 'Artist A', rank: 'metic' } }) : { ok: false, status: 401, data: {} };
+      const a = answers[key];
+      if (typeof a === 'function') return a(body);
+      if (a) return a;
+      return { status: 404, ok: false, data: { error: { code: 'no_answer', message: key } } };
+    },
+  };
+  const windowObj = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => client },
+    location: { host: 'builders.cloudbongos.com', hostname: 'builders.cloudbongos.com', protocol: 'https:', search: '', pathname: '/studio', assign: (u) => { out.navigated = u; } },
+    localStorage: { getItem: () => null, setItem() {} },
+    addEventListener() {},
+    scrollTo() {},
+  };
+  const sandbox = { window: windowObj, document: documentObj, location: windowObj.location, console, setTimeout, clearTimeout, encodeURIComponent };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  for (const [name, src] of SOURCES) vm.runInContext(src, sandbox, { filename: name });
+  const out = {
+    requests, navigated: null, focused: null, el: byId, html: htmlEl,
+    writes: () => requests.filter((r) => r.method !== 'GET'),
+    click: async (id) => { const el = byId(id); assert.ok(el, `no #${id}`); el.fire('click', { target: el }); await out.settle(); },
+    clickIn: async (overlayId, sel) => {
+      const overlay = byId(overlayId);
+      const target = overlay.querySelector(sel);
+      assert.ok(target, `no ${sel} in #${overlayId}`);
+      overlay.fire('click', { target });
+      await out.settle();
+    },
+    settle: async () => { for (let i = 0; i < 10; i++) await settle(); },
+  };
+  boot = out;
+  return out;
+}
+const ok = (data) => ({ status: 200, ok: true, data });
+const HOME = {
+  'GET /copy-desk/tally': ok(TALLY),
+  'GET /copy-desk/next': ok(NEXT),
+  'GET /copy-desk/pages': ok(PAGES),
+  'GET /copy-desk/pages/landing:index/draft': ok(RESUME_READ),
+};
+
+try {
+  // ── the pure half, over the composers' answers ────────────────────────────
+  await test('the tally reads the composer: credits, pages tweaked, and this week with its sign', () => {
+    assert.deepEqual(lib.tallyParts(TALLY), { credits: '60', pages: '2', week: '+30' });
+    assert.deepEqual(lib.tallyParts({ credits: 0, pages_tweaked: 0, this_week: 0 }), { credits: '0', pages: '0', week: '0' }, 'a quiet week is 0, not +0');
+    assert.equal(lib.tallyParts(null), null);
+  });
+
+  await test('Resume and the sub-line name the held page as the artist reads it, in the artboard\'s words', () => {
+    assert.equal(NEXT.resume.page_id, 'landing:index', 'the composer reports the held round as resume');
+    assert.equal(lib.resumeDetail(NEXT.resume, RESUME_READ.counter), 'Home · landing · 12 of 38 lines');
+    assert.equal(lib.resumeDetail(NEXT.resume, null), 'Home · landing');
+    assert.deepEqual(lib.subParts(NEXT.resume, RESUME_READ.counter),
+      { title: 'Home', surface: 'landing', counted: true, changed: 'Twelve', total: 'thirty-eight' });
+    assert.equal(lib.subParts(null, null), null, 'nothing held: the page\'s own sentence stands');
+    assert.equal(lib.numberWords(0, { capital: true }), 'None');
+    assert.equal(lib.numberWords(75), 'seventy-five');
+    assert.equal(lib.numberWords(120), 'one hundred and twenty');
+    assert.equal(lib.numberWords(1200), '1200');
+  });
+
+  await test('the three details: next up, the approvals count, and the whole count', () => {
+    assert.equal(lib.flowDetail(NEXT), 'next up: Projects — 2 people asked for it');
+    assert.equal(lib.flowDetail({ recommended: null }), 'every page is taken for now');
+    assert.equal(lib.statusDetail(PAGES), '2 of 5 pages tweaked');
+  });
+
+  await test('Artist Review Status: landing, builders hall, status, each N of M, the bar never empty', () => {
+    const rows = lib.surfaceRows(PAGES, 'cloudbongos.com');
+    assert.deepEqual(rows.map((r) => [r.name, r.where, r.count, r.pct]), [
+      ['Landing', 'cloudbongos.com', '1 of 2 tweaked', 50],
+      ['Builders hall', 'where the work happens', '0 of 2 tweaked', 3],
+      ['Status', 'the public dashboard', '1 of 1 tweaked', 100],
+    ]);
+    assert.equal(lib.landingHost('https://cloudbongos.com/', 'builders.x.test'), 'cloudbongos.com', 'the stamped origin wins');
+    assert.equal(lib.landingHost('{{publicOrigin}}', 'builders.x.test'), 'x.test', 'an unstamped token is no address');
+    assert.equal(lib.askedLine(NEXT.asked_pages), '1 page has been asked for. It comes up first in the Tweak/CopyWrite Flow.');
+    assert.equal(lib.askedLine(4), '4 pages have been asked for. They come up first in the Tweak/CopyWrite Flow.');
+    assert.equal(lib.askedLine(0), '');
+  });
+
+  await test('a word on the page finds its own line: the most specific wins, holes alone never match, shared never', () => {
+    const sentence = 'Home, on the landing page, is where you left it. Twelve of its thirty-eight lines are yours so far.';
+    assert.equal(lib.matchLine(sentence, STUDIO_READING.lines).key, 'L0003', 'not the generic "{…} of {…}"');
+    assert.equal(lib.matchLine('Good evening.', STUDIO_READING.lines).key, 'L0002');
+    assert.equal(lib.matchLine('Nine of ten', STUDIO_READING.lines), null, 'a line of holes and one word is no match for a sentence');
+    assert.equal(lib.matchLine('Skip to content', STUDIO_READING.lines), null, 'shell text is not the studio\'s own');
+    assert.equal(lib.matchLine('Something new', STUDIO_READING.lines), null);
+  });
+
+  await test('a refused claim, in words', () => {
+    assert.equal(lib.claimWords('page_held', { holder: { login: 'bob' } }), 'bob is tweaking this page right now.');
+    assert.match(lib.claimWords('not_an_artist', {}), /Only an artist can take a page/);
+    assert.equal(lib.claimWords('page_in_flight', { what_this_means: 'The server says so.' }), 'The server says so.');
+  });
+
+  // ── the real page ─────────────────────────────────────────────────────────
+  await test('the home paints from the four reads: tally, Resume into the editor, the sub-line, the details', async () => {
+    const s = bootStudio({ answers: HOME });
+    await s.settle();
+    assert.equal(s.el('st-tally').hidden, false);
+    assert.deepEqual(['st-tally-credits', 'st-tally-pages', 'st-tally-week'].map((id) => s.el(id).textContent), ['60', '2', '+30']);
+    assert.equal(s.el('st-resume').hidden, false);
+    assert.equal(s.el('st-resume').getAttribute('href'), '/builders/tweak-editor?page=landing:index');
+    assert.equal(s.el('st-resume-detail').textContent, 'Home · landing · 12 of 38 lines');
+    assert.equal(s.el('studio-sub').textContent, 'Home, on the landing page, is where you left it. Twelve of its thirty-eight lines are yours so far.');
+    assert.equal(s.el('st-flow-detail').textContent, 'next up: Projects — 2 people asked for it');
+    assert.equal(s.el('st-status-detail').textContent, '2 of 5 pages tweaked');
+    assert.deepEqual(s.writes(), [], 'opening the studio writes nothing');
+  });
+
+  await test('nothing held: no Resume, and the page\'s own sub-line stands', async () => {
+    const s = bootStudio({ answers: { ...HOME, 'GET /copy-desk/next': ok({ ...NEXT, resume: null }) } });
+    await s.settle();
+    assert.equal(s.el('st-resume').hidden, true);
+    assert.match(s.el('studio-sub').textContent, /^Nothing is on your desk yet\./);
+  });
+
+  await test('signed out: no tally, no reads of the ledger', async () => {
+    const s = bootStudio({ answers: HOME, signedIn: false });
+    await s.settle();
+    assert.equal(s.el('st-tally').hidden, true);
+    assert.equal(s.requests.filter((r) => /copy-desk\/(tally|next|pages)/.test(r.url)).length, 0);
+  });
+
+  await test('the Tweak/CopyWrite Flow: the recommendation, pick another swaps it, take it claims THAT page and opens it', async () => {
+    const s = bootStudio({ answers: { ...HOME, 'POST /copy-desk/pages/builders:studio/claim': ok({ ok: true, outcome: 'created' }) } });
+    await s.settle();
+    await s.click('st-flow');
+    assert.equal(s.el('st-panel').hidden, false);
+    assert.ok(s.html.classList.contains('st-open'));
+    assert.equal(s.el('st-panel-title').textContent, 'Tweak/CopyWrite Flow');
+    const body = () => s.el('st-panel-body').innerHTML;
+    assert.match(body(), /st-next__page">Projects</);
+    assert.match(body(), /landing · 2 people asked for it/);
+    await s.clickIn('st-panel', '[data-pick]');
+    assert.doesNotMatch(body(), /id="st-picks" hidden/, 'the chips open');
+    assert.match(body(), /data-pick-id="builders:studio">Studio · builders hall</);
+    await s.clickIn('st-panel', '[data-pick-id="builders:studio"]');
+    assert.match(body(), /st-next__page">Studio</, 'the picked page is now the one to take');
+    await s.clickIn('st-panel', '[data-take]');
+    assert.deepEqual(s.writes().map((w) => `${w.method} ${w.url}`), ['POST /api/bongos/copy-desk/pages/builders:studio/claim']);
+    assert.equal(s.navigated, '/builders/tweak-editor?page=builders:studio');
+  });
+
+  await test('a refused take stays in the panel and says why', async () => {
+    const s = bootStudio({ answers: { ...HOME, 'POST /copy-desk/pages/landing:projects/claim': { ok: false, status: 409, data: { error: { code: 'page_held', message: 'held', details: { holder: { login: 'bob' } } } } } } });
+    await s.settle();
+    await s.click('st-flow');
+    await s.clickIn('st-panel', '[data-take]');
+    assert.equal(s.navigated, null);
+    const err = s.el('st-take-err');
+    assert.equal(err.hidden, false);
+    assert.match(err.textContent, /is tweaking this page right now/);
+  });
+
+  await test('Artist Review Status: three surface lines, the instance\'s address on landing, the asked line', async () => {
+    const s = bootStudio({ answers: HOME });
+    s.el('hall-main').setAttribute('data-apex', 'https://cloudbongos.com');
+    await s.settle();
+    await s.click('st-status');
+    const body = s.el('st-panel-body').innerHTML;
+    assert.equal(s.el('st-panel-title').textContent, 'Artist Review Status');
+    assert.deepEqual([...body.matchAll(/st-surface__name">([^<]*)</g)].map((m) => m[1]), ['Landing', 'Builders hall', 'Status']);
+    assert.match(body, /st-surface__where">cloudbongos\.com</);
+    assert.match(body, /1 of 2 tweaked/);
+    assert.match(body, /style="width: 50%"/);
+    assert.match(body, /1 page has been asked for/);
+    await s.clickIn('st-panel', '[data-close-panel]');
+    assert.equal(s.el('st-panel').hidden, true);
+    assert.ok(!s.html.classList.contains('st-open'));
+  });
+
+  await test('the studio\'s words: a first click offers the studio page, and nothing is taken until the artist says so', async () => {
+    const s = bootStudio({ answers: { ...HOME, 'GET /copy-desk/pages/builders:studio/draft': ok(studioRead({ held: false })) } });
+    await s.settle();
+    await s.click('studio-greet');
+    assert.equal(s.el('st-offer').hidden, false);
+    assert.equal(s.el('studio-greet').getAttribute('contenteditable'), null, 'not editable before the page is taken');
+    assert.deepEqual(s.writes(), []);
+    await s.click('st-offer-no');
+    assert.equal(s.el('st-offer').hidden, true);
+    assert.deepEqual(s.writes(), [], 'not now takes nothing');
+  });
+
+  await test('taken: the words the reading lists are typed over in place, and the WHOLE draft is saved to the studio page', async () => {
+    let held = false;
+    const saved = [];
+    const s = bootStudio({
+      answers: {
+        ...HOME,
+        'GET /copy-desk/pages/builders:studio/draft': () => ok(studioRead({ held, draftLines: held ? [{ key: 'L0005', after: 'Waiting for you' }] : null })),
+        'POST /copy-desk/pages/builders:studio/claim': () => { held = true; return ok({ ok: true, outcome: 'created' }); },
+        'PUT /copy-desk/pages/builders:studio/draft': (b) => { saved.push(b); return ok({ ok: true, outcome: 'saved' }); },
+      },
+    });
+    await s.settle();
+    await s.click('studio-greet');
+    await s.click('st-offer-take');
+    const greet = s.el('studio-greet');
+    const sub = s.el('studio-sub');
+    assert.equal(greet.getAttribute('contenteditable'), 'true');
+    assert.equal(sub.getAttribute('contenteditable'), 'true', 'the sub-line found its own line, not the generic one');
+    assert.equal(sub.textContent, STUDIO_READING.lines[2].text, 'a line with holes is typed over as the reading holds it');
+    assert.equal(s.el('st-hint').hidden, true);
+    assert.equal(s.el('st-editing').hidden, false);
+    assert.match(s.el('st-editing').innerHTML, /The studio page is yours · 1 of 5 rewritten · saved/);
+    assert.match(s.el('st-editing').innerHTML, /href="\/builders\/tweak-editor\?page=builders:studio"/, 'submit is the editor\'s');
+
+    greet.textContent = 'Good night.';
+    greet.fire('input', { target: greet });
+    greet.fire('blur', { target: greet });
+    await s.settle();
+    assert.equal(saved.length, 1, 'one save');
+    assert.deepEqual(JSON.parse(JSON.stringify(saved[0])), { reading_hash: 'rs-1', lines: [{ key: 'L0002', after: 'Good night.' }, { key: 'L0005', after: 'Waiting for you' }] },
+      'the whole draft: the word typed here AND the line the editor saved');
+    assert.match(s.el('st-editing').innerHTML, /2 of 5 rewritten · saved/);
+    greet.fire('blur', { target: greet });
+    await s.settle();
+    assert.equal(saved.length, 1, 'an unchanged draft is not saved again');
+    const writes = s.writes().map((w) => `${w.method} ${w.url}`);
+    assert.deepEqual(writes, ['POST /api/bongos/copy-desk/pages/builders:studio/claim', 'PUT /api/bongos/copy-desk/pages/builders:studio/draft'],
+      'the claim and the draft, and never a live string');
+  });
+
+  await test('already held: a click goes straight to editing; a refused save says so in the server\'s words', async () => {
+    const s = bootStudio({
+      answers: {
+        ...HOME,
+        'GET /copy-desk/pages/builders:studio/draft': ok(studioRead({ held: true })),
+        'PUT /copy-desk/pages/builders:studio/draft': { ok: false, status: 409, data: { error: { code: 'reading_moved', message: 'moved', details: { what_this_means: 'The page changed since it was read.' } } } },
+      },
+    });
+    await s.settle();
+    await s.click('studio-greet');
+    assert.equal(s.el('st-offer').hidden, true, 'no offer: the page is already yours');
+    const greet = s.el('studio-greet');
+    assert.equal(greet.getAttribute('contenteditable'), 'true');
+    greet.textContent = 'Evening.';
+    greet.fire('input', { target: greet });
+    greet.fire('blur', { target: greet });
+    await s.settle();
+    assert.match(s.el('st-editing').innerHTML, /not saved · The page changed since it was read\./);
+    assert.ok(s.el('st-editing').classList.contains('st-editing--failed'));
+  });
+
+  await test('a refused claim on the studio page keeps the words as they are and says why', async () => {
+    const s = bootStudio({
+      answers: {
+        ...HOME,
+        'GET /copy-desk/pages/builders:studio/draft': ok(studioRead({ held: false })),
+        'POST /copy-desk/pages/builders:studio/claim': { ok: false, status: 403, data: { error: { code: 'not_an_artist', message: 'no' } } },
+      },
+    });
+    await s.settle();
+    await s.click('studio-greet');
+    await s.click('st-offer-take');
+    assert.equal(s.el('studio-greet').getAttribute('contenteditable'), null);
+    assert.equal(s.el('st-offer-err').hidden, false);
+    assert.match(s.el('st-offer-err').textContent, /Only an artist can take a page/);
+  });
+
+  await test('the older reviews stay one quiet door away while any still wait', async () => {
+    const REVIEW = { id: '1900', title: 'Artist review: the copy and visuals that shipped in task 1899', status: 'backlog', source: 'cascade', source_ref: 'cascade-artist-review-on-ship-1899', created_at: day(20) };
+    const s = bootStudio({ answers: { ...HOME, 'GET /tasks?discipline=artist&status=backlog&limit=50': ok({ tasks: [REVIEW] }) } });
+    await s.settle();
+    assert.equal(s.el('st-older').hidden, false);
+    assert.equal(s.el('st-older-label').textContent, '1 review from before Tweak Mode still waits');
+    await s.click('st-older');
+    assert.equal(s.el('st-reviews').hidden, false);
+    assert.match(s.el('studio-focus').innerHTML, /to tend now · 1 of 1/);
+    const none = bootStudio({ answers: HOME });
+    await none.settle();
+    assert.equal(none.el('st-older').hidden, true, 'no review waiting: no door');
+  });
+
+  await test('the markup: one h1 (the greeting), the tally and four doors, the libs before the page, the full-screen switch', () => {
+    const nc = HTML.replace(/<!--[\s\S]*?-->/g, '');
+    assert.equal((nc.match(/<h1\b/g) || []).length, 1);
+    assert.match(nc, /<h1[^>]*id="studio-greet"[^>]*data-words/);
+    assert.match(nc, /<p[^>]*id="studio-sub"[^>]*data-words/);
+    for (const id of ['st-tally', 'st-resume', 'st-flow', 'studio-approvals', 'st-status', 'st-older']) assert.match(nc, new RegExp(`id="${id}"`));
+    assert.match(nc, /<body[^>]*data-fullscreen-switch/);
+    const at = (f) => nc.indexOf(f);
+    assert.ok(at('tweak-editor-lib.js') < at('studio-lib.js') && at('studio-lib.js') < at('/studio.js'), 'the libs, then the page');
+    assert.ok(at('approval-queue.js') < at('/studio.js'), 'the Approval queue panel before the page that mounts it');
+  });
+} finally {
+  await new Promise((r) => setTimeout(r, 100));
+  summary();
+}

package/tests/hall_studio_world.mjs

@@ -55,6 +55,12 @@ test('the Studio writes ONLY the artist\'s verdict on their own review queue', (
     /^PATCH \$\{API\}\/tasks\/\$\{reviewId\}$/,          // note it   → the words, on the review
     /^POST \$\{API\}\/tasks$/,                           // needs work→ the follow-up task
     /^POST \$\{API\}\/tasks\/\$\{reviewId\}\/merge$/,    // …and the review closed against it
+    // The home (task 1003971 / BV2.TW16, ADR 0341 D5 and D11): take a page's
+    // tweak round, and save the studio page's draft while the artist holds it.
+    // Neither writes a live string; the words reach a page only as a shipped,
+    // approved tweak.
+    /^POST \$\{API\}\/copy-desk\/pages\/\$\{pageId\}\/claim$/,
+    /^PUT \$\{API\}\/copy-desk\/pages\/\$\{pageId\}\/draft$/,
   ];
   // Every write site, as "<VERB> <route expression>" — the verb from the
   // request call, the route from the WRITE_ROUTES entry it names.
@@ -69,7 +75,7 @@ test('the Studio writes ONLY the artist\'s verdict on their own review queue', (
       const named = /^WRITE_ROUTES\.(\w+)\(/.exec(arg.trim());
       return { verb, arg: arg.trim(), route: named ? routes.get(named[1]) : null };
     });
-  assert.equal(sites.length, 4, `exactly the four verdict writes; found ${sites.length}`);
+  assert.equal(sites.length, 6, `the four verdict writes, one page claim and one draft save; found ${sites.length}`);
   for (const s of sites) {
     assert.ok(s.route, `every write names a WRITE_ROUTES entry, never an inline URL: ${s.verb} ${s.arg}`);
     const site = `${s.verb} ${s.route}`;

package/tests/removal_verdict.mjs

@@ -62,8 +62,11 @@ await test('the prefix does NOT match the other cascade rule', () => {
   // separating a removal question from an artist review. If it ever widened, a
   // Confirm button would appear on a copy review and answering it would record a
   // removal verdict about work nobody proposed removing.
-  const artist = cascade.CASCADES.find((r) => r.key === 'artist-review-on-ship');
-  const artistRef = cascade.cascadeSourceRef(artist.key, SHIP);
+  //
+  // The artist rule itself was removed by Tweak Mode (TW14, ADR 0341 D9), but the
+  // reviews it filed are still rows on the board under its key, so the key is
+  // spelled here rather than read from CASCADES.
+  const artistRef = cascade.cascadeSourceRef('artist-review-on-ship', SHIP);
   assert.ok(!artistRef.startsWith(proposals.PROPOSAL_SOURCE_REF_PREFIX));
   assert.equal(proposals.shipTaskIdFromSourceRef(artistRef), null);
 });

package/tests/tweak_replaces_artist_review.mjs

@@ -0,0 +1,170 @@
+// tests/tweak_replaces_artist_review.mjs — Tweak Mode replaces the per-ship
+// artist review, the WHOLE path (task 1004325 / BV2.TW14, ADR 0341 D8 and D9).
+//
+// The done-when: "a ship changing a page's text files no artist review and the
+// page reads changed-since". Two halves, and they meet at one ship:
+//
+//   1. THE SHIP FILES NOTHING. The real cascade runner, with the real
+//      production table, the ship's real changed files and the artist gate at
+//      'strict' (the level that used to file AND hold), creates no task.
+//   2. THE PAGE READS CHANGED-SINCE ANYWAY, with no write. The real copy-desk
+//      route over the real lifecycle port's SQL (a fake pool), reading the page
+//      artifacts from disk: before the ship the page matches its last round;
+//      after it, the page's reading has moved, drift names the changed line, and
+//      the ship itself is listed as what changed it, found by its touches.
+//
+// "No write" is checked twice: the cascade's createTask is never called, and
+// the fake pool refuses any SQL that is not one of the two reads, so an INSERT
+// or UPDATE anywhere on the read path reds here.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { makeRunner } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+
+const F = require('../modules/copy-desk/tests/fixtures/page-tweak.cjs');
+const cascade = require('../modules/lifecycle/cascade.js');
+const gate = require('../src/bongos/artist-gate.js');
+const api = require('../src/module-api.js');
+
+// THE SHIP. An engineer rewords the studio greeting ("Welcome home" becomes
+// "Welcome back") after the page's first round shipped. Its touches meet the
+// studio page's files, and it is copy/visual work by every measure the old rule
+// used: a hall-ui module ship that changed a page file.
+const SHIP = {
+  id: '555', title: 'Reword the studio greeting', status: 'shipped',
+  discipline: 'engineer', kind: 'feature', source: 'manual', module_key: 'hall-ui',
+  version_id: 'BONGOS-V2', goal_id: '1000095',
+  touches: ['modules/hall-ui/public/studio.html'],
+  shipped_at: new Date('2026-09-22T09:00:00Z'),
+};
+
+// Every SQL the page read sends, so the test can say none of it wrote.
+const seen = [];
+const flat = (sql) => String(sql).replace(/\s+/g, ' ').trim();
+api.pool = {
+  async query(sql, params = []) {
+    const q = flat(sql);
+    seen.push({ q, params });
+    if (/FROM tasks t LEFT JOIN task_grades g/.test(q)) return { rows: F.TASKS };
+    if (/t\.touches && \$1::text\[\]/.test(q)) {
+      // The real query's predicate, applied to the one ship: shipped after the
+      // page's last round, touching one of the page's files.
+      const files = new Set(params[0]);
+      const hit = SHIP.shipped_at > new Date(params[1]) && SHIP.touches.some((t) => files.has(t));
+      return { rows: hit ? [{ id: SHIP.id, title: SHIP.title, shipped_at: SHIP.shipped_at }] : [] };
+    }
+    throw new Error(`unexpected SQL on the page read: ${q.slice(0, 120)}`);
+  },
+};
+api.requireBuilder = (req, res, next) => { req.builder = { id: F.ALICE.id, rank: 'thetes' }; next(); };
+
+const seams = require('../src/module-seams.js');
+if (!seams.hasProvider('lifecycle')) seams.registerProvider('lifecycle', require('../modules/lifecycle/lifecycle.js'));
+if (!seams.hasProvider('reward')) seams.registerProvider('reward', require('../modules/economy/reward.js'));
+
+const pageData = require('../modules/copy-desk/page-data.js');
+const express = require('express');
+const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+const buildRouter = require('../modules/copy-desk/routes/copy-desk.js');
+
+const app = express();
+app.use(attachFail);
+app.use(buildRouter());
+const server = await new Promise((resolve) => { const s = app.listen(0, '127.0.0.1', () => resolve(s)); });
+const base = `http://127.0.0.1:${server.address().port}`;
+async function get(p) {
+  const r = await fetch(base + p);
+  return { status: r.status, body: await r.json() };
+}
+
+// The studio's reading BEFORE the ship says exactly what its first round left
+// ("Welcome home", "Resume"); AFTER it is the fixture's (the greeting moved).
+// The shared shell line differs on both sides, and drift must ignore it.
+const studioAfter = F.READINGS.pages.find((p) => p.id === 'builders:studio');
+const studioBefore = {
+  ...studioAfter,
+  reading_hash: 'studio-before',
+  lines: studioAfter.lines.map((l) => (l.key === 'L0002' ? { ...l, text: 'Welcome home' } : l)),
+};
+const readingsWith = (studio) => ({ ...F.READINGS, pages: F.READINGS.pages.map((p) => (p.id === studio.id ? studio : p)) });
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'tweak-replaces-review-'));
+const root = (name, readings) => {
+  const dir = path.join(tmp, name);
+  fs.mkdirSync(path.join(dir, 'docs'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'docs', 'page-inventory.json'), JSON.stringify(F.INVENTORY));
+  fs.writeFileSync(path.join(dir, 'docs', 'page-readings.json'), JSON.stringify(readings));
+  return dir;
+};
+const BEFORE = root('before', readingsWith(studioBefore));
+const AFTER = root('after', readingsWith(studioAfter));
+
+const { test, summary } = makeRunner();
+
+try {
+  await test('before the ship, the studio matches its last round: tweaked, no drift', async () => {
+    pageData._setRoot(BEFORE);
+    const { status, body } = await get('/copy-desk/pages/builders:studio');
+    assert.equal(status, 200);
+    assert.equal(body.status_label, 'Text tweaked 1x');
+    assert.equal(body.drift.changed, false);
+  });
+
+  await test('the ship that rewords the page files NO artist review, at the strictest gate', async () => {
+    const created = [];
+    const report = await cascade.runCascadesForShip({ id: SHIP.id }, {
+      getTask: async () => SHIP,
+      findTaskBySourceRef: async () => null,
+      createTask: async (spec) => { created.push(spec); return { id: '9999' }; },
+      artistGateMode: () => 'strict',
+      changedFiles: async () => ({ paths: SHIP.touches, truncated: false }),
+      removalCandidates: async () => ({ removals: [] }),
+    });
+    assert.deepEqual(report.errors, []);
+    assert.deepEqual(created, [], 'nothing is filed: no review task, no marker, nothing');
+    assert.equal(created.some((s) => gate.isArtistReview({ source: s.source, source_ref: s.sourceRef })), false);
+    // It is still copy/visual work: the grader's reader lens still runs on it.
+    assert.equal(cascade.hasCopyOrVisualWork(SHIP, SHIP.touches), true);
+  });
+
+  await test('after the ship, the page reads changed-since, and names the ship, with no write', async () => {
+    pageData._setRoot(AFTER);
+    seen.length = 0;
+    const { status, body } = await get('/copy-desk/pages/builders:studio');
+    assert.equal(status, 200);
+    assert.equal(body.drift.known, true);
+    assert.equal(body.drift.changed, true, 'the page reads "changed since last tweak"');
+    assert.deepEqual(body.drift.changed_lines, [{ key: 'L0002', section: 'greeting', text: 'Welcome back' }]);
+    assert.deepEqual(body.drift.removed_lines, ['Welcome home']);
+    assert.deepEqual(body.drift.ships.map((s) => s.task_id), [SHIP.id], 'the ship is what changed it');
+    assert.equal(body.status_label, 'Text tweaked 1x', 'drift never lowers the count');
+    // Derived, never stored: only the two reads ran.
+    assert.ok(seen.length > 0);
+    for (const s of seen) assert.match(s.q, /^(WITH .*)?SELECT /, `a read, never a write: ${s.q.slice(0, 80)}`);
+  });
+
+  await test('the page list carries the same drift, which is what the recommendation ranks on', async () => {
+    pageData._setRoot(AFTER);
+    const list = await get('/copy-desk/pages');
+    const studio = list.body.pages.find((p) => p.id === 'builders:studio');
+    assert.equal(studio.drift.changed, true);
+    assert.equal(studio.drift.changed_count, 1);
+  });
+} finally {
+  pageData._setRoot(null);
+  server.closeAllConnections();
+  await new Promise((resolve) => server.close(resolve));
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// Let the closed sockets finish closing before summary() calls process.exit: on
+// Windows an exit while a handle is mid-close trips a libuv assertion (exit 127)
+// after every case has passed.
+await new Promise((resolve) => setTimeout(resolve, 100));
+summary();