@bongos/core 1.24.27 → 1.24.29

package/tests/speciality_walkthrough_ui.mjs

@@ -1,5 +1,6 @@
-// tests/speciality_walkthrough_ui.mjs — the skills walkthrough a person is taken
-// through when they adopt a speciality (task 1004073, part 2 of 3 of ADR 0310).
+// tests/speciality_walkthrough_ui.mjs — the ADOPTER's side of the speciality
+// tools: taking one on, the skills walkthrough it opens, and stopping it (task
+// 1004073, part 2 of 3 of ADR 0310; on My agents too since task 1005052).
 //
 // The owner's ruling: an adopted speciality's skills start OFF, "and you should
 // walk through what comes with each, people need to learn the system". The task
@@ -9,21 +10,21 @@
 // every step, no control that decides without the person seeing each skill, and
 // nothing written until the recap is saved.
 //
-// This EXECUTES the real modules/hall-ui/public/settings-specialities.js in a vm
-// under a minimal DOM stub (the tests/goal_criterion_confirm_ui.mjs precedent —
-// there is no jsdom here), against a fake API, and drives real clicks through the
-// delegated handler the page wires.
+// THE SAFETY STEP. A speciality someone else wrote puts their prose into your
+// sessions, so its full instructions are on the card, open, before the control
+// that adopts it — pinned below on My agents.
+//
+// ONE COMPONENT, ONE HOST. modules/hall-ui/public/speciality-tools.js was mounted
+// by Settings and by My agents (task 1005052); since task 1005044 My agents is the
+// only page that edits a speciality, and Settings links there. Every case runs on
+// each page in SPECIALITY_PAGES, booted on THAT page's own markup
+// (tests/helpers.mjs bootSpecialityTools), so a host lost from it fails its run.
+// tests/hall_settings_world.mjs pins that Settings no longer mounts it.
 //
 // Run:  node tests/speciality_walkthrough_ui.mjs
 import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import vm from 'node:vm';
