@bongos/core 1.21.44 → 1.21.45

package/modules/hall-ui/public/thinking.html

@@ -138,9 +138,9 @@
   </div>
 </div>
 
-<script src="/builders/shell-trail.js?v=2026-10-04-nolegacy"></script>
-<script src="/builders/craft-mode.js?v=2026-10-04-nolegacy"></script>
-<script src="/builders/shell.js?v=2026-10-04-nolegacy"></script>
+<script src="/builders/shell-trail.js?v=2026-10-04-paintbrush"></script>
+<script src="/builders/craft-mode.js?v=2026-10-04-paintbrush"></script>
+<script src="/builders/shell.js?v=2026-10-04-paintbrush"></script>
 <script src="/builders/palette.js" defer></script>
 
 <script src="/builders/idea-objects.js?v=2026-09-27-split"></script>

package/modules/hall-ui/public/tweak-editor.html

@@ -142,9 +142,9 @@
 
 <div id="toast" class="toast" role="status" aria-live="polite" data-visible="0"></div>
 
-<script src="/builders/shell-trail.js?v=2026-10-04-nolegacy"></script>
-<script src="/builders/craft-mode.js?v=2026-10-04-nolegacy"></script>
-<script src="/builders/shell.js?v=2026-10-04-nolegacy"></script>
+<script src="/builders/shell-trail.js?v=2026-10-04-paintbrush"></script>
+<script src="/builders/craft-mode.js?v=2026-10-04-paintbrush"></script>
+<script src="/builders/shell.js?v=2026-10-04-paintbrush"></script>
 <script src="/builders/palette.js" defer></script>
 <script src="/builders/dom-utils.js?v=2026-06-23-contrib"></script>
 <script src="/builders/brand-holes.js?v=2026-09-29-aqfix"></script>

package/modules/hall-ui/public/watch.html

@@ -162,9 +162,9 @@
 
 <!-- The app shell (sidebar + top bar). Dependency-free; loaded FIRST so the
      chrome exists before the page script runs. -->
-<script src="/builders/shell-trail.js?v=2026-10-04-nolegacy"></script>
-<script src="/builders/craft-mode.js?v=2026-10-04-nolegacy"></script>
-<script src="/builders/shell.js?v=2026-10-04-nolegacy"></script>
+<script src="/builders/shell-trail.js?v=2026-10-04-paintbrush"></script>
+<script src="/builders/craft-mode.js?v=2026-10-04-paintbrush"></script>
+<script src="/builders/shell.js?v=2026-10-04-paintbrush"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>
 <!-- shared frontend toolkit (window.OTB) — loaded before watch.js, which pulls from it. -->

package/modules/hall-ui/public/work.html

@@ -171,9 +171,9 @@
 
 <!-- The app shell (sidebar + top bar + footer). Dependency-free; runs at parse
      time so the chrome exists before the deferred page scripts execute. -->
-<script src="/builders/shell-trail.js?v=2026-10-04-nolegacy"></script>
-<script src="/builders/craft-mode.js?v=2026-10-04-nolegacy"></script>
-<script src="/builders/shell.js?v=2026-10-04-nolegacy"></script>
+<script src="/builders/shell-trail.js?v=2026-10-04-paintbrush"></script>
+<script src="/builders/craft-mode.js?v=2026-10-04-paintbrush"></script>
+<script src="/builders/shell.js?v=2026-10-04-paintbrush"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>
 <!-- shared frontend toolkit (window.OTB) — loaded FIRST so work.js can pull from it. -->

package/modules/hall-ui/records/craft-mode.md

