@bongos/core 1.21.52 → 1.21.53

package/tests/lightbulb.mjs

@@ -0,0 +1,385 @@
+// tests/lightbulb.mjs — the Ideating lightbulb (task 1004498): an ideator's
+// text-only notes about the page they are on, split into attributed ideas.
+//
+// Owner decisions, 2026-10-04: an AI splits the notes (one idea if it cannot);
+// the text itself is NOT kept — only the ideas, each linking back to the page;
+// the panel lists the ideas already filed from the page; unsent text waits in
+// this browser only.
+//
+// Three altitudes: the pure link/body rules (notes.js), the routes over a
+// stubbed db with an injected model and capture, and the REAL lightbulb.js over
+// a small DOM (the fake-DOM idiom of tests/paintbrush.mjs).
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import vm from 'node:vm';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const LIGHTBULB = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/lightbulb.js'), 'utf8');
+const N = require('../modules/page-notes/notes.js');
+// The real read, held before the route tests below stub the doc store.
+const realIdeasFromPage = require('../modules/page-notes/db.js').ideasFromPage;
+
+// ---------- the pure rules ----------
+
+test('the page link each idea carries is exactly what the page list looks for — from the lightbulb AND the palette', () => {
+  const page = { page_id: 'builders:studio', page_path: '/studio', page_title: 'Studio' };
+  const mine = N.ideatorIdeaBody({ title: 'A', body: 'Group the drafts by page.' }, page, 'Ana');
+  assert.match(mine, /^Group the drafts by page\.\n\nFrom Ana's ideas on Studio\. Page: \[Studio\]\(\/studio\)$/);
+  const theirs = N.ideaBody({ title: 'B', body: 'Warmer.' }, { ...page, id: 7 }, 'Bo');
+  const [bare, doc] = N.pageLinks('/studio');
+  assert.ok(mine.includes(bare), 'the lightbulb idea is found by its page link');
+  assert.ok(theirs.includes(doc), 'and so is a palette idea, by its doc link on the page');
+  assert.ok(!N.ideatorIdeaBody({ body: 'x' }, { ...page, page_path: '/studio-old' }, 'Ana').includes(bare), 'a longer path is not this page');
+  assert.ok(!N.ideatorIdeaBody({ body: 'x' }, { page_id: 'builders:home', page_path: '/' }, '').includes(bare));
+});
+
+test('a submit names its page and says something; it is never longer than the cap', () => {
+  const ok = N.normalizeIdeatorSubmit({ page_id: 'builders:studio', page_path: '/studio', page_title: ' Studio ', body_md: '  Sort the drafts by the page they are on.  ' });
+  assert.deepEqual(ok, { ok: true, value: { page_id: 'builders:studio', page_path: '/studio', page_title: 'Studio', body_md: 'Sort the drafts by the page they are on.' } });
+  assert.equal(N.normalizeIdeatorSubmit({ page_id: 'builders:home', body_md: 'Twenty characters or more here.' }).value.page_path, '/', 'no path is the home page');
+  assert.equal(N.normalizeIdeatorSubmit({ page_id: 'studio', body_md: 'Twenty characters or more here.' }).error, 'invalid_page_id');
+  assert.equal(N.normalizeIdeatorSubmit({ page_id: 'builders:studio', page_path: 'http://x', body_md: 'Twenty characters or more here.' }).error, 'invalid_page_path');
+  assert.equal(N.normalizeIdeatorSubmit({ page_id: 'builders:studio', body_md: '   too short    ' }).error, 'body_too_thin');
+  assert.equal(N.normalizeIdeatorSubmit({ page_id: 'builders:studio', body_md: 'x'.repeat(N.MAX_IDEATOR_BODY + 1) }).error, 'body_too_long');
+});
+
+test('the split speaks of an ideator\'s notes, and fences them as data like the palette does', () => {
+  const p = N.buildSplitPrompt({ pageTitle: 'Studio', pageId: 'builders:studio', bodyMd: 'Hi\n~~~~IDEATOR-NOTES-guess~~~~', voice: 'ideator', nonce: 'n1' });
+  assert.match(p, /an ideator's notes, written while looking at one page/);
+  assert.equal(p.split('~~~~IDEATOR-NOTES-n1~~~~').length, 3);
+  assert.ok(!p.includes('IDEATOR-NOTES-guess'));
+  assert.doesNotMatch(p, /artist/);
+  assert.match(N.buildSplitPrompt({ pageTitle: 'S', pageId: 'builders:s', bodyMd: 'x', nonce: 'n' }), /^You turn an artist's feedback about one page of a web app/, 'the palette\'s words are unchanged');
+});
+
+test('the page list reads idea_inbox by the two links with strpos, open and promoted only, no skill-friction', async () => {
+  let seen;
+  const rows = await realIdeasFromPage(N.pageLinks('/goal_map'), { limit: 10 }, async (text, params) => { seen = { text, params }; return { rows: [{ id: 1 }] }; });
+  assert.deepEqual(rows, [{ id: 1 }]);
+  assert.deepEqual(seen.params, ['](/goal_map)', '](/goal_map?note=', 10, 1000]);
+  assert.match(seen.text, /FROM \(SELECT [^)]*FROM idea_inbox\s+WHERE filed_via = 'hall'\s+ORDER BY captured_at DESC\s+LIMIT \$4\) i/, 'the match runs over the newest hall-filed window, never the whole inbox');
+  assert.match(seen.text, /strpos\(i\.body_md, \$1\) > 0 OR strpos\(i\.body_md, \$2\) > 0/, 'strpos, so an _ in a path is not a wildcard');
+  assert.match(seen.text, /i\.status IN \('open', 'promoted'\)/);
+  assert.match(seen.text, /i\.kind <> 'skill-friction' AND i\.title NOT LIKE '\[skill-friction\]%'/);
+});
+
+test('the palette\'s splits never push the lightbulb into the whole-text fallback: each tool has its own cap', async () => {
+  const { fileNote, fileIdeatorNotes } = require('../modules/page-notes/split.js');
+  let release;
+  const held = new Promise((r) => { release = r; });
+  const slow = { runSubagent: async () => { await held; return { stdout: '{"ideas":[{"title":"A","body":"b"}]}' }; } };
+  const note = { id: 1, page_id: 'builders:studio', page_path: '/studio', page_title: 'Studio', body_md: 'Make the title bigger please.', author_id: 9 };
+  const capture = async () => ({ id: 1 });
+  const fakeDb = { markFiled: async () => true };
+  const artists = [fileNote(note, { grade: slow, capture, db: fakeDb }), fileNote(note, { grade: slow, capture, db: fakeDb })];
+  const quick = { runSubagent: async () => ({ stdout: '{"ideas":[{"title":"One","body":"b"}]}' }) };
+  const r = await fileIdeatorNotes({ ...note, body_md: 'Sort the drafts by page.' }, { grade: quick, capture, authorId: 9, authorName: 'Ana' });
+  assert.equal(r.splitBy, 'ai', 'two palette splits in flight leave the lightbulb its own');
+  release();
+  await Promise.all(artists);
+});
+
+// ---------- the routes ----------
+
+const db = require('../modules/page-notes/db.js');
+const api = require('../src/module-api.js');
+// Nothing of the doc store may be touched: the notes are never kept.
+for (const k of Object.keys(db)) db[k] = async () => { throw new Error(`the lightbulb touched the doc store (${k})`); };
+let listed = null;
+db.ideasFromPage = async (links, opts) => { listed = { links, opts }; return [{ id: 31, title: 'Sort drafts', status: 'open', captured_at: '2026-10-04T10:00:00Z', author_name: 'Ana' }]; };
+let viewer = { id: 9, rank: 'thetes', display_name: 'Ana', github_login: 'ana' };
+api.requireBuilder = (req, res, next) => { if (!viewer) return res.status(401).json({ error: { code: 'unauthenticated' } }); req.builder = viewer; next(); };
+let captured = [];
+let captureFails = false;
+let grade = null;
+let captureOn = true;
+api.resolveOptional = (name) => {
+  if (name === 'ideas.capture') return captureOn ? async (x) => { if (captureFails) throw new Error('down'); captured.push(x); return { id: 700 + captured.length }; } : null;
+  if (name === 'grade') return grade;
+  return null;
+};
+const modelSaying = (reply, wait = 0) => ({
+  runSubagent: async ({ prompt, opts }) => {
+    assert.equal(opts.tools, '', 'the split runs with zero tools');
+    assert.match(prompt, /ideator/);
+    if (wait) await new Promise((r) => setTimeout(r, wait));
+    return { stdout: reply };
+  },
+});
+
+const express = require('express');
+const app = express();
+app.use((req, res, next) => {
+  res.fail = (code, opts) => res.status(typeof opts === 'number' ? opts : (opts && opts.status) || 400).json({ error: { code, message: opts && opts.message } });
+  next();
+});
+app.use(express.json({ limit: '64kb' }));
+app.use('/api/bongos', require('../modules/page-notes/routes/page-notes.js')());
+const server = app.listen(0);
+await new Promise((r) => server.once('listening', r));
+const base = `http://127.0.0.1:${server.address().port}/api/bongos`;
+test.after(() => server.close());
+
+function call(method, p, body) {
+  return new Promise((resolve, reject) => {
+    const data = body === undefined ? null : JSON.stringify(body);
+    const req = http.request(`${base}${p}`, { method, headers: data ? { 'content-type': 'application/json', 'content-length': Buffer.byteLength(data) } : {} }, (res) => {
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => { let j = null; try { j = JSON.parse(Buffer.concat(chunks).toString()); } catch { /* none */ } resolve({ status: res.statusCode, body: j }); });
+    });
+    req.on('error', reject);
+    if (data) req.write(data);
+    req.end();
+  });
+}
+const NOTES = { page_id: 'builders:studio', page_path: '/studio', page_title: 'Studio', body_md: 'Sort the drafts by page.\n\nAlso show who wrote each one.' };
+
+test('THE WHOLE PATH: an ideator\'s notes come back as ideas under their name, each linking to the page, and nothing is stored', async () => {
+  viewer = { id: 9, rank: 'thetes', display_name: 'Ana', github_login: 'ana' };
+  captured = []; captureFails = false; captureOn = true;
+  grade = modelSaying('{"ideas":[{"title":"Sort drafts by page","body":"Group them."},{"title":"Show each draft\'s writer","body":"Name them."}]}');
+  const r = await call('POST', '/page-notes/ideas', NOTES);
+  assert.equal(r.status, 201);
+  assert.deepEqual(r.body, { ideas: [{ id: '701', title: 'Sort drafts by page' }, { id: '702', title: 'Show each draft\'s writer' }], split_by: 'ai' });
+  assert.deepEqual(captured.map((c) => [c.capturedBy, c.filedVia]), [[9, 'hall'], [9, 'hall']], 'attributed to the ideator, filed through the hall');
+  for (const c of captured) assert.ok(c.bodyMd.endsWith("From Ana's ideas on Studio. Page: [Studio](/studio)"), 'each idea links back to the page');
+});
+
+test('FAIL-OPEN: with no model the notes file whole, as one idea', async () => {
+  captured = []; grade = null;
+  const r = await call('POST', '/page-notes/ideas', NOTES);
+  assert.equal(r.status, 201);
+  assert.equal(r.body.split_by, 'whole');
+  assert.equal(captured.length, 1);
+  assert.match(captured[0].title, /^Studio: Sort the drafts by page\./);
+});
+
+test('refusals: thin, unnamed, signed out, no inbox, nothing filed — each says so and files nothing', async () => {
+  captured = []; grade = null;
+  assert.equal((await call('POST', '/page-notes/ideas', { ...NOTES, body_md: 'short' })).body.error.code, 'body_too_thin');
+  assert.equal((await call('POST', '/page-notes/ideas', { ...NOTES, page_id: 'nope' })).status, 400);
+  assert.equal((await call('POST', '/page-notes/ideas', { page_id: 'builders:studio' })).status, 400, 'no text is refused');
+  captureOn = false;
+  assert.equal((await call('POST', '/page-notes/ideas', NOTES)).status, 503);
+  captureOn = true; captureFails = true;
+  const failed = await call('POST', '/page-notes/ideas', NOTES);
+  assert.equal(failed.status, 502);
+  assert.match(failed.body.error.message, /Your text is still here/);
+  captureFails = false;
+  viewer = null;
+  assert.equal((await call('POST', '/page-notes/ideas', NOTES)).status, 401);
+  assert.equal((await call('GET', '/page-notes/ideas?page_path=/studio')).status, 401);
+  viewer = { id: 9, rank: 'thetes', display_name: 'Ana' };
+  assert.equal(captured.length, 0);
+});
+
+test('a double press files once: a second submit while the first is filing is refused', async () => {
+  captured = [];
+  grade = modelSaying('{"ideas":[{"title":"One","body":"b"}]}', 60);
+  const [a, b] = await Promise.all([call('POST', '/page-notes/ideas', NOTES), call('POST', '/page-notes/ideas', NOTES)]);
+  assert.deepEqual([a.status, b.status].sort(), [201, 409]);
+  assert.equal(captured.length, 1);
+  assert.equal((await call('POST', '/page-notes/ideas', NOTES)).status, 201, 'and the next one, after, goes through');
+});
+
+test('the page list answers on its own path (not as a doc id) and checks the page path', async () => {
+  const r = await call('GET', '/page-notes/ideas?page_path=/studio');
+  assert.equal(r.status, 200);
+  assert.deepEqual(listed, { links: ['](/studio)', '](/studio?note='], opts: { limit: 10 } });
+  assert.deepEqual(r.body.ideas, [{ id: '31', title: 'Sort drafts', status: 'open', captured_at: '2026-10-04T10:00:00Z', author_name: 'Ana' }]);
+  assert.equal((await call('GET', '/page-notes/ideas')).status, 400);
+  assert.equal((await call('GET', '/page-notes/ideas?page_path=javascript:1')).status, 400);
+});
+
+// ---------- the panel: the REAL lightbulb.js over a small DOM ----------
+
+function unesc(s) { return s.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, '&'); }
+class El {
+  constructor(tag, doc) {
+    this.tagName = tag.toUpperCase(); this.doc = doc; this.attrs = {}; this.children = []; this.parentNode = null;
+    this.listeners = {}; this._html = ''; this.textContent = ''; this.value = ''; this.disabled = false; this.readOnly = false;
+    const cls = new Set();
+    this.classList = { add: (c) => cls.add(c), remove: (c) => cls.delete(c), contains: (c) => cls.has(c) };
+  }
+  get id() { return this.attrs.id || ''; }
+  set id(v) { this.attrs.id = String(v); }
+  set className(v) { this.attrs.class = String(v); }
+  setAttribute(k, v) { this.attrs[k] = String(v); }
+  getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; }
+  hasAttribute(k) { return k in this.attrs; }
+  appendChild(c) { c.parentNode = this; this.children.push(c); return c; }
+  removeChild(c) { this.children.splice(this.children.indexOf(c), 1); c.parentNode = null; return c; }
+  // innerHTML is parsed flat: every opening tag becomes a child carrying its
+  // attributes, which is all the panel's selectors ask of it.
+  get innerHTML() { return this._html; }
+  set innerHTML(v) {
+    this._html = String(v);
+    this.children = [];
+    const re = /<([a-z0-9]+)((?:\s+[a-z-]+(?:="[^"]*")?)*)\s*>/gi;
+    let m;
+    while ((m = re.exec(this._html))) {
+      const el = new El(m[1], this.doc);
+      for (const a of m[2].matchAll(/([a-z-]+)(?:="([^"]*)")?/gi)) el.attrs[a[1]] = a[2] === undefined ? '' : unesc(a[2]);
+      if (el.tagName === 'TEXTAREA') el.value = unesc(this._html.slice(re.lastIndex, this._html.indexOf('</textarea>', re.lastIndex)));
+      this.appendChild(el);
+    }
+  }
+  all() { return this.children.flatMap((c) => [c, ...c.all()]); }
+  is(sel) {
+    if (sel.startsWith('#')) return this.id === sel.slice(1);
+    const a = /^\[([\w-]+)\]$/.exec(sel);
+    if (a) return this.hasAttribute(a[1]);
+    return this.tagName === sel.toUpperCase();
+  }
+  querySelector(sel) { return this.all().find((n) => sel.split(',').some((s) => n.is(s.trim()))) || null; }
+  querySelectorAll(sel) { return this.all().filter((n) => sel.split(',').some((s) => n.is(s.trim()))); }
+  closest(sel) { for (let n = this; n; n = n.parentNode) if (n.is && n.is(sel)) return n; return null; }
+  addEventListener(t, fn) { (this.listeners[t] ||= []).push(fn); }
+  fire(t, e = {}) { (this.listeners[t] || []).forEach((fn) => fn({ target: this, ...e })); }
+  focus() { this.doc.activeElement = this; }
+}
+
+function boot({ storage = {}, throwing = false, respond } = {}) {
+  const doc = { activeElement: null, listeners: {}, title: 'Studio — Cloud Bongos' };
+  doc.documentElement = new El('html', doc);
+  doc.body = new El('body', doc);
+  doc.body.dataset = { page: 'studio', pageTitle: 'Studio' };
+  doc.createElement = (t) => new El(t, doc);
+  doc.addEventListener = (t, fn) => { (doc.listeners[t] ||= []).push(fn); };
+  doc.removeEventListener = (t, fn) => { doc.listeners[t] = (doc.listeners[t] || []).filter((f) => f !== fn); };
+  const calls = [];
+  const timers = [];
+  const store = {
+    getItem: (k) => { if (throwing) throw new Error('blocked'); return k in storage ? storage[k] : null; },
+    setItem: (k, v) => { if (throwing) throw new Error('blocked'); storage[k] = String(v); },
+    removeItem: (k) => { if (throwing) throw new Error('blocked'); delete storage[k]; },
+  };
+  const answer = respond || ((method) => (method === 'GET'
+    ? { ok: true, status: 200, json: { ideas: [{ id: '5', title: '<b>Bold</b> idea', author_name: 'Bo', captured_at: '2026-10-01T00:00:00Z' }] } }
+    : { ok: true, status: 201, json: { ideas: [{ id: '801', title: 'Sort drafts' }, { id: '802', title: 'Name writers' }], split_by: 'ai' } }));
+  const win = {
+    location: { pathname: '/studio' },
+    localStorage: store,
+    fetch: (url, opts) => {
+      calls.push({ url, method: opts.method, body: opts.body ? JSON.parse(opts.body) : undefined });
+      const r = answer(opts.method, url);
+      return Promise.resolve({ ok: r.ok, status: r.status, json: () => Promise.resolve(r.json) });
+    },
+    setTimeout: (fn) => { timers.push(fn); return timers.length; },
+    clearTimeout: (id) => { timers[id - 1] = null; },
+  };
+  win.window = win;
+  win.document = doc;
+  vm.runInNewContext(LIGHTBULB, win);
+  const sheet = () => doc.body.querySelector('#lightbulb');
+  const q = (sel) => sheet() && sheet().querySelector(sel);
+  return {
+    win, doc, calls, storage, sheet, q,
+    lb: win.OTBLightbulb,
+    flush: () => new Promise((r) => setTimeout(r, 0)),
+    runTimers: () => { timers.splice(0).forEach((fn) => fn && fn()); },
+    type: (text) => { q('#lb-text').value = text; q('#lb-text').fire('input'); },
+    press: (sel) => sheet().fire('click', { target: q(sel) }),
+    key: (key) => (doc.listeners.keydown || []).forEach((fn) => fn({ key, preventDefault() {} })),
+  };
+}
+
+test('opening shows a text box and this page\'s ideas — escaped, each linking to its idea; nothing else loads or posts', async () => {
+  const p = boot();
+  p.lb.open();
+  await p.flush();
+  assert.ok(p.sheet(), 'the sheet opens');
+  assert.ok(p.q('#lb-text'), 'with a text box');
+  assert.equal(p.q('input'), null, 'and no upload: the lightbulb is text only');
+  assert.deepEqual(p.calls, [{ url: '/api/bongos/page-notes/ideas?page_path=%2Fstudio', method: 'GET', body: undefined }]);
+  const list = p.q('#lb-list').innerHTML;
+  assert.match(list, /href="\/#\/idea\/5"/);
+  assert.match(list, /&lt;b&gt;Bold&lt;\/b&gt; idea/, 'a title is text, never markup');
+  assert.match(p.sheet().innerHTML, /Ideas · Studio/);
+  assert.ok(p.doc.documentElement.classList.contains('pn-open'));
+});
+
+test('unsent text waits in THIS browser, per page, and comes back on reopening', async () => {
+  const p = boot();
+  p.lb.open();
+  p.type('Sort the drafts by page, please.');
+  p.runTimers();
+  assert.equal(p.storage['hall-lightbulb:/studio'], 'Sort the drafts by page, please.');
+  assert.equal(p.calls.filter((c) => c.method !== 'GET').length, 0, 'nothing reaches the server before a submit');
+  p.key('Escape');
+  assert.equal(p.sheet(), null, 'Escape closes it');
+  p.lb.open();
+  assert.equal(p.q('#lb-text').value, 'Sort the drafts by page, please.');
+  p.type('   ');
+  p.runTimers();
+  assert.equal('hall-lightbulb:/studio' in p.storage, false, 'emptying the box forgets it');
+});
+
+test('SUBMIT files the notes for this page once, then clears the kept text and shows the ideas', async () => {
+  const p = boot({ storage: { 'hall-lightbulb:/studio': 'Sort the drafts by page.\nName who wrote each.' } });
+  p.lb.open();
+  await p.flush();
+  p.press('[data-lb-submit]');
+  p.press('[data-lb-submit]');
+  assert.equal(p.q('[data-lb-submit]').disabled, true, 'the button holds while it files');
+  await p.flush(); await p.flush();
+  const posts = p.calls.filter((c) => c.method === 'POST');
+  assert.deepEqual(posts, [{ url: '/api/bongos/page-notes/ideas', method: 'POST', body: { page_id: 'builders:studio', page_path: '/studio', page_title: 'Studio', body_md: 'Sort the drafts by page.\nName who wrote each.' } }], 'one post, for this page');
+  assert.match(p.q('#lb-body').innerHTML, /Filed as 2 ideas under your name/);
+  assert.match(p.q('#lb-body').innerHTML, /href="\/#\/idea\/801"/);
+  assert.equal('hall-lightbulb:/studio' in p.storage, false, 'the text is not kept once it is ideas');
+  p.press('[data-lb-new]');
+  assert.equal(p.q('#lb-text').value, '', 'writing more starts empty');
+});
+
+test('a refused or failed submit says why and keeps every word', async () => {
+  const p = boot({
+    storage: { 'hall-lightbulb:/studio': 'short' },
+    respond: (m) => (m === 'GET' ? { ok: true, status: 200, json: { ideas: [] } } : { ok: false, status: 502, json: { error: { message: 'Your ideas could not be filed. Your text is still here; try again in a moment.' } } }),
+  });
+  p.lb.open();
+  await p.flush();
+  assert.match(p.q('#lb-list').innerHTML, /None yet/);
+  p.press('[data-lb-submit]');
+  assert.match(p.q('#lb-error').textContent, /Write a little more/);
+  assert.equal(p.calls.filter((c) => c.method === 'POST').length, 0, 'too little text never posts');
+  p.type('Long enough to be an idea now.');
+  p.press('[data-lb-submit]');
+  await p.flush(); await p.flush();
+  assert.match(p.q('#lb-error').textContent, /could not be filed/);
+  assert.equal(p.q('[data-lb-submit]').disabled, false, 'the button comes back');
+  assert.equal(p.q('#lb-text').readOnly, false);
+  assert.equal(p.q('#lb-text').value, 'Long enough to be an idea now.');
+  assert.equal(p.storage['hall-lightbulb:/studio'], 'Long enough to be an idea now.', 'and the browser still holds it');
+});
+
+test('storage that throws keeps nothing, and the panel still files', async () => {
+  const p = boot({ throwing: true });
+  p.lb.open();
+  p.type('Twenty characters or more of ideas.');
+  p.runTimers();
+  p.press('[data-lb-submit]');
+  await p.flush(); await p.flush();
+  assert.match(p.q('#lb-body').innerHTML, /Filed as 2 ideas/);
+});
+
+test('craft-mode.js gives the tool its OWN icon, so it is never read as the Ideating pill beside it (owner, 2026-10-04)', () => {
+  const craft = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/craft-mode.js'), 'utf8');
+  assert.match(craft, /\{ id: 'lightbulb', icon: 'note', short: 'Ideas', label: 'Write ideas about this page', script: 'lightbulb\.js', api: 'OTBLightbulb' \}/);
+  assert.match(craft, /^ {4}note: '<path /m, 'the note glyph is drawn');
+  assert.doesNotMatch(/ideating: \[([\s\S]*?)\]/.exec(/var TOOLS = \{([\s\S]*?)\n {2}\};/.exec(craft)[1])[1], /icon: 'ideating'/);
+});
+
+test('the only route it calls is the lightbulb\'s own, and it rides the palette\'s styles', () => {
+  const urls = LIGHTBULB.match(/\/api\/[a-z/-]+/g);
+  assert.deepEqual([...new Set(urls)], ['/api/bongos/page-notes/ideas']);
+  assert.doesNotMatch(LIGHTBULB, /type="file"|FileReader/, 'no uploads');
+  assert.doesNotMatch(LIGHTBULB, /#[0-9a-f]{3,6}\b|rgb\(/i, 'no colour literals: the look is style.css\'s');
+});

package/tests/page_notes_panel.mjs

@@ -80,10 +80,12 @@ test('THE PALETTE: in the top bar in Artistry alone, right before the switch, an
   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']) {
+  for (const m of ['building', 'governing']) {
     p.craft.choose(m);
     assert.equal(p.tools().length, 0, `no palette in ${m}`);
   }
+  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');
   p.craft.choose('artistry');
   assert.equal(p.tools().length, 2, 'choosing Artistry twice draws one palette and one paintbrush');

package/tests/paintbrush.mjs

@@ -184,7 +184,8 @@ test('craft-mode.js puts the paintbrush beside the palette in Artistry, loading
   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');
+  assert.doesNotMatch(tools, /building:|governing:/, 'Building and Governing have none');
+  assert.doesNotMatch(/ideating: \[([\s\S]*?)\]/.exec(tools)[1], /paintbrush/, 'and the paintbrush is not Ideating\'s (task 1004498)');
 });
 
 test('pressing it on a page nobody holds OFFERS the page — nothing is editable and nothing is written until the artist takes it', async () => {