-import { fileURLToPath } from 'node:url';
-import { makeRunner } from './helpers.mjs';
-
-const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/settings-specialities.js'), 'utf8');
+import { makeRunner, bootSpecialityTools, SPECIALITY_PAGES } from './helpers.mjs';
+
 const { test, summary } = makeRunner();
 
 const explained = (name, extra = {}) => ({
@@ -56,163 +57,183 @@ const SKILLS_BODY = {
   ],
 };
 
-// Boot the page script and return a handle to drive it.
-async function boot({ catalog = [speciality()], skillsBody = SKILLS_BODY } = {}) {
-  const requests = [];
-  const toasts = [];
-  const els = new Map();
-  const handlers = new Map();
-  const makeEl = (id) => ({
-    id, hidden: id === 'specialities-scroll', innerHTML: '', textContent: '', elements: {},
-    addEventListener(type, fn) { handlers.set(`${id}:${type}`, fn); },
-  });
-  for (const id of ['specialities-scroll', 'specialities-rows', 'speciality-suggestions', 'specialities-status']) els.set(id, makeEl(id));
-  let focused = null;
-
-  const fetch = async (url, opts = {}) => {
-    const method = opts.method || 'GET';
-    const p = url.replace('/api/bongos', '');
-    requests.push({ method, path: p, body: opts.body ? JSON.parse(opts.body) : undefined });
-    let body = {};
-    if (method === 'GET' && p === '/specialities') body = { specialities: catalog };
-    else if (method === 'GET' && p === '/me/specialities') body = { adoptions: [] };
-    else if (method === 'GET' && p === '/specialities/offered') body = { suggestions: [] };
-    else if (method === 'GET' && /\/skills$/.test(p)) body = skillsBody;
-    else if (method === 'POST' && /\/adopt$/.test(p)) body = { adoption: { active: true } };
-    else if (method === 'PUT' && /\/skills$/.test(p)) body = { adoption: { enabled_skills: JSON.parse(opts.body).enabled_skills } };
-    return { ok: true, status: 200, json: async () => body };
-  };
-
-  const document = {
-    readyState: 'complete',
-    getElementById: (id) => els.get(id) || null,
-    addEventListener() {},
-    querySelector: (sel) => (sel.includes('data-walk-focus') ? { focus() { focused = 'walk-heading'; } } : null),
-  };
-  const window = {
-    OTB: {
-      escapeHtml: (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'),
-      $: () => null,
-      toast: (m) => toasts.push(m),
-      roleAxisLabel: () => 'Role',
-    },
-    location: { assign() {} },
-  };
-  vm.runInNewContext(SRC, { window, document, fetch, JSON, Promise, Map, Set, String, Number, Array, Object, Math, RegExp, console });
-  const settle = () => new Promise((r) => setTimeout(r, 0));
-  for (let i = 0; i < 5; i++) await settle();
-
-  const rows = els.get('specialities-rows');
-  // A click through the delegated handler, on the first button whose attribute matches.
-  async function click(attr, value) {
-    const re = new RegExp(`<button[^>]*${attr}="${value}"[^>]*>`);
-    const tag = re.exec(rows.innerHTML);
-    assert.ok(tag, `no ${attr}="${value}" button in:\n${rows.innerHTML}`);
-    const dataset = {};
-    for (const [, k, v] of tag[0].matchAll(/data-([a-z]+)="([^"]*)"/g)) dataset[k] = v;
-    const btn = { dataset };
-    const target = { closest: (sel) => (sel === `button[${attr}]` ? btn : null) };
-    handlers.get('specialities-rows:click')({ target });
-    for (let i = 0; i < 6; i++) await settle();
-  }
-  const text = () => rows.innerHTML.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ');
-  return { els, rows, requests, toasts, click, text, focused: () => focused };
+async function boot(page, { catalog = [speciality()], skillsBody = SKILLS_BODY, ...rest } = {}) {
+  const h = bootSpecialityTools({ page, catalog, skills: { 9: skillsBody }, ...rest });
+  await h.ready();
+  return h;
 }
+const ROWS = '#specialities-rows';
+const writes = (h) => h.writes();
+const text = (h) => h.text('specialities-rows');
+
+for (const page of SPECIALITY_PAGES) {
+  await test(`${page}: the specialities panel is revealed once its reads answer — it shipped hidden and nothing ever showed it`, async () => {
+    const h = await boot(page);
+    assert.equal(h.el('specialities-scroll').hidden, false);
+  });
 
-const writes = (h) => h.requests.filter((r) => r.method !== 'GET');
+  await test(`${page}: adopting a speciality that offers skills opens the walkthrough on the FIRST skill, with nothing written yet`, async () => {
+    const h = await boot(page);
+    await h.click(`${ROWS} button[data-act="adopt"]`);
+    assert.ok(h.requests.some((r) => r.method === 'GET' && r.path === '/specialities/9/skills'), 'the walkthrough read its skills');
+    assert.match(text(h), /Skill 1 of 3 in Economics/, 'only INSTALLED skills are steps');
+    assert.ok(h.focused() && 'data-walk-focus' in h.focused().attrs, 'focus moves to the step, not left on a button that is gone');
+    assert.deepEqual(writes(h).map((r) => r.path), ['/specialities/9/adopt'], 'no enabled set was written by adopting');
+  });
 
-await test('the specialities panel is revealed once its reads answer — it shipped hidden and nothing ever showed it', async () => {
-  const h = await boot();
-  assert.equal(h.els.get('specialities-scroll').hidden, false);
-});
+  await test(`${page}: it is not a page of checkboxes: one skill per step, and no control decides for several at once`, async () => {
+    const h = await boot(page);
+    await h.click(`${ROWS} button[data-act="adopt"]`);
+    assert.ok(!/type="checkbox"/.test(h.html('specialities-rows')), 'no checkbox anywhere in the walkthrough');
+    assert.ok(!/(turn|enable|select) (them )?all/i.test(text(h)), 'no "turn them all on"');
+    assert.ok(text(h).includes('recall') && !text(h).includes('status does its one thing'), 'the next skill is not shown yet');
+  });
 
-await test('adopting a speciality that offers skills opens the walkthrough on the FIRST skill, with nothing written yet', async () => {
-  const h = await boot();
-  await h.click('data-act', 'adopt');
-  assert.ok(h.requests.some((r) => r.method === 'GET' && r.path === '/specialities/9/skills'), 'the walkthrough read its skills');
-  assert.match(h.text(), /Skill 1 of 3 in Economics/, 'only INSTALLED skills are steps');
-  assert.equal(h.focused(), 'walk-heading', 'focus moves to the step, not left on a button that is gone');
-  assert.deepEqual(writes(h).map((r) => r.path), ['/specialities/9/adopt'], 'no enabled set was written by adopting');
-});
+  await test(`${page}: every step answers what it does, when to reach for it, and what it costs`, async () => {
+    const h = await boot(page);
+    await h.click(`${ROWS} button[data-act="adopt"]`);
+    for (let step = 0; step < 3; step++) {
+      for (const q of ['What it does', 'When to reach for it', 'What it costs']) assert.ok(text(h).includes(q), `step ${step + 1} is missing "${q}"`);
+      await h.click(`${ROWS} button[data-walk="off"]`);
+    }
+  });
 
-await test('it is not a page of checkboxes: one skill per step, and no control decides for several at once', async () => {
-  const h = await boot();
-  await h.click('data-act', 'adopt');
-  assert.ok(!/type="checkbox"/.test(h.rows.innerHTML), 'no checkbox anywhere in the walkthrough');
-  assert.ok(!/(turn|enable|select) (them )?all/i.test(h.text()), 'no "turn them all on"');
-  assert.ok(h.text().includes('recall') && !h.text().includes('status does its one thing'), 'the next skill is not shown yet');
-});
+  await test(`${page}: a rank-gated skill says so BEFORE the choice — turning it on grants nothing`, async () => {
+    const h = await boot(page);
+    await h.click(`${ROWS} button[data-act="adopt"]`);
+    await h.click(`${ROWS} button[data-walk="off"]`);
+    await h.click(`${ROWS} button[data-walk="off"]`);
+    const t = text(h);
+    assert.match(t, /Skill 3 of 3/);
+    assert.match(t, /Metic rank or above.*does not change that/);
+    assert.match(t, /What it needs on your machine gh/);
+  });
 
-await test('every step answers what it does, when to reach for it, and what it costs', async () => {
-  const h = await boot();
-  await h.click('data-act', 'adopt');
-  for (let step = 0; step < 3; step++) {
-    const t = h.text();
-    for (const q of ['What it does', 'When to reach for it', 'What it costs']) assert.ok(t.includes(q), `step ${step + 1} is missing "${q}"`);
-    await h.click('data-walk', 'off');
-  }
-});
+  await test(`${page}: the recap names every skill with what it does and the choice made, then saves exactly the ones turned on`, async () => {
+    const h = await boot(page);
+    await h.click(`${ROWS} button[data-act="adopt"]`);
+    await h.click(`${ROWS} button[data-walk="on"]`);
+    await h.click(`${ROWS} button[data-walk="off"]`);
+    await h.click(`${ROWS} button[data-walk="on"]`);
+    const t = text(h);
+    assert.match(t, /Your choices for Economics/);
+    assert.match(t, /2 of 3 turned on/);
+    for (const n of ['recall', 'status', 'goal-review']) assert.ok(t.includes(`${n} does its one thing.`), `the recap restates what ${n} does`);
+    assert.ok(!t.includes('And a second sentence'), 'one line each, not the whole description again');
+    assert.match(t, /no longer on this project.*gone/, 'an offered skill removed since is named, not offered');
+    assert.equal(writes(h).length, 1, 'still nothing written before Save');
+    await h.click(`${ROWS} button[data-walk="save"]`);
+    const put = writes(h).find((r) => r.method === 'PUT');
+    assert.ok(put, 'Save wrote the set');
+    assert.equal(put.path, '/specialities/9/skills');
+    assert.deepEqual(put.body, { enabled_skills: ['recall', 'goal-review'] });
+    assert.ok(h.toasts.some((m) => /2 of 3/.test(m)));
+  });
 
-await test('a rank-gated skill says so BEFORE the choice — turning it on grants nothing', async () => {
-  const h = await boot();
-  await h.click('data-act', 'adopt');
-  await h.click('data-walk', 'off');
-  await h.click('data-walk', 'off');
-  const t = h.text();
-  assert.match(t, /Skill 3 of 3/);
-  assert.match(t, /Metic rank or above.*does not change that/);
-  assert.match(t, /What it needs on your machine gh/);
-});
+  await test(`${page}: Back revisits a decision and the new choice is the one saved`, async () => {
+    const h = await boot(page);
+    await h.click(`${ROWS} button[data-act="adopt"]`);
+    await h.click(`${ROWS} button[data-walk="on"]`);
+    await h.click(`${ROWS} button[data-walk="back"]`);
+    assert.match(text(h), /Skill 1 of 3/);
+    assert.match(h.html('specialities-rows'), /data-walk="on" aria-pressed="true"/, 'the earlier choice shows when you step back to it');
+    await h.click(`${ROWS} button[data-walk="off"]`);
+    await h.click(`${ROWS} button[data-walk="off"]`);
+    await h.click(`${ROWS} button[data-walk="off"]`);
+    await h.click(`${ROWS} button[data-walk="save"]`);
+    assert.deepEqual(writes(h).find((r) => r.method === 'PUT').body, { enabled_skills: [] });
+  });
 
-await test('the recap names every skill with what it does and the choice made, then saves exactly the ones turned on', async () => {
-  const h = await boot();
-  await h.click('data-act', 'adopt');
-  await h.click('data-walk', 'on');
-  await h.click('data-walk', 'off');
-  await h.click('data-walk', 'on');
-  const t = h.text();
-  assert.match(t, /Your choices for Economics/);
-  assert.match(t, /2 of 3 turned on/);
-  for (const n of ['recall', 'status', 'goal-review']) assert.ok(t.includes(`${n} does its one thing.`), `the recap restates what ${n} does`);
-  assert.ok(!t.includes('And a second sentence'), 'one line each, not the whole description again');
-  assert.match(t, /no longer on this project.*gone/, 'an offered skill removed since is named, not offered');
-  assert.equal(writes(h).length, 1, 'still nothing written before Save');
-  await h.click('data-walk', 'save');
-  const put = writes(h).find((r) => r.method === 'PUT');
-  assert.ok(put, 'Save wrote the set');
-  assert.equal(put.path, '/specialities/9/skills');
-  assert.deepEqual(put.body, { enabled_skills: ['recall', 'goal-review'] });
-  assert.ok(h.toasts.some((m) => /2 of 3/.test(m)));
-});
+  await test(`${page}: finishing later writes nothing, so every skill stays off — the default the ruling asked for`, async () => {
+    const h = await boot(page);
+    await h.click(`${ROWS} button[data-act="adopt"]`);
+    await h.click(`${ROWS} button[data-walk="on"]`);
+    await h.click(`${ROWS} button[data-walk="close"]`);
+    assert.ok(!/skill-walk/.test(h.html('specialities-rows')), 'the walkthrough closed');
+    assert.ok(!writes(h).some((r) => r.method === 'PUT'), 'a half-finished walk saves nothing');
+  });
 
-await test('Back revisits a decision and the new choice is the one saved', async () => {
-  const h = await boot();
-  await h.click('data-act', 'adopt');
-  await h.click('data-walk', 'on');
-  await h.click('data-walk', 'back');
-  assert.match(h.text(), /Skill 1 of 3/);
-  assert.match(h.rows.innerHTML, /data-walk="on" aria-pressed="true"/, 'the earlier choice shows when you step back to it');
-  await h.click('data-walk', 'off');
-  await h.click('data-walk', 'off');
-  await h.click('data-walk', 'off');
-  await h.click('data-walk', 'save');
-  assert.deepEqual(writes(h).find((r) => r.method === 'PUT').body, { enabled_skills: [] });
-});
+  await test(`${page}: a speciality that offers no skills adopts without a walkthrough`, async () => {
+    const h = await boot(page, { catalog: [speciality({ skills: [] })] });
+    await h.click(`${ROWS} button[data-act="adopt"]`);
+    assert.ok(!h.requests.some((r) => /\/skills$/.test(r.path)), 'no skills read for a speciality with none');
+    assert.ok(!/skill-walk/.test(h.html('specialities-rows')));
+  });
 
-await test('finishing later writes nothing, so every skill stays off — the default the ruling asked for', async () => {
-  const h = await boot();
-  await h.click('data-act', 'adopt');
-  await h.click('data-walk', 'on');
-  await h.click('data-walk', 'close');
-  assert.ok(!/skill-walk/.test(h.rows.innerHTML), 'the walkthrough closed');
-  assert.ok(!writes(h).some((r) => r.method === 'PUT'), 'a half-finished walk saves nothing');
-});
+  // ---- the safety step, and the rest of the adopter's tools (task 1005052) ----
+
+  await test(`${page}: SAFETY — someone else's speciality shows its full instructions, open, in the same card as the only control that adopts it`, async () => {
+    const contract = 'Argue from mechanism, not vibes.\nAlways name the assumption a number rests on.';
+    const h = await boot(page, { catalog: [speciality({ contract_md: contract })], suggestions: [speciality({ id: 21, name: 'Rates', contract_md: contract })] });
+    for (const host of ['specialities-rows', 'speciality-suggestions']) {
+      const card = h.find(`#${host} li[data-id]`);
+      assert.ok(card, `${host}: the speciality has a card`);
+      const details = card.querySelector('details');
+      assert.ok(details && details.open, `${host}: its instructions are OPEN, not folded behind a summary`);
+      assert.equal(card.querySelector('pre').textContent, contract, `${host}: the whole instruction, word for word`);
+      assert.match(card.querySelector('summary').textContent, /written by someone else/, `${host}: and whose they are`);
+      assert.match(details.textContent, /You did not write this\. Read it before using the speciality/);
+      assert.ok(card.querySelector('button[data-act="adopt"]'), `${host}: the adopt control is in that same card`);
+    }
+    assert.equal(h.find('button[data-adopt]'), null, 'no other control adopts it');
+  });
 
-await test('a speciality that offers no skills adopts without a walkthrough', async () => {
-  const h = await boot({ catalog: [speciality({ skills: [] })] });
-  await h.click('data-act', 'adopt');
-  assert.ok(!h.requests.some((r) => /\/skills$/.test(r.path)), 'no skills read for a speciality with none');
-  assert.ok(!/skill-walk/.test(h.rows.innerHTML));
-});
+  await test(`${page}: a speciality you use can be stopped: one POST /abandon, and the card offers it again`, async () => {
+    const h = await boot(page, { adoptions: [{ id: 9, active: true, enabled_skills: ['recall'] }] });
+    assert.match(text(h), /active/, 'the card says it is in use');
+    assert.match(text(h), /offers 4 skills, 1 on for you/, 'and how many of its skills are on');
+    assert.equal(h.find(`${ROWS} button[data-act="adopt"]`), null, 'in use: no "Use this"');
+    await h.click(`${ROWS} button[data-act="abandon"]`);
+    assert.deepEqual(writes(h).map((r) => `${r.method} ${r.path}`), ['POST /specialities/9/abandon']);
+    assert.ok(h.toasts.includes('Stopped using it.'));
+    assert.ok(h.find(`${ROWS} button[data-act="adopt"]`), 'stopped: it can be taken on again');
+    assert.equal(h.find(`${ROWS} button[data-act="abandon"]`), null);
+  });
+
+  await test(`${page}: stopping a speciality closes its walkthrough if it was open`, async () => {
+    const h = await boot(page, { adoptions: [{ id: 9, active: true, enabled_skills: [] }] });
+    await h.click(`${ROWS} button[data-act="walk"]`);
+    assert.match(h.html('specialities-rows'), /skill-walk/);
+    await h.click(`${ROWS} button[data-act="abandon"]`);
+    assert.ok(!/skill-walk/.test(h.html('specialities-rows')), 'no walkthrough for a speciality you stopped using');
+  });
+
+  await test(`${page}: "Choose its skills" reopens the walkthrough for one you use, and says which are on now`, async () => {
+    const h = await boot(page, { adoptions: [{ id: 9, active: true, enabled_skills: ['recall'] }], skillsBody: { ...SKILLS_BODY, enabled: ['recall'] } });
+    await h.click(`${ROWS} button[data-act="walk"]`);
+    assert.match(text(h), /Skill 1 of 3 in Economics/);
+    assert.match(text(h), /You have this one on at the moment/);
+    assert.equal(writes(h).length, 0, 'opening it writes nothing');
+  });
+
+  await test(`${page}: a suggestion adopts through the same act as the catalogue`, async () => {
+    const h = await boot(page, { suggestions: [speciality({ id: 21, name: 'Rates', skills: [] })] });
+    assert.match(h.text('speciality-suggestions'), /Suggested for you.*Rates/);
+    await h.click('#speciality-suggestions button[data-act="adopt"]');
+    assert.deepEqual(writes(h).map((r) => `${r.method} ${r.path}`), ['POST /specialities/21/adopt']);
+  });
+
+  await test(`${page}: adopting, stopping and saving its skills each tell the rest of the page, so what a session reads can be re-read`, async () => {
+    const h = await boot(page);
+    await h.click(`${ROWS} button[data-act="adopt"]`);
+    assert.deepEqual(h.events, ['otb:specialities-changed'], 'adopting');
+    for (let i = 0; i < 3; i++) await h.click(`${ROWS} button[data-walk="off"]`);
+    await h.click(`${ROWS} button[data-walk="save"]`);
+    assert.equal(h.events.length, 2, 'saving the skills');
+    await h.click(`${ROWS} button[data-act="abandon"]`);
+    assert.equal(h.events.length, 3, 'stopping');
+    const quiet = await boot(page, { catalog: [speciality({ mine: true })] });
+    await quiet.click(`${ROWS} button[data-act="train"]`);
+    assert.deepEqual(quiet.events, [], 'opening a tool that changes no session says nothing');
+  });
+
+  await test(`${page}: a refused adopt says why and changes nothing`, async () => {
+    const h = await boot(page, { answer: (m, p) => (m === 'POST' && /\/adopt$/.test(p) ? { status: 409, data: { message: 'already_adopted' } } : null) });
+    await h.click(`${ROWS} button[data-act="adopt"]`);
+    assert.equal(h.el('specialities-status').textContent, 'already_adopted');
+    assert.ok(!/skill-walk/.test(h.html('specialities-rows')), 'no walkthrough for an adopt that did not happen');
+    assert.deepEqual(h.events, [], 'and nothing told the page it changed');
+  });
+}
 
 summary();

package/modules/hall-ui/public/settings-interaction.js

@@ -1,132 +0,0 @@
-// modules/hall-ui/public/settings-interaction.js — the "How Claude talks to you"
-// panel on /builders/settings (task 2010's profile, delivered by task 1002514).
-//
-// WHY THE PANEL EXISTS. The interaction profile shipped complete except for a
-// way to set it: interaction-prefs.js stored it, GET/PATCH /me/interaction served
-// it, and the conductor hook already injected the resolved contract into every
-// session — but settings.js had 18 `wandering` references and 0 `interaction`
-// ones, so the profile was reachable only by a raw API call. In practice that
-// meant nobody had one.
-//
-// Its own file rather than more of settings.js, on the settings-sessions.js
-// precedent and for the same stated reason: settings.js sits against the
-// 1500-line size ratchet (adding this inline pushed it to 1601 and regressed the
-// budget). The panel is self-contained — it shares nothing with the rest of the
-// page but the `window.OTB` toolkit and the generated API client, both globals
-// loaded before it.
-//
-// THE ONE SHAPE DIFFERENCE FROM WANDERING, which is the sibling to read first:
-// wandering is a single level, so it is one radiogroup. This payload is a FIELD
-// CATALOG — several independent fields, each with its own value set — so each
-// field is its own single-select and a PATCH carries only the field that changed
-// ({ <field>: <value> }). The route merges, so the untouched fields keep their
-// values and a field never explicitly set keeps falling back to its default.
-
-(() => {
-  'use strict';
-
-  const API = '/api/bongos';
-  const { escapeHtml, $ } = window.OTB;
-  const toast = (msg) => window.OTB.toast(msg);
-  const api = window.BongosClient.createClient({ baseUrl: '', credentials: 'same-origin', throwOnError: false });
-
-  const toAuth = () => window.location.assign(`${API}/auth/web/start`);
-  // the project's laws on these fields (task 1004724): settings-law-locks.js
-  const Laws = window.OTBSettingsLaws || { lockFor: () => null, allows: () => true, lawLine: () => '', tagFor: () => '' };
-
-  function render(data) {
-    const wrap = $('#interaction-rows');
-    if (!wrap) return;
-    const fields = Array.isArray(data && data.fields) ? data.fields : [];
-    const eff = (data && data.effective) || {};
-    if (fields.length === 0) {
-      wrap.innerHTML = window.OTBKit.emptyStateHtml('No interaction settings registered.');
-      return;
-    }
-    // A fieldset per field so the field's label is its radiogroup's accessible
-    // name — four independent single-selects, not one flat list of radios.
-    wrap.innerHTML = fields.map((f) => {
-      const chosenValue = eff[f.field];
-      const lock = Laws.lockFor(data, f.field);
-      const rows = (f.values || []).map((v) => {
-        const id = `interaction-${f.field}-${v.value}`;
-        const chosen = v.value === chosenValue;
-        const barred = !Laws.allows(lock, v.value);
-        // No "default" tag here, deliberately: interaction-prefs.js already ends
-        // every default value's LABEL with "(default)", so adding the row tag the
-        // wandering picker uses rendered "Non-technical (default) · DEFAULT".
-        // One source for the word, and it is the label the API already ships.
-        return (
-          `<label class="prow prow--pick" for="${id}"${barred ? ' aria-disabled="true"' : ''}>` +
-          `<input class="pradio" type="radio" name="interaction-${escapeHtml(f.field)}" id="${id}"` +
-          ` value="${escapeHtml(v.value)}" data-field="${escapeHtml(f.field)}"${chosen ? ' checked' : ''}${barred ? ' disabled' : ''}>` +
-          '<span class="prow__main">' +
-          `<span class="prow__label">${escapeHtml(v.label)}</span>` +
-          '</span></label>'
-        );
-      }).join('');
-      return (
-        `<fieldset class="pgroup" id="interaction-field-${escapeHtml(f.field)}">` +
-        `<legend class="prow__label">${escapeHtml(f.label)}</legend>` +
-        `<p class="prow__desc">${escapeHtml(f.blurb || '')}</p>` +
-        (lock ? `<p class="prow__desc prow__law" data-law="${escapeHtml(String(lock.law_no || ''))}">${escapeHtml(Laws.lawLine(lock))}</p>` : '') +
-        rows +
-        '</fieldset>'
-      );
-    }).join('');
-  }
-
-  // The human label for a saved value, for the status line — falls back to the
-  // raw value rather than going blank if the catalog and the payload disagree.
-  function labelFor(data, field, value) {
-    const f = (Array.isArray(data && data.fields) ? data.fields : []).find((x) => x.field === field);
-    const v = f && (f.values || []).find((x) => x.value === value);
-    return (v && v.label) || value;
-  }
-
-  async function save(field, value, input) {
-    const status = $('#interaction-status');
-    if (status) status.textContent = 'Saving…';
-    if (input) input.disabled = true;
-    try {
-      const res = await api.request('PATCH', `${API}/me/interaction`, { body: { [field]: value } });
-      if (res.status === 401) { toAuth(); return; }
-      if (!res.ok) throw new Error(`interaction PATCH → ${res.status}`);
-      render(res.data);
-      const msg = `Saved — ${labelFor(res.data, field, value)}.`;
-      if (status) status.textContent = msg;
-      toast(msg);
-    } catch (err) {
-      console.error('[settings] save interaction failed', err);
-      if (status) status.textContent = 'Could not save. Try again.';
-      toast('Could not save your interaction profile. Try again.');
-      if (input) input.disabled = false;
-    }
-  }
-
-  async function setup() {
-    try {
-      const res = await api.request('GET', `${API}/me/interaction`);
-      if (res.status === 401) { toAuth(); return; }
-      if (!res.ok) throw new Error(`interaction GET → ${res.status}`);
-      render(res.data);
-      $('#interaction-scroll').hidden = false;
-      // Delegate the change so post-render radios stay wired.
-      $('#interaction-rows').addEventListener('change', (e) => {
-        const r = e.target.closest('.pradio');
-        if (!r || r.disabled || !r.checked) return;
-        const field = r.getAttribute('data-field');
-        if (field) save(field, r.value, r);
-      });
-    } catch (err) {
-      // Its own try/catch, like every other section: a failing endpoint shows this
-      // panel's own error rather than taking the settings page down with it.
-      console.error('[settings] failed to load interaction', err);
-      $('#interaction-scroll').hidden = false;
-      $('#interaction-rows').innerHTML =
-        '<p class="voices-empty">Your interaction profile could not be loaded. Reload the page to try again.</p>';
-    }
-  }
-
-  setup();
-})();

package/modules/hall-ui/public/settings-law-locks.js

@@ -1,53 +0,0 @@
-// modules/hall-ui/public/settings-law-locks.js — the project's LAWS on the
-// /builders/settings rows (task 1004724).
-//
-// A law passed by the project's government may lock a personal setting: FIX it
-// to one value, or CAP it. The server enforces the lock (law-locks.js, task
-// 1004707) and every settings read already reports it as `law_locks` — this file
-// is only how the page SAYS so: a value the lock does not allow is a disabled
-// row tagged with the law, and the setting carries one line naming the law.
-// Shared by the "How Claude talks to you" panel (settings-interaction.js) and the
-// wandering picker (settings.js). The page decides nothing; a write the law
-// forbids is refused by the route either way (409 locked_by_law).
-//
-// PURE: no DOM, no fetch. tests/settings_law_locks.mjs requires it in node.
-
-(function (root) {
-  'use strict';
-
-  const str = (v) => (v == null ? '' : String(v));
-
-  // The lock a law puts on `setting`, from a settings read's `law_locks`, or null.
-  // Only an ENFORCED lock counts: one naming no real value locks nothing.
-  function lockFor(data, setting) {
-    const locks = data && Array.isArray(data.law_locks) ? data.law_locks : [];
-    return locks.find((l) => l && l.enforced === true && str(l.setting) === str(setting)) || null;
-  }
-
-  // May `value` still be picked under `lock`? No lock: yes.
-  function allows(lock, value) {
-    if (!lock) return true;
-    if (!Array.isArray(lock.allowed)) return true;
-    return lock.allowed.map(str).includes(str(value));
-  }
-
-  // The one line the setting carries: which law, and what it does to the row.
-  function lawLine(lock) {
-    if (!lock) return '';
-    const n = lock.law_no != null ? 'Law ' + str(lock.law_no) : 'A law';
-    const text = str(lock.law_text).trim();
-    const what = Object.prototype.hasOwnProperty.call(lock, 'value')
-      ? ' sets this for every agent in the project'
-      : ' caps this for every agent in the project';
-    return n + what + (text ? ': "' + text + '".' : '.') + ' Only a vote can change it.';
-  }
-
-  // The tag a row the lock rules out wears.
-  function tagFor(lock) {
-    return lock ? 'set by ' + (lock.law_no != null ? 'law ' + str(lock.law_no) : 'a law') : '';
-  }
-
-  const api = { lockFor, allows, lawLine, tagFor };
-  root.OTBSettingsLaws = api;
-  if (typeof module !== 'undefined' && module.exports) module.exports = api;
-}(typeof window !== 'undefined' ? window : globalThis));