@bongos/core 1.24.26 → 1.24.28

package/tests/core_upgrade_owner_door.mjs

@@ -430,26 +430,12 @@ function boot({ provisioning, deployUrl, pathname = '/settings', hash = '', held
   vm.runInContext(SHELL, sandbox, { filename: 'shell.js' });
   windowObj.OTBShell.applyAccess({ authed: true, rank: 'archon', permissions: { 'core.pin.move': true } });
   return {
-    banner: () => inserted.find((e) => String(e._html).includes('is available')),
-    notice: () => inserted.find((e) => e.id === 'core-update-notice'),
     deployItem: () => els.get('nav-deploy'),
   };
 }
 const settle = () => new Promise((r) => setTimeout(r, 0));
 const HUB = 'https://cloudbongos.com/deploy?project=hoodify-finance';
 
-// Task 1004296 moved the hand-off: a hall without a door of its own sends its owner to
-// Settings → Software update, whose Update button carries the hub address (GET
-// /software-update's `door`). The banner and the rail no longer link off-site.
-await t('on a hosted project, the banner\'s Upgrade goes to Settings → Software update, not off-site', async () => {
-  const b = boot({ provisioning: false, deployUrl: HUB });
-  await settle();
-  assert.ok(b.banner(), 'the banner renders');
-  assert.match(b.banner().innerHTML, /href="\/settings#software-update"/, 'Upgrade opens the Software update panel');
-  assert.ok(!b.banner().innerHTML.includes(HUB), 'never the hub address directly, even when an older server sends one');
-  assert.doesNotMatch(b.banner().innerHTML, /href="\/deploy"/, 'never the local /deploy, which this hall no longer has');
-});
-
 await t('on a hosted project, the rail\'s Deploy item stays hidden — it is the platform hall\'s page', async () => {
   const b = boot({ provisioning: false, deployUrl: HUB });
   await settle();
@@ -458,54 +444,16 @@ await t('on a hosted project, the rail\'s Deploy item stays hidden — it is the
   assert.equal(item.dataset.module, 'provisioning', 'its module gate stays, so a hall without the door hides it');
 });
 
-await t('a hall with no door of its own and no hub still links to Software update', async () => {
-  for (const url of [null, 'javascript:alert(1)', 42]) {
-    const b = boot({ provisioning: false, deployUrl: url });
-    await settle();
-    assert.match(b.banner().innerHTML, /href="\/settings#software-update"/, `Software update for ${JSON.stringify(url)}`);
-    assert.doesNotMatch(b.banner().innerHTML, /javascript:/);
-  }
-});
-
-await t('on the Software update panel itself, the banner points rather than linking to the page it is on', async () => {
-  const b = boot({ provisioning: false, pathname: '/settings', hash: '#software-update' });
-  await settle();
-  assert.doesNotMatch(b.banner().innerHTML, /core-update-notice__action/, 'no link to where you already are');
-  assert.match(b.banner().innerHTML, /core-update-notice__hint/);
-});
-
-await t('on the platform, the local door wins: the banner links /deploy and the rail keeps it', async () => {
+// The banner that used to link here is the Update pill now (task 1005041): where its Update now
+// goes on each kind of hall, and the held version it refuses to offer, are pinned against the
+// real pill in tests/update_pill.mjs. What stays here is the rail.
+await t('on the platform, the rail keeps its local /deploy', async () => {
   const b = boot({ provisioning: true, deployUrl: HUB });
   await settle();
-  assert.match(b.banner().innerHTML, /href="\/deploy"/);
-  assert.ok(!b.banner().innerHTML.includes(HUB));
-  assert.ok(!b.banner().innerHTML.includes('software-update'), 'the platform takes its update at its own door');
   const item = b.deployItem();
   assert.notEqual(item.getAttribute('href'), HUB, 'the rail keeps the local /deploy');
   assert.equal(item.dataset.module, 'provisioning', 'and its module gate, which the platform satisfies');
 });
 
-// Task 1004730: a version this project already tried and rolled back is not announced as
-// "available" with an Upgrade button. The banner says what happened instead, in the owner's
-// words, and points at Software update for the rest.
-await t('a held version: the banner says it was tried and rolled back, and the project is still fine', async () => {
-  const held = { version: '1.19.1033', still_on: '1.19.871', message: 'long form' };
-  const b = boot({ provisioning: false, held });
-  await settle();
-  const n = b.notice();
-  assert.ok(n, 'the banner renders');
-  assert.doesNotMatch(n.innerHTML, /is available/);
-  assert.match(n.innerHTML, /1\.19\.1033<\/strong> was tried on this project and rolled back/);
-  assert.match(n.innerHTML, /still on 1\.19\.871 and working/);
-  assert.match(n.innerHTML, /href="\/settings#software-update">Details</);
-  assert.doesNotMatch(n.innerHTML, />Upgrade</, 'no button to take the version that just failed');
-});
-
-await t('a hold on an OLDER version than the one now out leaves the ordinary banner', async () => {
-  const b = boot({ provisioning: false, held: { version: '1.19.900', still_on: '1.19.871', message: 'x' } });
-  await settle();
-  assert.ok(b.banner(), 'the newer release is announced as usual');
-});
-
 console.log(`\n${passed} passed, ${failed} failed`);
 process.exit(failed === 0 ? 0 : 1);

package/tests/deploy_handoff.mjs

@@ -0,0 +1,206 @@
+// tests/deploy_handoff.mjs — the hub's half of the in-place update (task 1005041).
+//
+// A hosted project's hall opens the hub's deploy door as a small window and tells it which
+// version to take (update-pill.js). The safety of that rests on three refusals, each pinned
+// here by EXECUTING the real deploy-handoff.js: a message from any window but the opener, or
+// from any origin but the project's registered address, is not heard; a version the hub's own
+// preview would not move to is shown to the owner, never sent; and with no word from the hall
+// the window waits for a press. It never moves anything on load by itself.
+import assert from 'node:assert/strict';
+import { test, afterEach } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { realOTB } from './helpers.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const require_ = createRequire(import.meta.url);
+const FILE = path.join(ROOT, 'modules/hall-ui/public/deploy-handoff.js');
+const SRC = fs.readFileSync(FILE, 'utf8');
+const H = require_(FILE);
+
+const PREVIEW = { instance_id: '14', slug: 'toast', reading: 'ok', behind: true, recommended_version: '1.21.30', viewer_may_move: true, open_intent: null };
+const OPENER = {};
+const GO = { tag: 'bongos-update', step: 'go', to: '1.21.30' };
+const base = { data: GO, source: OPENER, opener: OPENER, origin: 'https://toast.cloudbongos.com', allowed: 'https://toast.cloudbongos.com', preview: PREVIEW };
+
+// ── the rule ──────────────────────────────────────────────────────────────────
+
+test('the one message that may start the move', () => {
+  assert.equal(H.judgeGo(base), null);
+});
+
+test('a message from any window but the one that opened this is not heard', () => {
+  assert.equal(H.judgeGo({ ...base, source: {} }), 'not_opener');
+  assert.equal(H.judgeGo({ ...base, opener: null }), 'not_opener');
+});
+
+test('a message from any origin but the project\'s own address is not heard', () => {
+  assert.equal(H.judgeGo({ ...base, origin: 'https://evil.example' }), 'wrong_origin');
+  assert.equal(H.judgeGo({ ...base, origin: 'https://toast.cloudbongos.com.evil.example' }), 'wrong_origin');
+  assert.equal(H.judgeGo({ ...base, origin: 'http://toast.cloudbongos.com' }), 'wrong_origin', 'the scheme counts');
+  assert.equal(H.judgeGo({ ...base, allowed: null }), 'wrong_origin', 'a project with no address can be asked by nobody');
+});
+
+test('only the version the hub itself would move to is sent', () => {
+  assert.equal(H.judgeGo({ ...base, data: { ...GO, to: '1.21.31' } }), 'wrong_version');
+  assert.equal(H.judgeGo({ ...base, data: { ...GO, to: undefined } }), 'wrong_version');
+  assert.equal(H.judgeGo({ ...base, data: { ...GO, to: '1.21.30 ' } }), 'wrong_version');
+});
+
+test('nothing to move, a viewer who may not, or a run already open: refused', () => {
+  assert.equal(H.judgeGo({ ...base, preview: { ...PREVIEW, behind: false } }), 'nothing_to_move');
+  assert.equal(H.judgeGo({ ...base, preview: { ...PREVIEW, reading: 'no_answer' } }), 'nothing_to_move');
+  assert.equal(H.judgeGo({ ...base, preview: { ...PREVIEW, viewer_may_move: false } }), 'not_allowed');
+  assert.equal(H.judgeGo({ ...base, preview: { ...PREVIEW, open_intent: { action: 'restart' } } }), 'busy');
+});
+
+test('another page\'s message is not this protocol', () => {
+  assert.equal(H.judgeGo({ ...base, data: { ...GO, tag: 'other' } }), 'not_go');
+  assert.equal(H.judgeGo({ ...base, data: 'go' }), 'not_go');
+});
+
+test('the allowed origin is the project\'s registered address, and nothing that is not a host', () => {
+  assert.equal(H.projectOrigin({ domain: 'Toast.CloudBongos.com' }, 'https:'), 'https://toast.cloudbongos.com');
+  assert.equal(H.projectOrigin({ domain: 'toast.cloudbongos.com' }, 'http:'), 'http://toast.cloudbongos.com', 'http only on a harness served over http');
+  for (const domain of [null, '', 'localhost', 'a b.com', 'evil.com/path', 'evil.com?x', 'https://evil.com', '-x.com']) {
+    assert.equal(H.projectOrigin({ domain }, 'https:'), null, JSON.stringify(domain));
+  }
+});
+
+test('the window is the handoff only when asked for it', () => {
+  assert.equal(H.wanted({ search: '?project=toast&handoff=1' }), true);
+  assert.equal(H.wanted({ search: '?handoff=1' }), true);
+  assert.equal(H.wanted({ search: '?project=toast' }), false);
+  assert.equal(H.wanted({ search: '?handoff=10' }), false);
+  assert.equal(H.wanted(null), false);
+});
+
+// ── the page, run for real ────────────────────────────────────────────────────
+
+const armed = new Set();
+afterEach(() => { for (const id of armed) clearTimeout(id); armed.clear(); });
+const settle = (ms = 0) => new Promise((r) => setTimeout(r, ms));
+const plain = (x) => JSON.parse(JSON.stringify(x));
+
+function boot({ opener = { postMessage(msg, origin) { told.push({ msg, origin }); } }, preview = PREVIEW, post = { ok: true, status: 200, data: { ok: true } }, rows = [{ id: '14', slug: 'toast', domain: 'toast.cloudbongos.com' }] } = {}) {
+  const told = [];
+  const requests = [];
+  const listeners = {};
+  let closed = false;
+  const main = { _html: '', set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; } };
+  const bodyEl = { _html: '', set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; } };
+  const buttons = {};
+  const documentObj = {
+    documentElement: { setAttribute() {} },
+    getElementById(id) {
+      if (id === 'hall-main') return main;
+      if (id === 'ho-body') return bodyEl;
+      if (!bodyEl._html.includes(`id="${id}"`)) return null;
+      return (buttons[id] ||= { _on: {}, addEventListener(ev, fn) { this._on[ev] = fn; } });
+    },
+  };
+  if (opener) opener.postMessage = (msg, origin) => told.push({ msg, origin });
+  const windowObj = {
+    OTB: realOTB(), document: documentObj, opener, __handoffHearMs: 30,
+    location: { protocol: 'https:', pathname: '/deploy', search: '?project=toast&handoff=1', assign() {} },
+    addEventListener: (ev, fn) => { (listeners[ev] ||= []).push(fn); },
+    setTimeout: (fn, ms) => { const id = setTimeout(fn, ms); armed.add(id); return id; },
+    close() { closed = true; },
+  };
+  const api = {
+    request: (method, p, opts) => {
+      requests.push({ method, path: p, body: opts && opts.body });
+      if (p === '/api/bongos/provisioning/fleet') return Promise.resolve({ ok: true, status: 200, data: { instances: rows } });
+      if (method === 'GET' && /core-upgrade$/.test(p)) return Promise.resolve({ ok: true, status: 200, data: { ok: true, preview } });
+      if (method === 'POST') return Promise.resolve(post);
+      return Promise.resolve({ ok: false, status: 404, data: null });
+    },
+  };
+  const sandbox = { window: windowObj, console, Promise, JSON };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(SRC, sandbox, { filename: 'deploy-handoff.js' });
+  windowObj.OTBDeployHandoff.run({ api });
+  return {
+    told, requests, body: bodyEl, buttons, closed: () => closed,
+    message: (data, { source = opener, origin = 'https://toast.cloudbongos.com' } = {}) => { for (const fn of listeners.message || []) fn({ data, source, origin }); },
+    posts: () => requests.filter((r) => r.method === 'POST'),
+  };
+}
+
+test('it says "ready" only to the project\'s own address, and moves nothing until it hears', async () => {
+  const b = boot();
+  await settle(5);
+  assert.deepEqual(plain(b.told), [{ msg: { tag: 'bongos-update', step: 'ready' }, origin: 'https://toast.cloudbongos.com' }]);
+  assert.equal(b.posts().length, 0, 'nothing moves on load');
+});
+
+test('the go from the project\'s own hall moves it to that version, says so, and closes', async () => {
+  const b = boot();
+  await settle(5);
+  b.message(GO);
+  await settle(5);
+  assert.equal(b.posts().length, 1);
+  assert.equal(b.posts()[0].path, '/api/bongos/provisioning/instances/14/core-upgrade');
+  assert.deepEqual(plain(b.posts()[0].body), { to: '1.21.30' });
+  assert.deepEqual(plain(b.told[1]), { msg: { tag: 'bongos-update', step: 'started', to: '1.21.30' }, origin: 'https://toast.cloudbongos.com' });
+  assert.match(b.body.innerHTML, /The update has started/);
+});
+
+test('a go from another site, or another window, moves nothing', async () => {
+  const b = boot();
+  await settle(5);
+  b.message(GO, { origin: 'https://evil.example' });
+  b.message(GO, { source: {} });
+  await settle(5);
+  assert.equal(b.posts().length, 0);
+});
+
+test('a go naming another version is shown to the owner, never sent', async () => {
+  const b = boot();
+  await settle(5);
+  b.message({ ...GO, to: '1.21.31' });
+  await settle(5);
+  assert.equal(b.posts().length, 0);
+  assert.match(b.body.innerHTML, /A different version is ready/);
+  assert.match(b.body.innerHTML, /Update to 1\.21\.30/, 'the press names the hub\'s own version');
+});
+
+test('no word from the hall: one press, naming the version, and only the press moves it', async () => {
+  const b = boot();
+  await settle(60);
+  assert.equal(b.posts().length, 0, 'waiting is not consent');
+  assert.match(b.body.innerHTML, /id="ho-go"/);
+  b.buttons['ho-go']._on.click();
+  await settle(5);
+  assert.deepEqual(plain(b.posts()[0].body), { to: '1.21.30' });
+});
+
+test('opened by hand, with no hall behind it: the press, never an automatic move', async () => {
+  const b = boot({ opener: null });
+  await settle(5);
+  assert.equal(b.posts().length, 0);
+  assert.match(b.body.innerHTML, /Update to 1\.21\.30/);
+});
+
+test('a refusal is said in the server\'s words, here and to the hall', async () => {
+  const b = boot({ post: { ok: false, status: 409, data: { error: { code: 'intent_conflict', message: 'A restart is running for this project.' } } } });
+  await settle(5);
+  b.message(GO);
+  await settle(5);
+  assert.match(b.body.innerHTML, /A restart is running for this project\./);
+  assert.deepEqual(plain(b.told[1]), { msg: { tag: 'bongos-update', step: 'refused', message: 'A restart is running for this project.' }, origin: 'https://toast.cloudbongos.com' });
+});
+
+test('a project already current, or one with no address, says so and moves nothing', async () => {
+  const cur = boot({ preview: { ...PREVIEW, behind: false } });
+  await settle(5);
+  assert.match(cur.body.innerHTML, /already runs the newest version/);
+  const none = boot({ rows: [{ id: '14', slug: 'toast', domain: null }] });
+  await settle(60);
+  assert.equal(none.told.length, 0, 'nobody to say "ready" to');
+  assert.match(none.body.innerHTML, /id="ho-go"/, 'the press is still there');
+});

package/tests/government_protected_surfaces.mjs

@@ -328,6 +328,21 @@ const ADDED_SINCE_R101 = [
     why: 'split out of the protected ship.js: the ship-mode step every ship runs '
        + 'before it lands, so an edit here could change how work reaches main.',
   },
+  // task 1004546: the Autobongos self-edit wall. The grade of task 1004540 refused a
+  // version whose guard lived in unprotected shared files, so it moved into these two
+  // small ones and they sit beside the rest of the publish pipeline.
+  {
+    after: 'modules/lifecycle/publish-reconciler.js',
+    glob: 'modules/lifecycle/runner-self.js',
+    why: 'the one list of files an unattended runner may never change, and the shape of '
+       + "a runner's claim; an edit here could let a runner loosen its own fence.",
+  },
+  {
+    after: 'modules/lifecycle/runner-self.js',
+    glob: 'modules/lifecycle/runner-self-guard.js',
+    why: "the server's refusal to publish a runner's change to its own supervisor, safety "
+       + 'checks or kill switch, read against the pull request\'s real files.',
+  },
 ];
 
 // Surfaces RENAMED since R101 — still protected, under a new path. Distinct from

package/tests/hall_loading.mjs

@@ -136,7 +136,9 @@ test('the placeholders the page scripts write wear it too, and a failure stops i
     'criterion-uat-ui.js': '<p class="hall-loading hall-loading--inline" role="status">Loading…</p>',
     'watch.js': '<p class="hall-loading" role="status">Reading…</p>',
     'studio.js': '<p class="hall-loading" role="status">Reading the reviews…</p>',
-    'settings-specialities.js': '<p class="hall-loading hall-loading--inline" role="status">Loading this project’s skills…</p>',
+    // the speciality tools, Settings' and My agents' one copy (task 1005052): the offer
+    // editor's and the create form's skills picker both write it
+    'speciality-tools.js': '<p class="hall-loading hall-loading--inline" role="status">Loading this project’s skills…</p>',
     'settings-software-update.js': '<p class="hall-loading hall-loading--inline" role="status">Checking for a newer version…</p>',
     'goals-page.js': '<div class="hall-loading" role="status">Loading…</div>',
   };

package/tests/hall_my_agents.mjs

@@ -440,10 +440,11 @@ test('PAGE: in the hall family, with no prototype key', () => {
   const html = read('my-agents.html');
   assert.match(html, /<body data-page="my-agents"/);
   const sheets = [...html.matchAll(/href="\/builders\/([a-z-]+\.css)/g)].map((m) => m[1]);
-  assert.deepEqual(sheets, ['style.css', 'oversight.css', 'my-agents.css'], 'rides the oversight archetype, linked before its own sheet');
+  assert.deepEqual(sheets, ['style.css', 'oversight.css', 'speciality-tools.css', 'my-agents.css'],
+    'rides the oversight archetype; the shared speciality sheet (task 1005052) before its own, so the page skin wins');
   const scripts = [...html.matchAll(/src="\/builders\/([a-z-]+)\.js/g)].map((m) => m[1]);
   assert.deepEqual(scripts.slice(0, 4), ['dom-utils', 'shell-trail', 'craft-mode', 'shell']); // dom-utils first: the shell escapes through it (task 1004876)
-  for (const s of ['gov-living', 'gov-positions', 'my-agents']) assert.ok(scripts.includes(s), `loads ${s}.js`);
+  for (const s of ['gov-living', 'gov-positions', 'my-agents', 'speciality-tools']) assert.ok(scripts.includes(s), `loads ${s}.js`);
   assert.doesNotMatch(html, /ma-key|data-proto|Prototype data/, 'nothing on the page is prototype data, so there is no key');
   assert.doesNotMatch(read('my-agents.js'), /governor-overlay/, 'and it reads no overlay');
   assert.match(html, /id="hall-main"/);
@@ -480,3 +481,104 @@ test('PAGE: no animation loop or timer-driven motion in the page script', () =>
   // the one timer takes the saved tick's attribute back off; CSS plays the motion
   assert.equal((code.match(/setTimeout\(/g) || []).length, 1);
 });
+
+// ---------------------------------------------------------------------------
+// 6. everything Settings can do here too (task 1005052)
+// ---------------------------------------------------------------------------
+
+const { createPrefRecorder: recorder } = require(path.join(ROOT, 'scripts', 'hall-preview', 'pref-writes.js'));
+
+test('DEFAULTS: session cards can go back to following your interaction profile', () => {
+  const me = fx('me');
+  assert.equal(me.render.override_level, null, 'the fixture viewer follows the profile');
+  const r = row(viewOf(), 'render');
+  assert.deepEqual(r.options[0], { value: '', label: 'follow my profile', pressed: true }, 'the way back comes first, and is the choice in force');
+  assert.deepEqual(r.options.slice(1).map((o) => o.value), me.render.levels.map((l) => l.value), 'then the four levels');
+  assert.ok(r.options.slice(1).every((o) => !o.pressed), 'a level is pressed only when it is your own pick');
+  assert.equal(r.fact, MyAgents.SETTING.render.words[me.render.derived_level], 'the fact is the level the profile gives');
+  assert.equal(r.note, 'follows your profile');
+  const pinned = fx('me');
+  pinned.render = { ...pinned.render, override_level: 'minimal', level: 'minimal' };
+  const p = row(viewOf({ me: pinned }), 'render');
+  assert.equal(p.options[0].pressed, false, 'a pinned level is not "follow my profile"');
+  assert.deepEqual(p.options.filter((o) => o.pressed).map((o) => o.value), ['minimal']);
+  assert.equal(p.fact, 'one line');
+  assert.equal(p.note, null);
+  assert.deepEqual(MyAgents.writeFor('render', '', { me }), { method: 'PATCH', path: '/me/render', body: { widgets: null }, slice: 'render' }, 'the way back CLEARS the pick (null), it does not pin today\'s level');
+  assert.deepEqual(MyAgents.writeFor('render', 'minimal', { me }).body, { widgets: 'minimal' });
+});
+
+test('DEFAULTS: the real shapers take the way back for session cards, and the row reads it as chosen', () => {
+  const rec = recorder({ log() {} });
+  const me = fx('me');
+  assert.equal(rec.write('me/render', MyAgents.writeFor('render', 'minimal', { me }).body, { me }).body.override_level, 'minimal');
+  const back = rec.write('me/render', MyAgents.writeFor('render', '', { me }).body, { me });
+  assert.equal(back.status, 200, 'the real route accepts it');
+  assert.equal(back.body.override_level, null);
+  assert.equal(back.body.level, back.body.derived_level, 'the cards follow the profile again');
+  const after = { ...me, render: back.body };
+  assert.equal(row(viewOf({ me: after }), 'render').options[0].pressed, true);
+});
+
+test('DEFAULTS: each skill voice can go back to its default model', () => {
+  const sk = fx('me__skill-prefs');
+  const subs = row(viewOf(), 'skills').skills;
+  assert.equal(subs.length, sk.effective.length);
+  for (const s of subs) {
+    assert.deepEqual(s.options[0], { value: '', label: 'default', pressed: true }, `${s.skill}: the default comes first, and is in force`);
+    assert.deepEqual(s.options.slice(1).map((o) => o.value), sk.allowed_models);
+    assert.ok(s.options.slice(1).every((o) => !o.pressed), `${s.skill}: no model is pressed you did not pick`);
+    assert.equal(s.note, null);
+  }
+  const own = JSON.parse(JSON.stringify(sk));
+  own.effective[0] = { ...own.effective[0], override_model: 'opus', effective_model: 'opus' };
+  const s0 = row(viewOf({ skills: own }), 'skills').skills[0];
+  assert.equal(s0.options[0].pressed, false);
+  assert.deepEqual(s0.options.filter((o) => o.pressed).map((o) => o.value), ['opus']);
+  assert.equal(s0.value, 'opus');
+  assert.equal(s0.note, 'default: ' + sk.effective[0].default_model, 'with your own pick, the default it replaces is said');
+  assert.match(row(viewOf({ skills: own }), 'skills').fact, /1 yours$/);
+  assert.deepEqual(MyAgents.writeFor('skill.' + sk.effective[0].skill, '', {}).body, { [sk.effective[0].skill]: null }, 'the way back clears the pick');
+});
+
+test('DEFAULTS: the real shapers take the way back for a skill voice', () => {
+  const rec = recorder({ log() {} });
+  const me = fx('me');
+  const sk = fx('me__skill-prefs');
+  const skill = sk.effective[0].skill;
+  rec.write('me/skill-prefs', { [skill]: 'opus' }, { me, skillFixture: sk });
+  const back = rec.write('me/skill-prefs', MyAgents.writeFor('skill.' + skill, '', {}).body, { me, skillFixture: sk });
+  assert.equal(back.status, 200);
+  assert.equal(skill in back.body.prefs, false, 'the override is gone');
+  const e = back.body.effective.find((x) => x.skill === skill);
+  assert.equal(e.override_model, null);
+  assert.equal(e.effective_model, e.default_model);
+  assert.equal(row(viewOf({ skills: back.body }), 'skills').skills[0].options[0].pressed, true);
+});
+
+test('PAGE: My agents mounts the SAME speciality component Settings does, in a section of its own', () => {
+  const html = read('my-agents.html');
+  assert.ok(!fs.existsSync(path.join(HALL, 'settings-specialities.js')), 'one copy: the Settings file was carved into the shared one');
+  for (const page of ['my-agents.html', 'settings.html']) assert.match(read(page), /src="\/builders\/speciality-tools\.js/, `${page} loads it`);
+  const at = html.indexOf('id="specialities-scroll"');
+  assert.ok(at > 0, 'the section is on the page');
+  assert.match(html.slice(html.lastIndexOf('<section', at), at), /class="scroll ma-know"/, 'a panel of its own');
+  const desk = html.slice(html.indexOf('id="ma-desk"'), html.indexOf('</section>', html.indexOf('id="ma-desk"')));
+  assert.doesNotMatch(desk, /specialities-rows/, 'not inside the desk, which my-agents.js redraws on every change and would wipe a form half-filled');
+  // tests/speciality_offer_ui.mjs and tests/speciality_walkthrough_ui.mjs drive every tool on this page's markup
+});
+
+test('PAGE: the desk adopts nothing in one tap — taking a speciality on goes through its instructions, read in full', () => {
+  const v = viewOf();
+  assert.equal(row(v, 'specialities'), undefined, 'no desk row adopts');
+  assert.equal(v.groups.some((g) => g.key === 'know'), false, 'the specialities are their own section');
+  assert.doesNotMatch(codeOf(read('my-agents.js')), /\/adopt'|data-adopt/, 'my-agents.js posts no adopt of its own');
+});
+
+test('PAGE: when a speciality changes, what your agent reads first is read again', () => {
+  // speciality-tools.js dispatches it after an adopt, a stop or a skills save
+  // (tests/speciality_walkthrough_ui.mjs); the page listens and re-reads /me.
+  const code = codeOf(read('my-agents.js'));
+  assert.match(code, /document\.addEventListener\('otb:specialities-changed', /);
+  assert.match(codeOf(read('speciality-tools.js')), /new CustomEvent\('otb:specialities-changed'\)/);
+});

package/tests/helpers.mjs

@@ -1015,6 +1015,167 @@ export function bootSkyPage({
   return out;
 }
 
+// bootSpecialityTools — boot THE SPECIALITY TOOLS for real on a page's OWN markup
+// (task 1005052). One component, modules/hall-ui/public/speciality-tools.js, is
+// mounted by Settings and by My agents, and it finds every host by id. So, on the
+// bootSkyPage rule, the DOM here is the page's own: its specialities section
+// (`#specialities-scroll`) is parsed out of `<page>.html` into the mini-DOM above,
+// an id the page does not carry is null here too, and an id the component renders
+// itself (the create form's skills picker) exists only once its markup says so. A
+// host lost from either page fails that page's run.
+//
+// The fake API keeps the builder's adoptions as STATE: adopt adds one, abandon
+// drops it, the walkthrough's PUT sets its enabled skills, so a reload after a
+// write reads what the write did. Clicks, submits, typing and the details toggle
+// are dispatched on the real parsed element and bubble to the listener the
+// component wired, so `closest()` in its handlers walks the real tree.
+//
+//   const h = await bootSpecialityTools({ page: 'my-agents', catalog, adoptions });
+//   await h.click('#specialities-rows button[data-act="adopt"]');
+//   h.writes()   → the non-GET requests, with their bodies
+//   h.text('specialities-rows'), h.toasts, h.events (the DOM events it dispatched)
+export const SPECIALITY_PAGES = ['settings', 'my-agents'];
+function specialitySection(page) {
+  const html = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public', `${page}.html`), 'utf8').replace(/<!--[\s\S]*?-->/g, '');
+  const at = html.indexOf('id="specialities-scroll"');
+  if (at < 0) return '';
+  const start = html.lastIndexOf('<section', at);
+  return html.slice(start, html.indexOf('</section>', at) + '</section>'.length);
+}
+export function bootSpecialityTools({
+  page = 'settings', catalog = [], adoptions = [], suggestions = [], skills = {}, installed = [], answer = null,
+} = {}) {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/speciality-tools.js'), 'utf8');
+  let focused = null;
+  const docListeners = new Map();
+  function node(tag, attrs = {}) {
+    const el = makeEl(tag, attrs);
+    el.hidden = 'hidden' in attrs;
+    el.open = 'open' in attrs;
+    el.checked = 'checked' in attrs;
+    el.focus = () => { focused = el; };
+    el.matches = (sel) => matches(el, sel);
+    // `:checked` is the one pseudo-class the component reads (the ticked skills)
+    const all = el.querySelectorAll.bind(el);
+    el.querySelectorAll = (sel) => (String(sel).endsWith(':checked') ? all(String(sel).slice(0, -':checked'.length)).filter((x) => x.checked) : all(sel));
+    if (tag === 'form') {
+      Object.defineProperty(el, 'elements', {
+        get() { const o = {}; for (const f of el.querySelectorAll('input, select, textarea')) if (f.name) o[f.name] = f; return o; },
+      });
+      el.reset = () => { for (const f of el.querySelectorAll('input, select, textarea')) { f._value = null; f.checked = 'checked' in f.attrs; } };
+    }
+    return el;
+  }
+  function parse(host, html) {
+    host.children = []; host._text = '';
+    const stack = [host];
+    const re = /<(\/?)([a-zA-Z][\w-]*)([^>]*?)(\/?)>/g;
+    let last = 0; let m;
+    const addText = (raw) => { if (raw) stack[stack.length - 1]._text += decodeEntities(raw); };
+    while ((m = re.exec(html))) {
+      addText(html.slice(last, m.index)); last = re.lastIndex;
+      const tag = m[2].toLowerCase();
+      if (m[1]) { for (let i = stack.length - 1; i > 0; i--) if (stack[i].tagName === tag) { stack.length = i; break; } continue; }
+      const el = node(tag, parseAttrs(m[3]));
+      stack[stack.length - 1].appendChild(el);
+      if (!m[4] && !VOID_TAGS.has(tag)) stack.push(el);
+    }
+    addText(html.slice(last));
+  }
+  const patchInnerHtml = (el) => Object.defineProperty(el, 'innerHTML', {
+    get() { return this._html === null ? '' : this._html; },
+    set(v) { this._html = String(v); this._value = null; parse(this, this._html); walk(this, (c) => { patchInnerHtml(c); return null; }); },
+    configurable: true,
+  });
+  const root = node('body', {});
+  patchInnerHtml(root);
+  parse(root, specialitySection(page));
+  walk(root, (c) => { patchInnerHtml(c); return null; });
+  const hostIds = [];
+  walk(root, (c) => { if (c.id) hostIds.push(c.id); return null; });
+  const byId = (id) => walk(root, (c) => (c.id === id ? c : null));
+  const query = (sel) => {
+    let scope = [root];
+    for (const part of String(sel).trim().split(/\s+/)) {
+      const next = [];
+      for (const s of scope) walk(s, (c) => { if (matches(c, part)) next.push(c); return null; });
+      scope = next;
+      if (!scope.length) return null;
+    }
+    return scope[0];
+  };
+  function dispatch(target, type) {
+    const ev = { type, target, defaultPrevented: false, preventDefault() { this.defaultPrevented = true; } };
+    for (let n = target; n; n = n.parentNode) (n.listeners[type] || []).forEach((fn) => fn(ev));
+    (docListeners.get(type) || []).forEach((fn) => fn(ev));
+    return ev;
+  }
+  const events = [];
+  const documentObj = {
+    readyState: 'complete',
+    getElementById: byId,
+    querySelector: query,
+    addEventListener: (type, fn) => { if (!docListeners.has(type)) docListeners.set(type, []); docListeners.get(type).push(fn); },
+    dispatchEvent: (ev) => { events.push(ev.type); return true; },
+  };
+
+  // ── the API: the catalogue fixed, the builder's adoptions as state ─────────
+  const requests = [];
+  const mine = adoptions.map((a) => ({ ...a }));
+  const fetchFn = async (url, opts = {}) => {
+    const method = opts.method || 'GET';
+    const p = String(url).replace('/api/bongos', '');
+    const body = opts.body ? JSON.parse(opts.body) : undefined;
+    requests.push({ method, path: p, body });
+    const custom = answer && answer(method, p, body);
+    let status = 200;
+    let data = {};
+    const id = (/^\/specialities\/(\d+)/.exec(p) || [])[1];
+    if (custom) ({ status, data } = custom);
+    else if (method === 'GET' && p === '/specialities') data = { specialities: catalog };
+    else if (method === 'GET' && p === '/me/specialities') data = { adoptions: mine.map((a) => ({ ...a })) };
+    else if (method === 'GET' && p === '/specialities/offered') data = { suggestions };
+    else if (method === 'GET' && p === '/specialities/installed-skills') data = { skills: installed };
+    else if (method === 'GET' && /\/skills$/.test(p)) { data = skills[id] || {}; status = skills[id] ? 200 : 404; }
+    else if (method === 'POST' && /\/adopt$/.test(p)) { if (!mine.some((a) => String(a.id) === id)) mine.push({ id: Number(id), active: true, enabled_skills: [] }); data = { adoption: { active: true } }; }
+    else if (method === 'POST' && /\/abandon$/.test(p)) { const was = mine.some((a) => String(a.id) === id); mine.splice(0, mine.length, ...mine.filter((a) => String(a.id) !== id)); data = { ok: true, was_active: was }; }
+    else if (method === 'POST' && /\/documents$/.test(p)) { status = 201; data = { document: { id: 1, title: body.title } }; }
+    else if (method === 'PUT' && /\/skills$/.test(p)) { mine.forEach((a) => { if (String(a.id) === id) a.enabled_skills = body.enabled_skills; }); data = { adoption: { enabled_skills: body.enabled_skills } }; }
+    else if (method === 'PATCH') data = { speciality: { id: Number(id) } };
+    else if (method === 'POST' && p === '/specialities') { status = 201; data = { speciality: { id: 13 } }; }
+    else status = 404;
+    return { ok: status < 400, status, json: async () => data };
+  };
+
+  const toasts = [];
+  const out = { page, hostIds, requests, toasts, events, navigated: null };
+  const windowObj = {
+    OTB: { ...realOTB(), toast: (m) => toasts.push(m) },
+    location: { assign: (u) => { out.navigated = u; } },
+  };
+  class CustomEvent { constructor(type, init) { this.type = type; this.detail = init && init.detail; } }
+  const sandbox = { window: windowObj, document: documentObj, fetch: fetchFn, CustomEvent, JSON, Promise, Map, Set, String, Number, Array, Object, Math, RegExp, Error, console, setTimeout };
+  vm.createContext(sandbox);
+  vm.runInContext(src, sandbox, { filename: 'speciality-tools.js' });
+
+  const settleAll = async () => { for (let i = 0; i < 12; i++) await settle(); };
+  const must = (sel) => { const el = query(sel); if (!el) throw new Error(`${page}: no ${sel}`); return el; };
+  return Object.assign(out, {
+    ready: settleAll,
+    el: byId,
+    find: query,
+    html: (id) => (byId(id) ? byId(id).innerHTML : ''),
+    text: (id) => (byId(id) ? byId(id).innerHTML.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ') : ''),
+    writes: () => requests.filter((r) => r.method !== 'GET'),
+    focused: () => focused,
+    click: async (sel) => { const el = must(sel); dispatch(el, 'click'); await settleAll(); return el; },
+    submit: async (sel) => { const el = must(sel); const ev = dispatch(el, 'submit'); await settleAll(); return ev; },
+    type: async (sel, value) => { const el = must(sel); el.value = value; dispatch(el, 'input'); await settleAll(); return el; },
+    tick: (sel) => { const el = must(sel); el.checked = true; return el; },
+    toggle: async (id) => { const el = byId(id); if (!el) throw new Error(`${page}: no #${id}`); el.open = !el.open; dispatch(el, 'toggle'); await settleAll(); return el; },
+  });
+}
+
 // namesFieldKey — does this source USE `key` as a Full Idea field key, as
 // opposed to merely containing the word? (task 1004085 / BV2.R06.)
 //

package/tests/hub_connections_page.mjs

@@ -77,7 +77,7 @@ test('the body: a door, a loading line, the inactive and unreadable lines, then
   assert.match(MAIN, /<h1>connections<\/h1>/);
   assert.match(MAIN, /it grants no rank and no access to anything/, 'a connection is never authority (ADR 0016, ADR 0202)');
   assert.match(MAIN, /<section class="aDoor" id="door" hidden aria-labelledby="door-h">[\s\S]*?href="\/api\/bongos\/auth\/web\/start\?return=\/connections&amp;repos=1"/, 'signed out, the door returns here');
-  assert.match(MAIN, /<p class="loading" id="loading">/);
+  assert.match(MAIN, /<p class="loading loading-mark loading-mark--page" id="loading" role="status">/); // the Bongos-mark loader (task 1005053)
   assert.match(MAIN, /<p class="mineEmpty" id="inactive" hidden>/);
   assert.match(MAIN, /<p class="projMsg err" id="readFailed" role="alert" hidden>/);
   assert.match(MAIN, /<p class="projMsg" id="connMsg" role="status" aria-live="polite" hidden><\/p>/);

package/tests/hub_invitations_page.mjs

@@ -56,7 +56,7 @@ test('the page wears the hub’s bar, with Invitations as the one current place;
 test('the body: a door, a loading line, the four lists in order under one heading, the empty line, and the join field', () => {
   assert.match(MAIN, /<h1>invitations<\/h1>/);
   assert.match(MAIN, /<section class="aDoor" id="door" hidden aria-labelledby="door-h">[\s\S]*?href="\/api\/bongos\/auth\/web\/start\?return=\/invitations&amp;repos=1"/, 'signed out, the door returns here');
-  assert.match(MAIN, /<p class="loading" id="loading">/);
+  assert.match(MAIN, /<p class="loading loading-mark loading-mark--page" id="loading" role="status">/); // the Bongos-mark loader (task 1005053)
   const section = (MAIN.match(/<section id="mineInvites" aria-labelledby="mineInvitesH">[\s\S]*?<\/section>/) || [''])[0];
   assert.ok(section, 'the invitations section ships as markup, never hidden on its own: it is the page');
   assert.match(section, /<p class="mineEmpty" id="invitesNone" hidden>[^<]+<\/p>/, 'one empty line, down until the reads have answered');