@@ -35,3 +35,12 @@ Covers: every shelled hall page (`craft-mode.js`, `shell.js`, `style.css`), and
 - **Two pieces are drawn by `craft-mode.js` `applyLook()`, on every mode change:** the eyebrow beside `#topbar-title` (`LOOKS`: "the studio · night", "the sky", "the city"; hidden at <=640px, where it overflowed phones) and the scene plate under `.app-sidebar__brand` (40px closed rail, 64px open). The plate's markup IS `artHtml(mode)`, the picker's door art, exported rather than copied; light mode recolours it to each scene's day (the city is the dark one through `invert(1) hue-rotate(180deg)`). It does not animate.
 - **Always-present tabs widened** (owner, 2026-10-03): `ALWAYS_TABS` is Builders, Collab and Profile, so every mode keeps the You and Community groups.
 - **Governing's header tallies** ("needs you · moving") are task 1004563, not this look.
+
+## The paintbrush (task 1004497)
+
+- **Artistry carries two tools**: the palette (a feedback doc, `page-notes.js`, record `page-notes.md`) and the paintbrush (`paintbrush.js`). Both are `TOOLS` entries in `craft-mode.js` and load their own script on first press.
+- **The paintbrush edits the page's own words where they stand, as a REAL wording change** (owner, 2026-10-04): it is the copy desk's page round, the same one the tweak editor and the studio's own words write (ADR 0341). Pressing it reads `GET /copy-desk/pages/builders:<page>/draft`; a page nobody holds is OFFERED, never taken silently (taking it is the copy desk's artists-only claim, and the page shows as being tweaked while held). Typing saves the whole draft; "Review" lists every change as was/now; "Send for approval" submits the round. It never writes `page-notes` (owner: kept separate from the feedback docs).
+- **Only a leaf element inside `<main>` whose words are one reading line becomes editable.** Shared chrome, a line with a `{…}` hole, controls (`button`, form fields, `code`), and anything hidden stay as they are; the bar counts the lines it cannot reach and links to the tweak editor for them. A click on edited words inside a link does not navigate.
+- **Nobody else's view changes, and neither does yours once editing ends**: "Stop editing" and "Send" both put the page's own words back. The draft stays on the round.
+- **The top bar fits two tools at 390px** because, at phone width, the side packs to a 4px gap, a tool is 28px, the side and the menu do not shrink, and a long page title trims with an ellipsis instead. All 34 hall pages measure 0px of sideways scroll in Artistry at 390px.
+- `tests/paintbrush.mjs` runs the real script and both shared libs over a small page.

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.44",
+  "version": "1.21.45",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.21.44",
+      "version": "1.21.45",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.44",
+  "version": "1.21.45",
   "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

@@ -9028,5 +9028,11 @@
       "id": "1004569",
       "text": "The street's pins no longer pile up or talk over each other. Each building now has one pin, and its colour and size show how much it matters: largest and pulsing orange when something needs you within a day, orange when it nee"
     }
+  ],
+  "1.21.45": [
+    {
+      "id": "1004497",
+      "text": "Artists can now edit any hall page's words right where they stand. In Artistry mode, \"Edit words\" offers to take the page; the words get an underline and can be typed over, a review lists each change as was/now, and \"Send for"
+    }
   ]
 }

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.44'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.45'; // 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/hall_tweak_editor.mjs

