@bongos/core 1.24.28 → 1.24.30

package/tests/hall_home_ships_bounded.mjs

@@ -122,14 +122,15 @@ function loadRender({ view = 'home' } = {}) {
 
 const homePage = (total, firstId = 3000) => ({ ships: [ship(firstId), ship(firstId - 1)], total });
 
-test('Home: the count and the five-row table come from the small page, with no ledger fetch', async () => {
+test('Home: the Standing chip\'s count comes from the small page, with no ledger fetch', async () => {
+  // task 1005054: the Shipped tile and the five-row table left Home with the stats
+  // strip and "Your work"; the small page still feeds the Standing chip's count.
   const { r, el, fetched } = loadRender();
   assert.equal(r.HOME_SHIPS_LIMIT, 5);
   r.setRecentShips(homePage(3000));
   await new Promise((done) => setTimeout(done, 0));
   assert.deepEqual(fetched, [], 'Home never asks for the full history');
-  assert.equal(el('stat-shipped').textContent, '3000', 'the Shipped tile shows the server total, not rows held');
-  assert.match(el('home-recent-table tbody').innerHTML, /#3000[\s\S]*#2999/);
+  assert.equal(el('standing-shipped').textContent, '3000', 'the chip shows the server total, not rows held');
   assert.equal(el('recent-ships tbody').innerHTML, '', 'the ledger is untouched until its view opens');
 });
 

package/tests/hall_my_agents.mjs

@@ -556,10 +556,11 @@ test('DEFAULTS: the real shapers take the way back for a skill voice', () => {
   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', () => {
+test('PAGE: My agents mounts the speciality component, in a section of its own, and is its only host (task 1005044)', () => {
   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`);
+  assert.match(read('my-agents.html'), /src="\/builders\/speciality-tools\.js/, 'My agents loads it');
+  assert.doesNotMatch(read('settings.html'), /speciality-tools\.(js|css)/, 'Settings no longer mounts it: one page edits a speciality');
   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');
@@ -582,3 +583,88 @@ test('PAGE: when a speciality changes, what your agent reads first is read again
   assert.match(code, /document\.addEventListener\('otb:specialities-changed', /);
   assert.match(codeOf(read('speciality-tools.js')), /new CustomEvent\('otb:specialities-changed'\)/);
 });
+
+// ---------------------------------------------------------------------------
+// 6. moved from Settings (task 1005044): the five agent settings live HERE only.
+// Each case is a Settings assertion carried over — what the old panel promised a
+// builder, proven on this page instead (tests/hall_settings_world.mjs pins that
+// Settings no longer carries them).
+// ---------------------------------------------------------------------------
+
+test('MOVED: every interaction field is a row offering every value, written to PATCH /me/interaction', () => {
+  const v = viewOf();
+  for (const f of fx('me').interaction.fields) {
+    const r = row(v, f.field);
+    assert.ok(r, f.field + ' is a row');
+    assert.deepEqual(r.options.map((o) => o.value), f.values.map((x) => x.value), f.field + ': every value the old radio group offered');
+    for (const o of r.options) {
+      const w = MyAgents.writeFor(f.field, o.value, {});
+      assert.deepEqual(w, { method: 'PATCH', path: '/me/interaction', body: { [f.field]: o.value }, slice: 'interaction' }, 'one field per write, as Settings sent');
+    }
+  }
+});
+
+test('MOVED: a default value is named once — a chip never repeats the API label\'s "(default)"', () => {
+  for (const r of rows(viewOf())) for (const o of r.options || []) assert.doesNotMatch(String(o.label), /\(default\)|DEFAULT/, r.key + ': ' + o.label);
+});
+
+test('MOVED: wandering offers every level the rank allows, writes its number, and never a level above the ceiling', () => {
+  const me = JSON.parse(JSON.stringify(fx('me')));
+  me.wandering.levels[3].allowed = false; // a rank whose ceiling is balanced
+  const r = row(viewOf({ me }), 'wandering');
+  assert.deepEqual(r.options.map((o) => o.value), ['locked', 'focused', 'balanced'], 'the level above the rank ceiling is not offered');
+  me.wandering.levels.forEach((l) => {
+    assert.deepEqual(MyAgents.writeFor('wandering', l.key, { me }).body, { wandering: l.n }, l.key + ' writes its level number, as Settings did');
+  });
+});
+
+test('MOVED: following the profile names the level it derives, and choosing it clears the pick', () => {
+  const me = JSON.parse(JSON.stringify(fx('me')));
+  me.render.override_level = null; me.render.derived_level = 'text'; me.render.level = 'text';
+  const r = row(viewOf({ me }), 'render');
+  assert.equal(r.fact, 'plain text', 'the fact is the level the profile derives, not a bare "default"');
+  assert.equal(r.note, 'follows your profile');
+  assert.equal(r.options[0].pressed, true);
+  assert.deepEqual(MyAgents.writeFor('render', '', {}).body, { widgets: null }, 'the way back clears the override rather than pinning today\'s level');
+});
+
+test('MOVED: a law lock on these rows still holds here — a fixed setting is locked, a cap offers only what it allows, an unenforced lock locks nothing', () => {
+  const me = JSON.parse(JSON.stringify(fx('me')));
+  me.laws = { inject: true, contract: 'Project laws', laws: [], locks: [
+    { setting: 'verbosity', law_id: '2', law_no: 2, law_text: 'Agents keep replies short', value: 'concise', enforced: true, allowed: ['concise'] },
+    { setting: 'wandering', law_id: '3', law_no: 3, law_text: 'Agents stay on task', max: 'focused', enforced: true, allowed: ['locked', 'focused'] },
+    { setting: 'machinery', law_id: '4', law_no: 4, value: 'nonsense', enforced: false, reason: 'value_not_allowed' },
+  ] };
+  const v = viewOf({ me });
+  assert.equal(row(v, 'verbosity').locked, true);
+  assert.match(row(v, 'verbosity').lock.text, /Agents keep replies short · Law 2$/);
+  assert.equal(row(v, 'wandering').locked, false, 'a cap is not a lock');
+  assert.deepEqual(row(v, 'wandering').options.map((o) => o.value), ['locked', 'focused']);
+  assert.equal(row(v, 'machinery').locked, false, 'a lock that enforces nothing locks nothing');
+});
+
+test('MOVED: each skill voice offers default plus every allowed model, written to PATCH /me/skill-prefs', () => {
+  const sk = fx('me__skill-prefs');
+  const r = row(viewOf(), 'skills');
+  assert.equal(r.skills.length, sk.effective.length, 'every skill Settings listed');
+  for (const s of r.skills) assert.deepEqual(s.options.map((o) => o.value), [''].concat(sk.allowed_models));
+  assert.deepEqual(MyAgents.writeFor('skill.x', 'opus', {}), { method: 'PATCH', path: '/me/skill-prefs', body: { x: 'opus' }, slice: 'skills' });
+});
+
+test('ANCHORS: every My agents anchor names a group this page draws, and #skills opens the per-skill list', () => {
+  const groups = MyAgents.GROUPS.map((g) => g.key);
+  for (const [hash, a] of Object.entries(MyAgents.ANCHORS)) {
+    if (a.group) assert.ok(groups.includes(a.group), hash + ' lands on a real group');
+  }
+  assert.deepEqual(MyAgents.anchorFor('#talk'), { id: 'ma-group-talk', openSkills: false });
+  assert.deepEqual(MyAgents.anchorFor('#work'), { id: 'ma-group-work', openSkills: false });
+  assert.deepEqual(MyAgents.anchorFor('#models'), { id: 'ma-group-models', openSkills: false });
+  assert.deepEqual(MyAgents.anchorFor('#skills'), { id: 'ma-group-models', openSkills: true });
+  assert.deepEqual(MyAgents.anchorFor('#knows'), { id: 'specialities-scroll', openSkills: false });
+  assert.equal(MyAgents.anchorFor('#nope'), null);
+  assert.equal(MyAgents.anchorFor(''), null);
+  const code = codeOf(read('my-agents.js'));
+  assert.match(code, /id="ma-group-' \+ esc\(g\.key\) \+ '"/, 'each drawn group carries the id its anchor names');
+  assert.match(code, /addEventListener\('hashchange'/, 'a later hash lands too');
+  assert.match(read('my-agents.html'), /id="specialities-scroll"/);
+});

package/tests/hall_palette.mjs

@@ -182,6 +182,18 @@ test('Settings panel anchors exist in settings.js RAIL_GROUPS', () => {
   }
 });
 
+test('My agents anchors are ones my-agents.js lands, and the moved Settings panels are offered there (task 1005044)', () => {
+  const src = read('my-agents.js');
+  const block = (src.match(/const ANCHORS = \{([\s\S]*?)\n  \};/) || [, ''])[1];
+  const keys = [...block.matchAll(/^\s*([a-z-]+): \{/gm)].map((m) => m[1]);
+  assert.ok(keys.length >= 5, `sanity: my-agents.js ANCHORS (${keys})`);
+  const declared = declaredHrefs((x) => x.startsWith('/my-agents#'));
+  assert.ok(declared.length >= 5, 'the palette offers the agent settings where they live now');
+  for (const h of declared) assert.ok(keys.includes(h.split('#')[1]), `${h} must be a my-agents.js anchor`);
+  assert.equal(declaredHrefs((x) => /\/settings#(interaction|wandering|rendering|voices|specialities)/.test(x)).length, 0,
+    'no palette row points at a Settings panel that left');
+});
+
 test('the anchor guard actually CATCHES a declared id that does not exist', () => {
   const groups = ['work', 'karma', 'progress', 'achievements'];
   assert.equal(groups.includes('standing-nope'.replace('standing-', '')), false,

package/tests/hall_settings_world.mjs

@@ -41,6 +41,7 @@ import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
@@ -153,120 +154,83 @@ test('the switch clears the floor: a 46x38 target drawing a 44x24 track', () =>
   assert.match(on, /background:\s*var\(--accent-tint\)/, 'on is the tint, the accent arrives on the knob');
 });
 
-test('the wandering pick is a radio row, wired on change', () => {
-  const render = settingsJs.match(/function renderWandering\([\s\S]*?\n  \}\n/);
-  assert.ok(render, 'renderWandering is a whole function');
-  assert.match(render[0], /<label class="prow prow--pick" for="\$\{id\}"/, 'the whole row is the radio\'s label');
-  assert.match(render[0], /<input class="pradio" type="radio" name="wandering"/, 'a real radio group');
-  assert.match(render[0], /locked \? ' disabled' : ''/, 'a level above the rank ceiling is a disabled radio');
-  assert.doesNotMatch(render[0], /Rank-locked<\/button>|Choose<\/button>/, 'the four "Choose" buttons are gone');
-  const load = settingsJs.match(/async function loadWandering\([\s\S]*?\n  \}\n/);
-  assert.match(load[0], /addEventListener\('change'/, 'a radio fires change, not click');
-  assert.match(load[0], /closest\('\.pradio'\)/);
+test('the family radio clears the floor: a native radio is 13px, the family one is 24', () => {
   const radio = ruleOf(panelCss, '.pradio');
   assert.match(radio, /width:\s*24px/);
   assert.match(radio, /height:\s*24px/, 'a native radio is 13px; the floor is 24');
 });
 
-// ---- the interaction panel (task 1002514) ----------------------------------
+// ---- the five agent settings live on My agents only (task 1005044) ----------
 //
-// Three facts a browser is silent about: the panel is rendered by a script that
-// is not settings.js, so the wiring between the two halves is the thing that can
-// silently break; and the carve exists because settings.js is against the
-// 1500-line ratchet, which is a fact a reader will otherwise undo.
-
-test('the interaction panel is wired end to end across its two files', () => {
+// How Claude talks to you, Wandering, Rendering (session cards), Skill voices and
+// Your specialities used to be edited on BOTH pages, on the same routes, with no
+// hint that the two were one setting. The owner kept them on My agents only. What
+// each old panel promised a builder is now proven on My agents instead
+// (tests/hall_my_agents.mjs "MOVED:", tests/speciality_offer_ui.mjs,
+// tests/speciality_walkthrough_ui.mjs); this pins that Settings no longer carries
+// them, says where they went, and sends every old link there.
+
+const MOVED_SECTIONS = ['interaction-scroll', 'specialities-scroll', 'wandering-scroll', 'render-scroll', 'voices-scroll'];
+const requireHall = (f) => createRequire(import.meta.url)(path.join(HALL, f));
+
+test('Settings carries none of the five agent settings: no section, no script, no write', () => {
   const html = read('settings.html');
-  const panelJs = read('settings-interaction.js');
-
-  // The markup half lives in settings.html and must join a group that already
-  // exists — the rail renders groups, so a section in an unknown data-group is
-  // markup nothing ever shows.
-  const section = html.match(/<section class="scroll" id="interaction-scroll"[^>]*>/);
-  assert.ok(section, 'the panel has a section');
-  assert.match(section[0], /data-group="preferences"/, 'it joins a group the rail already renders');
-  assert.match(section[0], /\bhidden\b/, 'hidden until its own read succeeds, like every other panel');
-  assert.match(html, /<script src="\/builders\/settings-interaction\.js/, 'the page loads the panel script');
-
-  // The script half self-boots and reveals the section. If it stopped doing
-  // either, the panel would simply never appear and no test would notice.
-  assert.match(panelJs, /\$\('#interaction-scroll'\)\.hidden = false/, 'the script reveals its own section');
-  assert.match(panelJs, /setup\(\);/, 'it self-boots — settings.js does not call it');
-
-  // settings.js keeps ONLY the anchor entry, so /settings#interaction activates
-  // the group before the panel paints.
-  assert.match(settingsJs, /'interaction': 'interaction-scroll'/, 'the deep-link anchor stays in settings.js');
-  assert.doesNotMatch(settingsJs, /function renderInteraction\(/, 'the renderer moved out and must not come back inline');
+  for (const id of MOVED_SECTIONS) assert.doesNotMatch(html, new RegExp(`id="${id}"`), `${id} is gone from Settings`);
+  for (const f of ['settings-interaction.js', 'settings-render.js', 'settings-law-locks.js', 'speciality-tools.js', 'speciality-tools.css']) {
+    assert.doesNotMatch(html, new RegExp(f.replace('.', '\\.')), `Settings no longer loads ${f}`);
+  }
+  for (const f of ['settings-interaction.js', 'settings-render.js', 'settings-law-locks.js']) {
+    assert.ok(!fs.existsSync(path.join(HALL, f)), `${f} had one host, Settings, and went with its panel`);
+  }
+  for (const route of ['/me/skill-prefs', '/me/wandering', '/me/interaction', '/me/render', '/specialities']) {
+    assert.ok(!settingsJs.includes(route), `settings.js no longer reads or writes ${route}`);
+  }
+  assert.doesNotMatch(settingsJs, /function (renderVoices|renderWandering|loadVoices|loadWandering)\(/);
 });
 
-test('the interaction panel stays out of settings.js, which is against the size ratchet', () => {
-  // Not style: inlining this panel put settings.js at 1601 lines and regressed
-  // oversized_file_count 0→1 and excess_lines_total 0→102 (fitness-ratchets.js,
-  // OVERSIZE_LINES = 1500). The settings-sessions.js precedent, same reason.
-  const lines = settingsJs.split('\n').length;
-  assert.ok(lines < 1500, `settings.js is ${lines} lines — at or over the 1500 ratchet; carve the next panel out too`);
+test('Settings says where they went: one line to My agents in Preferences and one in Sound', () => {
+  const html = read('settings.html').replace(/<!--[\s\S]*?-->/g, '');
+  for (const [group, anchor] of [['preferences', '#talk'], ['sound', '#skills']]) {
+    const m = html.match(new RegExp(`<section class="scroll[^"]*" id="agents-moved-${group}"[^>]*>[\\s\\S]*?</section>`));
+    assert.ok(m, `a section in ${group} points to My agents`);
+    assert.match(m[0], new RegExp(`data-group="${group}"`), `it sits in the ${group} group`);
+    assert.doesNotMatch(m[0].match(/<section[^>]*>/)[0], /\bhidden\b/, 'drawn without waiting on any read');
+    assert.match(m[0], new RegExp(`href="/my-agents${anchor}"`), `it links to /my-agents${anchor}`);
+  }
+  // Sound still carries the sounds-off note (task 1004554), revealed at boot
+  assert.match(html, /id="sounds-off-scroll"[^>]*data-group="sound"/);
+  assert.match(settingsJs, /\$\('#sounds-off-scroll'\)\.hidden = false/);
 });
 
-// ---- the Rendering panel, carved out the same way (task 1002518) -----------
-//
-// Same two-file shape as the interaction panel above, and the same reason: the
-// knob became a four-rung ladder with a DERIVED default, which is more UI than
-// settings.js has room for. The extra fact this panel has to keep true is that
-// its "default" row explains itself — the default is computed from another
-// panel's answers, so a bare "default" tag would name a choice without naming
-// who made it.
-
-test('the rendering panel is wired end to end across its two files', () => {
+test('every old link to those sections lands on My agents', () => {
+  const Moved = requireHall('settings-moved.js');
+  const expect = {
+    interaction: '/my-agents#talk', rendering: '/my-agents#talk', render: '/my-agents#talk',
+    wandering: '/my-agents#work', voices: '/my-agents#skills', specialities: '/my-agents#knows',
+  };
+  for (const [anchor, to] of Object.entries(expect)) {
+    assert.equal(Moved.movedTarget('#' + anchor), to, `/settings#${anchor}`);
+  }
+  // the old section ids resolved as deep links too (resolveHash falls back to an element id)
+  for (const id of MOVED_SECTIONS) assert.match(String(Moved.movedTarget('#' + id)), /^\/my-agents#/, `/settings#${id}`);
+  for (const kept of ['', '#preferences', '#sound', '#cli', '#art-key', '#software-update', '#account']) {
+    assert.equal(Moved.movedTarget(kept), null, `${kept || 'no hash'} stays on Settings`);
+  }
+  // the anchors it sends to are ones My agents lands
+  const MyAgents = requireHall('my-agents.js');
+  for (const to of new Set(Object.values(expect))) assert.ok(MyAgents.anchorFor(to.slice(to.indexOf('#'))), `${to} is a My agents anchor`);
+  // settings.js asks before it draws anything, and on every later hash
   const html = read('settings.html');
-  const panelJs = read('settings-render.js');
-
-  const section = html.match(/<section class="scroll" id="render-scroll"[^>]*>/);
-  assert.ok(section, 'the panel has a section');
-  assert.match(section[0], /data-group="preferences"/, 'it joins a group the rail already renders');
-  assert.match(section[0], /\bhidden\b/, 'hidden until its own read succeeds');
-  assert.match(html, /<script src="\/builders\/settings-render\.js/, 'the page loads the panel script');
-
-  assert.match(panelJs, /\$\('#render-scroll'\)\.hidden = false/, 'the script reveals its own section');
-  assert.match(panelJs, /setup\(\);/, 'it self-boots — settings.js does not call it');
-
-  // settings.js keeps ONLY the anchor entry.
-  assert.match(settingsJs, /'rendering': 'render-scroll'/, 'the deep-link anchor stays in settings.js');
-  assert.doesNotMatch(settingsJs, /function renderRender\(/, 'the renderer moved out and must not come back inline');
-  assert.doesNotMatch(settingsJs, /loadRender\(\)/, 'and settings.js no longer calls it');
-});
-
-test('the rendering panel is a radio group, wired on change, and can clear the override', () => {
-  const panelJs = read('settings-render.js');
-  const render = panelJs.match(/function render\([\s\S]*?\n  \}\n/);
-  assert.ok(render, 'render is a whole function');
-  assert.match(render[0], /<input class="pradio" type="radio" name="render-level"/, 'a real radio group');
-  assert.match(render[0], /<label class="prow prow--pick"/, 'the whole row is the radio\'s label');
-  const setup = panelJs.match(/async function setup\([\s\S]*?\n  \}\n/);
-  assert.match(setup[0], /addEventListener\('change'/, 'a radio fires change, not click');
-  assert.match(setup[0], /closest\('\.pradio'\)/);
-  // The sentinel row must send null, not a level: pinning the rung that happens
-  // to be derived today would silently stop tracking the interaction profile.
-  assert.match(panelJs, /widgets: value === USE_DEFAULT \? null : value/,
-    'choosing "match my profile" CLEARS the override rather than pinning a level');
+  assert.ok(html.indexOf('settings-moved.js') > 0 && html.indexOf('settings-moved.js') < html.indexOf('/builders/settings.js'), 'loaded before settings.js');
+  assert.match(settingsJs, /location\.replace\(/, 'a replace, so Back does not bounce through Settings');
+  assert.doesNotMatch(settingsJs, /'(interaction|wandering|rendering|voices)': '[a-z-]+-scroll'/, 'no PANEL_ANCHORS entry for a section that left');
 });
 
-test('the derived default explains itself, because it is computed elsewhere', () => {
-  // Unlike every other picker on the page, "default" here is not a constant —
-  // render-prefs.js derives it from the interaction profile. A row that said
-  // only "default" would name a choice the reader never made and cannot see.
-  const panelJs = read('settings-render.js');
-  assert.match(panelJs, /derived_reason/, 'the row states WHY the default landed where it did');
-  assert.match(panelJs, /derived_level/, 'and WHICH rung that is');
-});
-
-test('a default value is named once, by the API, not twice by the row', () => {
-  // The first render read "Non-technical (default) · DEFAULT": interaction-prefs.js
-  // already ends every default value's LABEL with "(default)", and the row also
-  // carried the wandering picker's .prow__tag. One source for the word.
-  const panelJs = read('settings-interaction.js');
-  const render = panelJs.match(/function render\([\s\S]*?\n  \}\n/);
-  assert.ok(render, 'render is a whole function');
-  assert.doesNotMatch(render[0], /prow__tag/, 'the row must not re-state "default" beside a label that already says it');
+test('settings.js stays under the size ratchet', () => {
+  // Not style: inlining a panel once put settings.js at 1601 lines and regressed
+  // oversized_file_count 0→1 (fitness-ratchets.js, OVERSIZE_LINES = 1500).
+  const lines = settingsJs.split('\n').length;
+  assert.ok(lines < 1500, `settings.js is ${lines} lines — at or over the 1500 ratchet; carve the next panel out too`);
 });
 
 test('.craft-pref is a 24px target with a 14px drawn box — it was 13x13, the smallest control in the hall', () => {

package/tests/helpers.mjs

@@ -1016,13 +1016,14 @@ export function bootSkyPage({
 }
 
 // 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
+// (task 1005052). One component, modules/hall-ui/public/speciality-tools.js, was
+// mounted by Settings and by My agents; since task 1005044 My agents is its only
+// host (Settings links there). 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.
+// host lost from a 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
@@ -1034,7 +1035,7 @@ export function bootSkyPage({
 //   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'];
+export const SPECIALITY_PAGES = ['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"');
@@ -1043,7 +1044,7 @@ function specialitySection(page) {
   return html.slice(start, html.indexOf('</section>', at) + '</section>'.length);
 }
 export function bootSpecialityTools({
-  page = 'settings', catalog = [], adoptions = [], suggestions = [], skills = {}, installed = [], answer = null,
+  page = 'my-agents', 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;

package/tests/home_bounded_reads.mjs

@@ -28,7 +28,6 @@ const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const read = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8');
 const BUILDERS_JS = read('modules/hall-ui/public/builders.js');
-const WIDGETS_JS = read('modules/hall-ui/public/hall-widgets.js');
 const ROUTE = read('modules/lifecycle/routes/tasks.js');
 const DB_TASKS = read('modules/lifecycle/db-tasks.js');
 
@@ -48,26 +47,24 @@ await test('no Home read downloads a feed and slices it in the browser', () => {
   // DISPLAYED is fine; narrowing what was FETCHED is the bug, and the two look
   // identical at the call site — which is why this is a test and not a code review.
   const src = noComments(BUILDERS_JS);
-  for (const fn of ['loadNextUp', 'loadTriageInbox']) {
-    const from = src.indexOf(`function ${fn}(`);
-    assert.ok(from > 0, `${fn} must exist`);
-    const body = src.slice(from, src.indexOf('\n  }\n', from));
-    const name = fn;
-    const url = body.match(/\$\{API\}\/[^`'"]+/);
-    assert.ok(url, `${name} must issue a request`);
-    assert.match(url[0], /[?&]limit=\d+/, `${name} must ask the server for its page size`);
-  }
+  const from = src.indexOf('function loadTriageInbox(');
+  assert.ok(from > 0, 'loadTriageInbox must exist');
+  const body = src.slice(from, src.indexOf('\n  }\n', from));
+  const url = body.match(/\$\{API\}\/[^`'"]+/);
+  assert.ok(url, 'loadTriageInbox must issue a request');
+  assert.match(url[0], /[?&]limit=\d+/, 'loadTriageInbox must ask the server for its page size');
 });
 
-await test('the two cards ask for exactly the rows they draw', () => {
-  assert.match(BUILDERS_JS, /\$\{API\}\/tasks\/claimable\?limit=5/, 'Next up draws five rows, level with Recently shipped');
-  assert.match(BUILDERS_JS, /\$\{API\}\/inbox\?limit=5/, 'the triage card draws five');
-  // …and no longer re-slices what came back.
-  const src = noComments(BUILDERS_JS);
-  const from = src.indexOf('function loadNextUp(');
-  const body = src.slice(from, src.indexOf('\n  }\n', from));
-  assert.ok(body.length > 0, 'loadNextUp body found');
-  assert.doesNotMatch(body, /\.slice\(0,\s*2\)/, 'the client-side slice is gone');
+await test('the project city asks for ONE weekly summary, and the Next-up read left with its card', () => {
+  // task 1005054: Home's body is the project city. It draws from one bounded read
+  // the server counts per week (modules/lifecycle/home-city.js), never a task feed;
+  // the Next-up card and its GET /tasks/claimable read left Home with "Your work".
+  const CITY_JS = noComments(read('modules/hall-ui/public/home-city.js'));
+  const reads = [...CITY_JS.matchAll(/api\.request\('GET',\s*`([^`]+)`/g)].map((m) => m[1]);
+  assert.deepEqual(reads, ['${API}/home/city?weeks=${WEEKS}'], 'one read, asked for its window');
+  assert.doesNotMatch(CITY_JS, /\/tasks|claimable|recent-ships/, 'the city never downloads a feed');
+  assert.doesNotMatch(noComments(BUILDERS_JS), /function loadNextUp\(|tasks\/claimable/, 'Home no longer reads the claimable feed');
+  assert.match(BUILDERS_JS, /\$\{API\}\/inbox\?limit=5/, 'the triage card still draws five');
 });
 
 // ---------------------------------------------------------------------------
@@ -153,16 +150,4 @@ await test('the limit is applied AFTER the JS post-filters, not as a SQL LIMIT',
   assert.match(routeBody, /feed\.slice\(0, claimLimit\)/, 'the slice happens on the finished feed');
 });
 
-// ---------------------------------------------------------------------------
-// 4. what the reader sees
-// ---------------------------------------------------------------------------
-
-await test('the foot names the queue the two rows came off', () => {
-  assert.match(WIDGETS_JS, /id="home-next-foot"/, 'the link has an id to write into');
-  assert.match(BUILDERS_JS, /See all \$\{fmtNum\(total\)\} ready work/);
-  // Silent rather than wrong when the count is missing or not larger than what is
-  // shown: "See all 2" under two rows is noise, and a guessed number is worse.
-  assert.match(BUILDERS_JS, /Number\.isFinite\(total\) && total > rows\.length/);
-});
-
 summary();