@@ -635,7 +635,7 @@ try {
     assert.match(HTML, /<body data-page="tweak-editor"[^>]*data-fullscreen-switch/);
     assert.equal((HTML.match(/<h1\b/g) || []).length, 1);
     assert.ok(HTML.indexOf('tweak-editor-lib.js') < HTML.indexOf('tweak-editor.js?'), 'the lib loads first');
-    assert.match(HTML, /shell\.js\?v=2026-10-04-nolegacy/);
+    assert.match(HTML, /shell\.js\?v=2026-10-04-paintbrush/);
     assert.equal(/fonts\.googleapis\.com\/css/.test(HTML), false);
     for (const id of ['tw-bar', 'tw-counter', 'tw-open', 'tw-open-more', 'tw-divider', 'tw-openwrap', 'tw-open-menu', 'tw-open-tab', 'tw-open-split', 'tw-frame', 'tw-frame-view', 'tw-split-close', 'tw-download', 'tw-upload', 'tw-file', 'tw-submit', 'tw-paper', 'tw-doc', 'tw-notice', 'tw-done', 'tw-take', 'tw-pick', 'tw-picks', 'tw-refused', 'tw-refused-title', 'tw-refused-list', 'tw-refused-next', 'tw-refused-download', 'tw-refused-close']) {
       assert.ok(new RegExp(`id="${id}"`).test(HTML), `#${id} is in the markup`);

package/tests/page_notes_panel.mjs

@@ -76,8 +76,9 @@ 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', () => {
   const p = boot({ session: { 'hall-craft': 'artistry' } });
-  assert.deepEqual(p.tools().map((t) => t.id), ['craft-tool-palette']);
-  assert.equal(p.tools()[0].nextSibling, p.sw, 'it sits right before the mode switch');
+  assert.deepEqual(p.tools().map((t) => t.id), ['craft-tool-palette', 'craft-tool-paintbrush'], 'the palette, then the paintbrush (task 1004497)');
+  assert.equal(p.tools()[0].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'), 'Write feedback on this page');
   for (const m of ['building', 'ideating', 'governing']) {
     p.craft.choose(m);
@@ -85,7 +86,7 @@ test('THE PALETTE: in the top bar in Artistry alone, right before the switch, an
   }
   p.craft.choose('artistry');
   p.craft.choose('artistry');
-  assert.equal(p.tools().length, 1, 'choosing Artistry twice draws one palette');
+  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');
 });
 

package/tests/paintbrush.mjs

@@ -0,0 +1,351 @@
+// tests/paintbrush.mjs — the Artistry paintbrush (task 1004497): a page's own
+// words, edited where they stand, as a proposed wording change.
+//
+// Runs the REAL paintbrush.js, with the REAL tweak-editor-lib.js and
+// studio-lib.js it shares with the editor and the studio, over a small page
+// (there is no jsdom here; the fake-DOM idiom of tests/page_notes_panel.mjs).
+// The task's done-when, as cases: an artist toggles editing, changes the words
+// a page shows, reviews the changes and sends them as one proposal; nobody
+// else's view changes — the page's words come back when editing ends, and the
+// only writes are the copy desk's own page-round routes (owner, 2026-10-04: the
+// edits are real wording changes, kept apart from the palette's feedback docs).
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules/hall-ui/public');
+const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
+const BRUSH = read('paintbrush.js');
+const EDITOR_LIB = read('tweak-editor-lib.js');
+const STUDIO_LIB = read('studio-lib.js');
+const CRAFT = read('craft-mode.js');
+const CSS = read('style.css');
+
+// ---------- a small DOM: enough for the selectors paintbrush.js asks ----------
+function matchesOne(el, sel) {
+  sel = sel.trim();
+  const m = /^([a-z]+)?(?:#([\w-]+))?(?:\.([\w-]+))?(?:\[([\w-]+)(?:="([^"]*)")?\])?$/i.exec(sel);
+  if (!m) throw new Error('fake DOM cannot match ' + sel);
+  const [, tag, id, cls, attr, val] = m;
+  if (tag && el.tagName !== tag.toUpperCase()) return false;
+  if (id && el.id !== id) return false;
+  if (cls && !el.classList.contains(cls)) return false;
+  if (attr) {
+    if (attr === 'hidden') return !!el.hidden;
+    if (!el.hasAttribute(attr)) return false;
+    if (val !== undefined && el.getAttribute(attr) !== val) return false;
+  }
+  return true;
+}
+const matches = (el, sel) => sel.split(',').some((s) => matchesOne(el, s));
+
+class El {
+  constructor(tag, text) {
+    this.tagName = tag.toUpperCase();
+    this.attrs = {};
+    this.children = [];
+    this.parentNode = null;
+    this.id = '';
+    this.hidden = false;
+    this.dataset = {};
+    this.listeners = {};
+    this._text = text == null ? '' : String(text);
+    this._html = '';
+    const cls = new Set();
+    this.classList = {
+      add: (...c) => c.forEach((x) => cls.add(x)), remove: (...c) => c.forEach((x) => cls.delete(x)),
+      contains: (c) => cls.has(c), toggle: (c, on) => { if (on === undefined ? !cls.has(c) : on) cls.add(c); else cls.delete(c); },
+    };
+  }
+  add(child) { child.parentNode = this; this.children.push(child); return child; }
+  appendChild(c) { return this.add(c); }
+  removeChild(c) { this.children.splice(this.children.indexOf(c), 1); c.parentNode = null; return c; }
+  get childElementCount() { return this.children.length; }
+  get textContent() { return this.children.length ? this.children.map((c) => c.textContent).join('') : this._text; }
+  set textContent(v) { this.children = []; this._text = String(v); }
+  get innerHTML() { return this._html; }
+  set innerHTML(v) { this._html = String(v); }
+  set className(v) { String(v).split(/\s+/).filter(Boolean).forEach((c) => this.classList.add(c)); }
+  setAttribute(k, v) { this.attrs[k] = String(v); if (k === 'contenteditable') this.contentEditable = String(v); }
+  getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; }
+  hasAttribute(k) { return k in this.attrs; }
+  removeAttribute(k) { delete this.attrs[k]; if (k === 'contenteditable') this.contentEditable = 'inherit'; }
+  closest(sel) { for (let n = this; n; n = n.parentNode) if (n.tagName && matches(n, sel)) return n; return null; }
+  querySelectorAll(sel) {
+    const out = [];
+    const walk = (n) => n.children.forEach((c) => { if (sel === '*' || matches(c, sel)) out.push(c); walk(c); });
+    walk(this);
+    return out;
+  }
+  querySelector(sel) { return this.querySelectorAll(sel)[0] || null; }
+  addEventListener(t, fn) { (this.listeners[t] ||= []).push(fn); }
+  focus() { this.ownerDocument.activeElement = this; }
+  blur() {}
+}
+
+// A page with words the reading lists, and words it must leave alone.
+function page() {
+  const body = new El('body');
+  body.dataset.page = 'roadmap';
+  body.dataset.pageTitle = 'Roadmap';
+  const main = body.add(new El('main'));
+  const h1 = main.add(new El('h1', 'Where the build is going'));
+  const lede = main.add(new El('p', 'Every version, from first idea to shipped.'));
+  const link = main.add(new El('a'));
+  link.setAttribute('href', '/goals');
+  const linkWords = link.add(new El('span', 'See every goal'));
+  const count = main.add(new El('p', '12 versions shipped'));            // a {…} hole line: the editor's
+  const btn = main.add(new El('button', 'Star this version'));          // a control: never editable
+  const stray = main.add(new El('p', 'Words the reading has never seen'));
+  const hiddenBox = main.add(new El('div'));
+  hiddenBox.hidden = true;
+  const hiddenWords = hiddenBox.add(new El('p', 'Nothing in flight right now.'));
+  const footer = body.add(new El('footer', 'Skip to content'));        // outside main
+  return { body, main, h1, lede, link, linkWords, count, btn, stray, hiddenWords, footer };
+}
+const READING = {
+  reading_hash: 'abc123',
+  read: true,
+  lines: [
+    { key: 'L0001', section: 'skip link', text: 'Skip to content', placement: 'shared' },
+    { key: 'L0002', section: 'page top', text: 'Where the build is going', placement: 'placed' },
+    { key: 'L0003', section: 'page top', text: 'Every version, from first idea to shipped.', placement: 'placed' },
+    { key: 'L0004', section: 'versions', text: 'See every goal', placement: 'placed' },
+    { key: 'L0005', section: 'versions', text: '{…} versions shipped', placement: 'placed' },
+    { key: 'L0006', section: 'versions', text: 'Star this version', placement: 'placed' },
+    { key: 'L0007', section: 'versions', text: 'Nothing in flight right now.', placement: 'unplaced' },
+  ],
+};
+
+function boot({ round = null, draft = null, claim = { status: 200, body: { ok: true } }, submit = { status: 200, body: { ok: true, outcome: 'submitted' } } } = {}) {
+  const p = page();
+  const head = new El('head');
+  const calls = [];
+  const docListeners = {};
+  const document = {
+    body: p.body, head, documentElement: new El('html'), activeElement: null,
+    currentScript: { src: 'https://h/builders/paintbrush.js?v=2026-10-04-test' },
+    querySelector: (sel) => p.body.querySelector(sel),
+    getElementById: (id) => p.body.querySelectorAll('*').find((n) => n.id === id) || null,
+    createElement: (t) => { const e = new El(t); e.ownerDocument = document; return e; },
+    addEventListener: (t, fn) => { (docListeners[t] ||= []).push(fn); },
+    removeEventListener: (t, fn) => { docListeners[t] = (docListeners[t] || []).filter((f) => f !== fn); },
+    execCommand() { return true; },
+    title: 'Roadmap — Builders hall',
+  };
+  for (const n of [p.body, ...p.body.querySelectorAll('*')]) n.ownerDocument = document;
+  let state = { round, draft };
+  const respond = (status, body) => Promise.resolve({ ok: status < 400, status, json: () => Promise.resolve(body) });
+  const fetch = (url, opts = {}) => {
+    const method = opts.method || 'GET';
+    calls.push({ method, url, body: opts.body ? JSON.parse(opts.body) : undefined, keepalive: !!opts.keepalive });
+    if (!url.startsWith('/api/bongos/copy-desk/pages/builders%3Aroadmap/')) return respond(404, {});
+    const rest = url.slice('/api/bongos/copy-desk/pages/builders%3Aroadmap/'.length);
+    if (method === 'GET' && rest === 'draft') return respond(200, { ok: true, page: { id: 'builders:roadmap', title: 'Roadmap' }, reading: READING, round: state.round, draft: state.draft });
+    if (method === 'POST' && rest === 'claim') {
+      if (claim.status < 400) state = { round: { task_id: '9', state: 'writing', held_by_you: true, holder: { login: 'me' } }, draft: null };
+      return respond(claim.status, claim.body);
+    }
+    if (method === 'PUT' && rest === 'draft') return respond(200, { ok: true, outcome: 'saved' });
+    if (method === 'POST' && rest === 'submit') return respond(submit.status, submit.body);
+    return respond(404, {});
+  };
+  const winListeners = {};
+  const window = { location: { pathname: '/roadmap' }, addEventListener: (t, fn) => { (winListeners[t] ||= []).push(fn); }, removeEventListener: (t, fn) => { winListeners[t] = (winListeners[t] || []).filter((f) => f !== fn); } };
+  const sandbox = { window, document, fetch, Promise, setTimeout, clearTimeout, JSON, Math, String, Array, Object };
+  window.window = window;
+  vm.createContext(sandbox);
+  // The two shared libs, as the page would have them once the tool loads them.
+  vm.runInContext(EDITOR_LIB, sandbox, { filename: 'tweak-editor-lib.js' });
+  vm.runInContext(STUDIO_LIB, sandbox, { filename: 'studio-lib.js' });
+  vm.runInContext(BRUSH, sandbox, { filename: 'paintbrush.js' });
+  const bar = () => p.body.querySelector('#paintbrush');
+  const fire = (type, ev) => (docListeners[type] || []).slice().forEach((fn) => fn(ev));
+  // Press a bar button by its data attribute.
+  const press = (attr) => {
+    const html = bar().innerHTML;
+    assert.match(html, new RegExp(attr), `the bar offers [${attr}]`);
+    const btn = new El('button');
+    btn.setAttribute(attr, '');
+    btn.parentNode = bar();
+    bar().listeners.click.forEach((fn) => fn({ target: btn }));
+  };
+  const type = (el, text) => { el.textContent = text; fire('input', { target: el }); };
+  const editable = () => p.body.querySelectorAll('*').filter((n) => n.hasAttribute('contenteditable'));
+  return { ...p, leave: () => (winListeners.pagehide || []).forEach((fn) => fn()), brush: window.OTBPaintbrush, calls, bar, press, type, fire, editable, html: document.documentElement, writes: () => calls.filter((c) => c.method !== 'GET') };
+}
+const settle = () => new Promise((r) => setTimeout(r, 5));
+
+test('craft-mode.js puts the paintbrush beside the palette in Artistry, loading its own script', () => {
+  assert.match(CRAFT, /\{ id: 'paintbrush', icon: 'brush', short: 'Edit words', label: 'Edit this page\\'s words', script: 'paintbrush.js', api: 'OTBPaintbrush' \}/);
+  const tools = /var TOOLS = \{([\s\S]*?)\n  \};/.exec(CRAFT)[1];
+  assert.match(tools, /^\s*artistry: \[/m, 'it is an Artistry tool');
+  assert.doesNotMatch(tools, /building:|ideating:|governing:/, 'and no other mode has one');
+});
+
+test('pressing it on a page nobody holds OFFERS the page — nothing is editable and nothing is written until the artist takes it', async () => {
+  const p = boot();
+  p.brush.open();
+  await settle();
+  assert.match(p.bar().innerHTML, /Take this page/);
+  assert.match(p.bar().innerHTML, /Nobody else sees them until then/);
+  assert.equal(p.editable().length, 0);
+  assert.deepEqual(p.writes(), [], 'reading the page writes nothing');
+  assert.equal(p.calls[0].url, '/api/bongos/copy-desk/pages/builders%3Aroadmap/draft', 'it reads this page by its reading id');
+});
+
+test('taking the page makes the words the reading lists editable where they stand — not shared chrome, holes, controls, hidden or unknown words', async () => {
+  const p = boot();
+  p.brush.open();
+  await settle();
+  p.press('data-pb-take');
+  await settle();
+  assert.deepEqual(p.writes().map((c) => c.method + ' ' + c.url.split('/').pop()), ['POST claim'], 'one claim, through the copy desk');
+  assert.deepEqual(p.editable().map((n) => n.textContent), ['Where the build is going', 'Every version, from first idea to shipped.', 'See every goal']);
+  for (const n of [p.count, p.btn, p.stray, p.hiddenWords, p.footer]) assert.ok(!n.hasAttribute('contenteditable'), `"${n.textContent}" stays as it is`);
+  assert.equal(p.h1.getAttribute('data-pb-key'), 'L0002');
+  assert.ok(p.html.classList.contains('pb-editing'));
+  assert.match(p.bar().innerHTML, /0 changes/);
+  assert.match(p.bar().innerHTML, /tweak editor/, 'the lines it cannot reach point to the editor');
+});
+
+test('a refused claim says why, in the artist\'s words, and leaves the page alone', async () => {
+  const p = boot({ claim: { status: 403, body: { ok: false, error: { code: 'not_an_artist', message: 'no' } } } });
+  p.brush.open();
+  await settle();
+  p.press('data-pb-take');
+  await settle();
+  assert.match(p.bar().innerHTML, /Only an artist can take a page/);
+  assert.equal(p.editable().length, 0);
+});
+
+test('a page another artist holds is not offered, and one already on its way is not either', async () => {
+  const held = boot({ round: { task_id: '9', state: 'writing', held_by_you: false, holder: { login: 'mira' } } });
+  held.brush.open();
+  await settle();
+  assert.match(held.bar().innerHTML, /mira is tweaking this page right now/);
+  assert.doesNotMatch(held.bar().innerHTML, /Take this page/);
+  const flight = boot({ round: { task_id: '9', state: 'submitted', held_by_you: false, holder: null } });
+  flight.brush.open();
+  await settle();
+  assert.match(flight.bar().innerHTML, /on its way to the site/);
+  assert.deepEqual([...held.writes(), ...flight.writes()], []);
+});
+
+test('typing saves the WHOLE draft to the page round, and a click on words inside a link does not follow it', async () => {
+  const p = boot({ round: { task_id: '9', state: 'writing', held_by_you: true, holder: { login: 'me' } } });
+  p.brush.open();
+  await settle();
+  assert.equal(p.editable().length, 3, 'a page you already hold opens straight into editing');
+  p.type(p.lede, 'Every version, from the first spark to shipped.');
+  p.fire('focusout', { target: p.lede });
+  await settle();
+  const put = p.writes().find((c) => c.method === 'PUT');
+  assert.ok(put, 'a save went out');
+  assert.match(put.url, /builders%3Aroadmap\/draft$/);
+  assert.deepEqual(JSON.parse(JSON.stringify(put.body)), { reading_hash: 'abc123', lines: [{ key: 'L0003', after: 'Every version, from the first spark to shipped.' }] });
+  assert.ok(p.lede.classList.contains('pb-word--changed'));
+  let prevented = false;
+  p.fire('click', { target: p.linkWords, preventDefault() { prevented = true; } });
+  assert.ok(prevented, 'the link around the words does not navigate while editing');
+});
+
+test('REVIEW lists every change as was/now, and SEND submits the page once and puts its own words back', async () => {
+  const p = boot({ round: { task_id: '9', state: 'writing', held_by_you: true, holder: { login: 'me' } } });
+  p.brush.open();
+  await settle();
+  p.type(p.h1, 'Where we are going');
+  p.type(p.linkWords, 'Every goal <b>here</b>');
+  p.press('data-pb-review');
+  await settle();
+  const html = p.bar().innerHTML;
+  assert.match(html, /Was<\/span> Where the build is going/);
+  assert.match(html, /Now<\/span> Where we are going/);
+  assert.match(html, /Every goal &lt;b&gt;here&lt;\/b&gt;/, 'what the artist typed is escaped in the review');
+  p.press('data-pb-send');
+  await settle();
+  const submits = p.writes().filter((c) => c.method === 'POST' && c.url.endsWith('/submit'));
+  assert.equal(submits.length, 1, 'one proposal for the page');
+  const lastPut = p.writes().filter((c) => c.method === 'PUT').pop();
+  assert.deepEqual(JSON.parse(JSON.stringify(lastPut.body.lines)), [{ key: 'L0002', after: 'Where we are going' }, { key: 'L0004', after: 'Every goal <b>here</b>' }], 'the saved draft held both changes before the submit');
+  assert.match(p.bar().innerHTML, /Sent for approval: 2 changes/);
+  assert.equal(p.h1.textContent, 'Where the build is going', 'the page shows its own words again');
+  assert.equal(p.linkWords.textContent, 'See every goal');
+  assert.equal(p.editable().length, 0);
+  assert.ok(!p.html.classList.contains('pb-editing'));
+});
+
+test('STOP EDITING keeps the draft saved and puts the page\'s words back', async () => {
+  const p = boot({ round: { task_id: '9', state: 'writing', held_by_you: true, holder: { login: 'me' } } });
+  p.brush.open();
+  await settle();
+  p.type(p.h1, 'A new heading');
+  p.press('data-pb-stop');
+  await settle();
+  assert.ok(p.writes().some((c) => c.method === 'PUT'), 'the change was saved first');
+  assert.ok(!p.writes().some((c) => c.url.endsWith('/submit')), 'stopping sends nothing');
+  assert.equal(p.h1.textContent, 'Where the build is going');
+  assert.equal(p.editable().length, 0);
+  assert.equal(p.bar(), null, 'the bar is gone');
+});
+
+test('a draft saved earlier comes back: the words show the artist\'s rewrite when editing resumes', async () => {
+  const p = boot({
+    round: { task_id: '9', state: 'writing', held_by_you: true, holder: { login: 'me' } },
+    draft: { reading_hash: 'abc123', lines: [{ key: 'L0002', after: 'Where it all goes' }] },
+  });
+  p.brush.open();
+  await settle();
+  assert.equal(p.h1.textContent, 'Where it all goes');
+  assert.ok(p.h1.classList.contains('pb-word--changed'));
+  assert.match(p.bar().innerHTML, /1 change/);
+});
+
+test('the only routes it writes are the copy desk\'s page round — never page-notes, never anything else', () => {
+  const routes = [...BRUSH.matchAll(/request\('(POST|PUT|PATCH|DELETE)', [^,]*?'\/([a-z-]+)'/g)].map((m) => m[1] + ' ' + m[2]);
+  assert.deepEqual(routes.sort(), ['POST claim', 'POST submit', 'PUT draft']);
+  assert.match(BRUSH, /var API = '\/api\/bongos\/copy-desk\/pages\/';/);
+  assert.doesNotMatch(BRUSH, /page-notes/);
+});
+
+test('its styles live in style.css, on the token tier', () => {
+  for (const sel of ['.pb {', '.pb__btn--go', '.pb-word {', '.pb-word--changed', '.pb__changes']) assert.ok(CSS.includes(sel), `style.css styles ${sel}`);
+  const block = CSS.slice(CSS.indexOf('/* THE PAINTBRUSH'), CSS.indexOf('/* THE BACK LINK'));
+  assert.doesNotMatch(block, /#[0-9a-f]{3,8}\b|rgba?\(/i, 'no colour literals: tokens only');
+});
+
+test('leaving the page mid-edit sends the last save with keepalive, so closing the tab does not lose it', async () => {
+  const p = boot({ round: { task_id: '9', state: 'writing', held_by_you: true, holder: { login: 'me' } } });
+  p.brush.open();
+  await settle();
+  p.type(p.h1, 'Typed, then the tab closed');
+  p.leave();
+  await settle();
+  const put = p.writes().find((c) => c.method === 'PUT');
+  assert.ok(put && put.keepalive, 'the save on the way out is a keepalive request');
+  assert.equal(put.body.lines[0].after, 'Typed, then the tab closed');
+});
+
+test('words only: bold, italic and underline keys do nothing in the words; elsewhere they are left alone', async () => {
+  const p = boot({ round: { task_id: '9', state: 'writing', held_by_you: true, holder: { login: 'me' } } });
+  p.brush.open();
+  await settle();
+  let prevented = 0;
+  for (const key of ['b', 'i', 'u']) p.fire('keydown', { key, ctrlKey: true, target: p.h1, preventDefault() { prevented++; } });
+  assert.equal(prevented, 3);
+  p.fire('keydown', { key: 'b', ctrlKey: true, target: p.stray, preventDefault() { prevented++; } });
+  assert.equal(prevented, 3, 'a key outside the edited words is not touched');
+});
+
+test('a word on the page matches its line however its spaces wrap, and one table serves every element', async () => {
+  const p = boot({ round: { task_id: '9', state: 'writing', held_by_you: true, holder: { login: 'me' } } });
+  p.lede.textContent = '  Every version,\n   from first idea to shipped. ';
+  p.brush.open();
+  await settle();
+  assert.equal(p.lede.getAttribute('data-pb-key'), 'L0003');
+  assert.doesNotMatch(BRUSH, /matchLine\(/, 'no per-element pattern matching: the hole-free lines are looked up by their words');
+});