@bongos/core 1.24.41 → 1.24.43

package/tests/hall_palette.mjs

@@ -35,7 +35,7 @@ const SHELL_SRC = read('shell.js');
 // SAME stub every time — real enough to fire DOM events at and read innerHTML
 // back from, which the pure-compute-only harness never needed before task 1003460
 // wired a real fetch() into the input handler.
-function bootPalette({ navItems = [], visibleIds = ['nav-standing', 'nav-work', 'shell-user'], modules = null, fetchImpl = undefined } = {}) {
+function bootPalette({ navItems = [], visibleIds = ['nav-profile', 'nav-work', 'shell-user'], modules = null, fetchImpl = undefined } = {}) {
   const registry = {};
   const makeNav = (it) => ({
     hidden: !!it.hidden,
@@ -113,7 +113,7 @@ async function settleSearch() { await tick(400); }
 const NAV_FIXTURE = [
   { label: 'Home', href: '/' },
   { label: 'Tasks', href: '/work' },
-  { label: 'Accomplishments', href: '/#accomplishments' },
+  { label: 'Profile', href: '/profile' },
   { label: 'Economy', href: '/drachmae' },
   { label: 'API docs', href: '/docs', external: true },
   { label: 'Watch', href: '/watch', hidden: true },   // Archon-only, gated off
@@ -126,22 +126,17 @@ function declaredHrefs(prefixTest) {
   return [...PALETTE_SRC.matchAll(/href:\s*'([^']+)'/g)].map((m) => m[1]).filter(prefixTest);
 }
 
-// task 1004826: Standing is Accomplishments to the reader; the sections are
-// #accomplishments-<group>, aliased onto the 'standing' view's anchors.
-test('Accomplishments section anchors exist in builders.js and are routable in shell.js', () => {
-  // task 1003206: STANDING_GROUPS moved to hall-render.js — read the family.
-  const groups = [...hallSource().matchAll(/\{ key: '([a-z]+)', label: '[^']+' \}/g)].map((m) => m[1]);
-  assert.ok(groups.length >= 4, `sanity: found STANDING_GROUPS (${groups})`);
-  assert.ok(!declaredHrefs((h) => h.startsWith('/#standing')).length, 'the palette names the page by its new name');
-  const declared = declaredHrefs((h) => h.startsWith('/#accomplishments-')).map((h) => h.replace('/#', ''));
-  assert.ok(declared.length, 'palette declares Accomplishments sections');
-  for (const id of declared) {
-    const key = id.replace('accomplishments-', '');
-    assert.ok(groups.includes(key), `${id} must be a real STANDING_GROUPS key (builders.js)`);
-    // shell.js must alias it, or route() ignores the hash and the jump goes nowhere.
-    assert.match(SHELL_SRC, new RegExp(`'${id}':\\s*\\{ view: 'standing', anchor: 'standing-${key}' \\}`),
-      `${id} must have a VIEW_ALIASES entry in shell.js`);
-  }
+// task 1005050: Accomplishments folded into Profile, so the palette's numbers
+// jumps are the profile's own screens — profile.js RAIL_ITEMS — and its old words
+// ("Accomplishments", karma, progress) still find the "Just you" screen.
+test('Profile section anchors are real profile.js rail keys', () => {
+  const block = (read('profile.js').match(/const RAIL_ITEMS = \[([\s\S]*?)\];/) || [, ''])[1];
+  const keys = [...block.matchAll(/id: '([a-z]+)'/g)].map((m) => m[1]);
+  assert.ok(keys.includes('yours'), `sanity: profile.js rail keys (${keys})`);
+  const declared = declaredHrefs((h) => h.startsWith('/profile#'));
+  assert.ok(declared.length >= 3, 'palette declares the profile screens');
+  for (const h of declared) assert.ok(keys.includes(h.split('#')[1]), `${h} must be a real profile.js rail key`);
+  assert.ok(!declaredHrefs((h) => /^\/#(standing|accomplishments)/.test(h)).length, 'no jump points at the retired view');
 });
 
 test('Tasks tab anchors exist in work.js makeTabs', () => {
@@ -195,8 +190,8 @@ test('My agents anchors are ones my-agents.js lands, and the moved Settings pane
 });
 
 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,
+  const keys = ['overview', 'works', 'activity', 'connections', 'yours'];
+  assert.equal(keys.includes('profile#nope'.split('#')[1]), false,
     'an invented section id fails the membership check the tests above apply');
 });
 
@@ -205,17 +200,17 @@ test('the anchor guard actually CATCHES a declared id that does not exist', () =
 test('pages come from the sidebar, and a gated-off nav item is not a destination', () => {
   const P = bootPalette({ navItems: NAV_FIXTURE });
   const labels = P.compute('').filter((r) => r.group === 'Pages').map((r) => r.label);
-  assert.deepEqual(labels, ['Home', 'Tasks', 'Accomplishments', 'Economy', 'API docs']);
+  assert.deepEqual(labels, ['Home', 'Tasks', 'Profile', 'Economy', 'API docs']);
   assert.ok(!labels.includes('Watch'), 'a hidden (rank-gated) nav item must not be jumpable');
 });
 
 test('section groups appear only when their owning nav item is visible', () => {
   const all = bootPalette({ navItems: NAV_FIXTURE }).compute('');
-  assert.ok(all.some((r) => r.group === 'Accomplishments'), 'Accomplishments sections offered when nav-standing shows');
+  assert.ok(all.some((r) => r.group === 'Profile'), 'Profile sections offered when nav-profile shows');
   assert.ok(all.some((r) => r.group === 'Settings'), 'Settings panels offered when the profile chip shows');
 
   const gatedOut = bootPalette({ navItems: NAV_FIXTURE, visibleIds: [] }).compute('');
-  assert.ok(!gatedOut.some((r) => ['Accomplishments', 'Tasks', 'Settings'].includes(r.group)),
+  assert.ok(!gatedOut.some((r) => ['Profile', 'Tasks', 'Settings'].includes(r.group)),
     'no sub-destinations when their owners are hidden');
 });
 
@@ -242,7 +237,7 @@ test('a non-matching query yields nothing (the empty state), and text still matc
   const P = bootPalette({ navItems: NAV_FIXTURE });
   assert.deepEqual(P.compute('zzzqqq'), []);
   assert.equal(P.compute('econ')[0].label, 'Economy', 'substring match');
-  assert.equal(P.compute('stw')[0].label, 'Work', 'subsequence match reaches Standing > Work');
+  assert.equal(P.compute('accomplishments')[0].href, '/profile#yours', 'the old word still finds where its private half went');
 });
 
 // ---- progressive enhancement + wiring -------------------------------------

package/tests/hall_profile_world.mjs

@@ -63,7 +63,8 @@ const profileCss = stripComments(read('profile.css'));
 // The plot's dataviz spec lives in the kit's sheet since task 1003445.
 const styleCss = stripComments(read('style.css'));
 
-const GROUPS = ['overview', 'works', 'activity', 'connections'];
+// task 1005050: 'yours' joined — Accomplishments' private half, on your own profile only.
+const GROUPS = ['overview', 'works', 'activity', 'connections', 'yours'];
 
 // ---- the rail and the groups ---------------------------------------------------
 
@@ -89,8 +90,12 @@ test('every section in the groups carries a known data-group, and the keys are t
   assert.equal(groupOf('works-scroll'), 'works', 'the works ledger is its own key');
   assert.equal(groupOf('activity-scroll'), 'activity');
   assert.equal(groupOf('conn-scroll'), 'connections');
+  for (const id of ['rank-scroll', 'grades-scroll', 'karma-scroll', 'acclaim-scroll', 'analytics-scroll']) {
+    assert.equal(groupOf(id), 'yours', `#${id} is on the "Just you" screen`);
+    assert.match(html, new RegExp(`id="${id}"[^>]*data-group="yours" hidden>`), `#${id} starts hidden`);
+  }
   const railKeys = profileJs.match(/const RAIL_ITEMS = \[([\s\S]*?)\];/)[1].match(/id: '([a-z]+)'/g).map((s) => s.slice(5, -1));
-  assert.deepEqual(railKeys, GROUPS, 'the rail lists the four keys in reading order');
+  assert.deepEqual(railKeys, GROUPS, 'the rail lists the five keys in reading order');
 });
 
 test('the sheet shows exactly the active group, and a hidden section stays hidden', () => {

package/tests/hall_reading_room.mjs

@@ -156,7 +156,8 @@ test('the lifecycle, the rank ladder and credits and karma are each explained ON
   const ladder = PRIMER_MD.slice(PRIMER_MD.indexOf('## The rank ladder'), PRIMER_MD.indexOf('## Credits and karma'));
   for (const rank of ['Xenos', 'Thetes', 'Metic', 'Archon']) assert.match(ladder, new RegExp(`\\*\\*${rank}\\*\\*`));
   assert.match(ladder, /### How you advance/);
-  assert.match(ladder, /\/builders#accomplishments-progress/, 'and it points the reader at their own standing');
+  // task 1005050: Accomplishments folded into Profile; the card is its "Just you" screen.
+  assert.match(ladder, /\/builders\/profile#yours/, 'and it points the reader at their own standing');
 });
 
 test('the two stale primer lines are gone', () => {
@@ -172,7 +173,7 @@ test('the primer keeps a hall address in the hall, and sends repo paths to GitHu
   // Lift the resolver out of primer.js without booting the page.
   const src = primerJs.slice(primerJs.indexOf('  const resolveLinkHref = (() => {'), primerJs.indexOf('  function toast('));
   const fn = vm.runInContext(`(() => { const MD = window.OTBMdReader; const PRIMER_DIR = 'docs/onboarding/'; let repoBlobBase = 'https://gh/blob/main'; let repoTreeBase = 'https://gh/tree/main';\n${src}\nreturn resolveLinkHref; })()`, sandbox);
-  assert.equal(fn('/builders#accomplishments-progress'), '/builders#accomplishments-progress');
+  assert.equal(fn('/builders/profile#yours'), '/builders/profile#yours');
   assert.equal(fn('drachmae-and-karma.md'), 'https://gh/blob/main/docs/onboarding/drachmae-and-karma.md',
     'the full reference is a repo doc now that its hall page is a chapter');
   assert.equal(fn('../adr/'), 'https://gh/tree/main/docs/adr');

package/tests/helpers.mjs

@@ -542,7 +542,9 @@ const PROFILE_CRAFTS_JS = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/publi
 // tab each. The default leads with the ideator, so the trail is the first tab
 // and a suite that reads it needs no switch; switchCraft('engineer') opens the
 // works and goals, switchCraft('artist') the approved pages.
-export function bootProfilePage({ signedIn = true, trail = [], roles = ['ideator', 'engineer'], artistPages = [] } = {}) {
+// `search` is the page's ?query (task 1005050: ?id= decides whose profile it is), and
+// `withOwn` also loads profile-own.js, the "Just you" screen drawn on your own profile.
+export function bootProfilePage({ signedIn = true, trail = [], roles = ['ideator', 'engineer'], artistPages = [], search = '', withOwn = false } = {}) {
   const els = new Map();
   const makeEl = () => ({
     dataset: {}, style: {}, textContent: '', hidden: false, _html: '',
@@ -617,6 +619,8 @@ export function bootProfilePage({ signedIn = true, trail = [], roles = ['ideator
       return { active: () => current, activate(id) { current = id; onChange(id); }, setCount() {} };
     },
     shipVisualThumbHtml: () => '',
+    // profile-own.js's peer-recognition pager (task 1005050).
+    paginate: (rows) => rows, wirePager() {}, pagerBarHtml: () => '',
   };
 
   const windowObj = {
@@ -638,7 +642,7 @@ export function bootProfilePage({ signedIn = true, trail = [], roles = ['ideator
       rankLabel: (r) => r,
       toast() {},
     },
-    location: { hostname: 'builders.cloudbongos.com', search: '', pathname: '/profile' },
+    location: { hostname: 'builders.cloudbongos.com', search, pathname: '/profile' },
     localStorage: { getItem: () => null, setItem() {} },
     addEventListener() {},
     matchMedia: () => ({ matches: false }),
@@ -655,6 +659,7 @@ export function bootProfilePage({ signedIn = true, trail = [], roles = ['ideator
   vm.runInContext(PROFILE_ROLES_JS, sandbox, { filename: 'profile-roles.js' });
   vm.runInContext(IDEA_OBJECTS_JS, sandbox, { filename: 'idea-objects.js' });
   vm.runInContext(PROFILE_CRAFTS_JS, sandbox, { filename: 'profile-crafts.js' });
+  if (withOwn) vm.runInContext(fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/profile-own.js'), 'utf8'), sandbox, { filename: 'profile-own.js' });
   vm.runInContext(PROFILE_JS, sandbox, { filename: 'profile.js' });
 
   const htmlFor = (mountId) => {
@@ -666,6 +671,7 @@ export function bootProfilePage({ signedIn = true, trail = [], roles = ['ideator
     htmlFor,
     switchCraft: (id) => { if (tabsOnChange) tabsOnChange(id); },
     el: (id) => documentObj.getElementById(id),
+    window: windowObj,
   };
 }
 

package/tests/leaderboard_roles.mjs

@@ -236,7 +236,7 @@ function extract(src, start, end) {
 
 await test('the standing card adds the place inside the builder\'s main role, only when it says something new', () => {
   const src = read('modules/hall-ui/public/hall-render.js');
-  const code = extract(src, 'const lbState = { rows: [] };', '    return { acclaimEvidenceHtml');
+  const code = extract(src, 'const lbState = { rows: [] };', '    return { lbState');
   const sandbox = { rows: FIX.leaderboard };
   vm.createContext(sandbox);
   vm.runInContext(`${code}; lbState.rows = rows; this.place = leaderboardPlace; this.text = rolePlaceText;`, sandbox);

package/tests/module_contributions.mjs

@@ -228,7 +228,8 @@ test('the role axis has exactly one user-facing word, and no surface types it',
     'modules/hall-ui/public/work.js',
     'modules/hall-ui/public/goals-page.js',
     'modules/hall-ui/public/profile.js',
-    'modules/hall-ui/public/builders.js',
+    // task 1005076: the setup screen's role step replaced builders.js's checklist picker.
+    'modules/hall-ui/public/setup-gate.js',
   ];
   for (const p of SURFACES) {
     const s = readSrc(p);
@@ -266,7 +267,8 @@ test('craft picker options: neither picker hardcodes the craft list any more', (
   // silently dropped a module-contributed craft. Whichever picker is edited next
   // must keep reading the server list.
   const read = (p) => readFileSync(path.join(ROOT, p), 'utf8');
-  for (const p of ['modules/hall-ui/public/settings.js', 'modules/hall-ui/public/hall-render.js']) {
+  // task 1005076: the second picker is the setup screen's role step (it was the Home checklist's).
+  for (const p of ['modules/hall-ui/public/settings.js', 'modules/hall-ui/public/setup-gate.js']) {
     const src = read(p);
     assert.ok(/OTB\.disciplines\(\)/.test(src), `${p} builds its options from OTB.disciplines()`);
     assert.ok(!/\['engineer',\s*'artist',\s*'ideator'\]/.test(src), `${p} no longer hardcodes the craft triple`);
@@ -312,11 +314,13 @@ test('hall-widget registry: placement rules reject bad registrations, accept goo
     assert.ok(reg({ id: 'e', view: 'home', zone: 'home-main', summary: true }));
     assert.ok(reg({ id: 'f', view: 'home', zone: 'home-main', collapsedByDefault: true }));
     assert.ok(reg({ id: 'g', view: 'home', zone: 'home-main', core: true }));
-    // a non-Home view needs no zone (Standing widgets carry `group` instead)
-    assert.ok(reg({ id: 'h', view: 'standing', group: 'work' }));
+    // task 1005050: 'standing' (Accomplishments) left the views with the view
+    // itself — it folded into the Profile page — so a widget naming it is refused.
+    assert.equal(reg({ id: 'h', view: 'standing', group: 'work' }), null);
+    assert.match(errors.at(-1), /unknown view "standing"/);
 
-    // only the accepted four reached the registry
-    assert.deepEqual(OTB.hallWidgetIds(), ['e', 'f', 'g', 'h']);
+    // only the accepted three reached the registry
+    assert.deepEqual(OTB.hallWidgetIds(), ['e', 'f', 'g']);
   } finally {
     console.error = realError;
     delete global.window;

package/tests/nav_permission_atoms.mjs

@@ -96,8 +96,10 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // Market Watch settings nav item and its fuel glyph; task 1005041: the Update pill replaced the
 // core-update banner; task 1005045: the Market Watch settings item left (one sidebar item);
 // task 1005046: Ranks, Economy and Diagrams left Docs (one reading room, the Primer);
-// task 1005049: Sessions and Autobongos left the sidebar (tabs on Watch).
-const SHELL_SHA = 'bb0abbadab2508ca';
+// task 1005049: Sessions and Autobongos left the sidebar (tabs on Watch);
+// task 1005076: the setup flow's holdForSetup;
+// task 1005050: Accomplishments left it (folded into Profile; its hashes redirect).
+const SHELL_SHA = '050dbf4ceac560dc';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);

package/tests/onboarding_state.mjs

@@ -322,6 +322,39 @@ test('graduation is engine-only (display signals never gate it)', async () => {
   assert.ok(shaped.stages.every((s) => s.cleared === true));
 });
 
+// ---- the setup flow (task 1005076) -----------------------------------------
+
+const SETUP_IDS = ['signed_in', 'cli_setup', 'pick_disciplines', 'first_start'];
+const setupOf = (state, opts) => onboarding.shapeForApi(state, opts).setup;
+const clearedIds = (setup) => setup.steps.filter((s) => s.cleared).map((s) => s.id);
+
+test('setup: a brand-new xenos is held, with only signed_in cleared', () => {
+  const setup = setupOf(null, { rank: 'xenos' });
+  assert.equal(setup.complete, false);
+  assert.deepEqual(setup.steps.map((s) => s.id), SETUP_IDS);
+  assert.deepEqual(clearedIds(setup), ['signed_in']);
+  assert.ok(setup.steps.every((s) => s.label && s.hint), 'every step says what to do');
+});
+
+test('setup: each step ticks from its own signal, and all four complete it', () => {
+  const state = { current_stage: 'pick_disciplines', completed_stages: ['auth_complete'] };
+  assert.deepEqual(clearedIds(setupOf(state, { rank: 'xenos', cliAuthed: true })), ['signed_in', 'cli_setup']);
+  const picked = { current_stage: 'first_start', completed_stages: ['auth_complete', 'pick_disciplines'] };
+  const almost = setupOf(picked, { rank: 'xenos', cliAuthed: true });
+  assert.equal(almost.complete, false, 'first_start not yet run from Claude');
+  const started = { current_stage: 'first_claim', completed_stages: ['auth_complete', 'pick_disciplines', 'first_start'] };
+  assert.equal(setupOf(started, { rank: 'xenos', cliAuthed: true }).complete, true);
+  assert.equal(setupOf(started, { rank: 'xenos', cliAuthed: false }).complete, false, 'no linked machine, not set up');
+});
+
+test('setup: anyone already past it goes straight in', () => {
+  const fresh = { current_stage: 'auth_complete', completed_stages: [] };
+  for (const rank of ['thetes', 'metic', 'archon']) assert.equal(setupOf(fresh, { rank }).complete, true, rank);
+  assert.equal(setupOf({ current_stage: 'graduated', completed_stages: [] }, { rank: 'xenos' }).complete, true, 'graduated');
+  assert.equal(setupOf({ current_stage: 'ship_three', completed_stages: ['first_claim'] }, { rank: 'xenos' }).complete, true, 'claimed a task');
+  assert.equal(setupOf(fresh, {}).complete, false, 'an unknown rank is not a pass');
+});
+
 // ---- wrap-up --------------------------------------------------------------
 
 Promise.resolve().then(async () => {

package/tests/page_tweak_artist.mjs

@@ -195,7 +195,8 @@ await test('the status page and the acclaim feed render the helper', () => {
   const status = readFileSync(new URL('../modules/status-ui/public/status.js', import.meta.url), 'utf8');
   assert.match(status, /t\.helper_display_name \|\| t\.helper_login/);
   assert.match(status, /with help from \$\{helper\}/);
-  const hall = readFileSync(new URL('../modules/hall-ui/public/builders.js', import.meta.url), 'utf8');
+  // task 1005050: the acclaim feed moved with Accomplishments to the profile's "Just you" screen.
+  const hall = readFileSync(new URL('../modules/hall-ui/public/profile-own.js', import.meta.url), 'utf8');
   assert.match(hall, /with help from \$\{escapeHtml\(helperName\)\}/, 'escaped before it reaches innerHTML');
   const feed = readFileSync(new URL('../modules/lifecycle/routes/tasks.js', import.meta.url), 'utf8');
   assert.match(feed, /helper\.helper_login, helper\.helper_display_name/, 'the acclaim feed carries the helper');

package/tests/rank_tier_single_source.mjs

@@ -93,6 +93,9 @@ const STATIC_LADDER_FILES = [
   'modules/discord/discord-channels.js',
   'modules/memory/search.js',
   'modules/hall-ui/public/profile.js',
+  // task 1005050: Where you stand moved with Accomplishments to the profile's "Just
+  // you" screen and reads the rung above yours off this ladder.
+  'modules/hall-ui/public/profile-own.js',
   // task 1005048: the rank <select> on each roster row moved from watch.js to the
   // Builders page with the roster itself; the copy moved with it.
   'modules/hall-ui/public/roster.js',

package/tests/setup_flow.mjs

@@ -0,0 +1,242 @@
+// tests/setup_flow.mjs — the setup flow a new builder finishes once (task 1005076).
+//
+// Owner, 2026-11-05: a new builder is held on one setup screen until every step is done,
+// and once set up they are in for good — no setup banner on Home. Three halves, each run
+// for real: the claimable route ticks first_start only for a Claude (CLI) session; the
+// shell loads setup-gate.js and draws nothing else over it while setup is incomplete; and
+// the screen draws the steps, saves a craft, and lets the builder in once /me says done.
+// The rule itself (which steps, who goes straight in) is in tests/onboarding_state.mjs.
+//
+// Run:  node tests/setup_flow.mjs
+
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { makeEl, realOTB, settle } from './helpers.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const read = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8');
+const ROUTE = read('modules/lifecycle/routes/tasks.js');
+const SHELL = read('modules/hall-ui/public/shell.js');
+const GATE = read('modules/hall-ui/public/setup-gate.js');
+
+let passed = 0;
+let failed = 0;
+const t = async (name, fn) => {
+  try { await fn(); passed += 1; console.log(`  PASS  ${name}`); }
+  catch (e) { failed += 1; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+};
+
+const STEPS = (cleared) => ['signed_in', 'cli_setup', 'pick_disciplines', 'first_start']
+  .map((id) => ({ id, label: `Label ${id}`, hint: `Hint ${id}`, cleared: cleared.includes(id) }));
+
+console.log('the setup flow (task 1005076)');
+
+// ---- the claimable route: first_start only from Claude --------------------
+
+// The real guarded statement, run against each kind of session.
+const from = ROUTE.indexOf("if (req.gdsSession && req.gdsSession.source === 'cli')");
+const guard = ROUTE.slice(from, ROUTE.indexOf('\n', from));
+const runGuard = (gdsSession) => {
+  const marks = [];
+  const seams = { resolveOptional: () => ({ safeMarkStage: (_pool, id, stage) => marks.push([id, stage]) }) };
+  vm.runInNewContext(guard, { req: { gdsSession, builder: { id: 7 } }, seams, pool: {} });
+  return marks;
+};
+
+await t('GET /tasks/claimable marks first_start for a Claude (CLI) session, never for the browser', () => {
+  assert.ok(from > 0, 'the guard is in the claimable handler');
+  assert.match(guard, /safeMarkStage\(pool, req\.builder\.id, 'first_start', req\.builder\)/);
+  assert.deepEqual(runGuard({ source: 'cli' }), [[7, 'first_start']]);
+  assert.deepEqual(runGuard({ source: 'web' }), [], 'the hall pages read this feed from the browser');
+  assert.deepEqual(runGuard(null), []);
+  assert.equal((ROUTE.match(/'first_start'/g) || []).length, 1, 'no unguarded mark elsewhere in the routes');
+});
+
+// ---- the screen ------------------------------------------------------------
+
+function bootGate({ patchOk = true } = {}) {
+  const body = makeEl('body');
+  const htmlClasses = new Set();
+  const requests = [];
+  let reloaded = 0;
+  let me = null;
+  const api = { request: (method, p, opts) => {
+    requests.push({ method, p, body: opts && opts.body });
+    if (method === 'PATCH') return Promise.resolve({ ok: patchOk, status: patchOk ? 200 : 422, data: {} });
+    return Promise.resolve({ ok: true, status: 200, data: me });
+  } };
+  const intervals = [];
+  const document = {
+    body,
+    documentElement: { classList: { add: (c) => htmlClasses.add(c), remove: (c) => htmlClasses.delete(c) } },
+    createElement: (tag) => makeEl(tag),
+    getElementById: (id) => body.querySelector('#' + id),
+    activeElement: null,
+  };
+  // the crafts this project offers (dom-utils.js reads them off __MODULES__)
+  const window = { OTB: { ...realOTB(), disciplines: () => ['engineer', 'artist', 'ui'] }, location: { reload: () => { reloaded += 1; } } };
+  const sandbox = { window, document, setInterval: (fn) => { intervals.push(fn); return intervals.length; }, clearInterval() {} };
+  vm.createContext(sandbox);
+  vm.runInContext(GATE, sandbox, { filename: 'setup-gate.js' });
+  return {
+    show: (setup, builder) => window.OTBSetupGate.show(setup, { api, builder }),
+    gate: () => body.querySelector('#setup-gate'),
+    htmlClasses, requests, intervals,
+    setMe: (v) => { me = v; },
+    reloaded: () => reloaded,
+    click: (target) => body.querySelector('#setup-gate').fire('click', { target }),
+  };
+}
+
+await t('the screen lists every step in order, ticks the cleared ones, and opens the first gap', () => {
+  const g = bootGate();
+  g.show({ complete: false, steps: STEPS(['signed_in', 'cli_setup']) }, { display_name: 'Sam' });
+  const gate = g.gate();
+  assert.ok(gate, 'drawn');
+  assert.equal(gate.getAttribute('aria-modal'), 'true');
+  assert.ok(g.htmlClasses.has('setup-gate-open'), 'the hall behind it does not scroll');
+  assert.match(gate.querySelector('#setup-gate-h').textContent, /Welcome, Sam/);
+  assert.equal(gate.querySelector('.setup-gate__count').textContent, '2 of 4 done');
+  const steps = gate.querySelectorAll('.setup-gate__step');
+  assert.deepEqual(steps.map((s) => s.className), ['setup-gate__step is-done', 'setup-gate__step is-done', 'setup-gate__step is-current', 'setup-gate__step']);
+  assert.match(steps[2].textContent, /Hint pick_disciplines/, 'only the current step shows its hint');
+  assert.doesNotMatch(steps[3].textContent, /Hint first_start/);
+  assert.deepEqual(gate.querySelectorAll('[data-craft]').map((b) => b.textContent), ['Engineer', 'Artist', 'UI'],
+    'the crafts this project offers');
+});
+
+await t('choosing a craft saves it through PATCH /me/disciplines, the route every picker uses', async () => {
+  const g = bootGate();
+  g.show({ complete: false, steps: STEPS(['signed_in', 'cli_setup']) });
+  const save = () => g.gate().querySelector('[data-save-crafts]');
+  assert.equal(save().disabled, true, 'nothing picked, nothing to save');
+  g.click(g.gate().querySelector('[data-craft="artist"]'));
+  assert.equal(g.gate().querySelector('[data-craft="artist"]').getAttribute('aria-pressed'), 'true');
+  assert.equal(save().disabled, false);
+  g.setMe({ onboarding: { setup: { complete: false, steps: STEPS(['signed_in', 'cli_setup', 'pick_disciplines']) } } });
+  g.click(save());
+  await settle(); await settle();
+  const patch = g.requests.find((r) => r.method === 'PATCH');
+  assert.equal(patch.p, '/api/bongos/me/disciplines');
+  assert.deepEqual(JSON.parse(JSON.stringify(patch.body)), { preferred_disciplines: ['artist'] });
+  assert.equal(g.gate().querySelector('.setup-gate__count').textContent, '3 of 4 done', 're-read /me and ticked');
+});
+
+await t('a craft that does not save says so and can be tried again', async () => {
+  const g = bootGate({ patchOk: false });
+  g.show({ complete: false, steps: STEPS(['signed_in', 'cli_setup']) });
+  g.click(g.gate().querySelector('[data-craft="engineer"]'));
+  g.click(g.gate().querySelector('[data-save-crafts]'));
+  await settle();
+  const err = g.gate().querySelector('[data-craft-err]');
+  assert.equal(err.hidden, false);
+  assert.match(err.textContent, /did not save/);
+  assert.equal(g.gate().querySelector('[data-save-crafts]').disabled, false);
+});
+
+await t('it checks /me while it is up, and lets the builder in the moment setup is complete', async () => {
+  const g = bootGate();
+  g.show({ complete: false, steps: STEPS(['signed_in', 'cli_setup', 'pick_disciplines']) });
+  assert.equal(g.intervals.length, 1, 'it polls');
+  g.setMe({ onboarding: { setup: { complete: true, steps: STEPS(['signed_in', 'cli_setup', 'pick_disciplines', 'first_start']) } } });
+  g.intervals[0]();
+  await settle();
+  assert.equal(g.gate(), null, 'the screen is gone');
+  assert.ok(!g.htmlClasses.has('setup-gate-open'));
+  assert.equal(g.reloaded(), 1, 'the page reloads into the hall');
+});
+
+await t('a complete setup draws nothing', () => {
+  const g = bootGate();
+  g.show({ complete: true, steps: STEPS(['signed_in', 'cli_setup', 'pick_disciplines', 'first_start']) });
+  assert.equal(g.gate(), null);
+});
+
+// ---- the shell: loads the screen, and nothing else is drawn over it ---------
+
+function bootShell({ deferLoad = false } = {}) {
+  const loaded = [];
+  const pending = [];
+  const asked = [];
+  let sandbox = null;
+  const stubEl = () => ({
+    dataset: {}, style: {}, textContent: '', hidden: false, innerHTML: '',
+    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+    setAttribute() {}, getAttribute() { return null; }, removeAttribute() {}, addEventListener() {},
+    querySelector() { return null; }, querySelectorAll() { return []; }, appendChild() {}, focus() {},
+  });
+  const els = new Map();
+  const document = {
+    body: { dataset: { page: 'work' }, appendChild() {} },
+    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } } },
+    getElementById(id) { if (!els.has(id)) els.set(id, stubEl()); return els.get(id); },
+    querySelectorAll() { return []; }, createElement: () => stubEl(),
+    addEventListener() {}, dispatchEvent() {}, get cookie() { return ''; }, set cookie(_v) {},
+    head: { appendChild(tag) {
+      loaded.push(tag.src);
+      const land = () => {
+        if (/setup-gate/.test(tag.src)) sandbox.window.OTBSetupGate = { show: (setup) => asked.push(['gate', setup.complete]) };
+        if (tag.onload) tag.onload();
+      };
+      if (deferLoad && /setup-gate/.test(tag.src)) pending.push(land); else land();
+    } },
+  };
+  const location = { hostname: 'h', origin: 'https://h', pathname: '/work', hash: '', assign() {}, replace() {} };
+  const window = {
+    OTB: realOTB(), __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => ({ request: () => new Promise(() => {}) }) },
+    // the boot pass runs before anyone is signed in, when neither draws anything: count signed-in asks only
+    OTBWelcome: { onAccess: (access) => { if (access.authed === true) asked.push(['welcome']); return false; } },
+    OTBCraftMode: { onAccess: (access) => { if (access.authed === true) asked.push(['craft']); }, applyNav() {}, mount() {}, setPositions() {}, switchHtml: () => '' },
+    matchMedia: () => ({ matches: false, addEventListener() {} }),
+    localStorage: { getItem: () => null, setItem() {} },
+    requestAnimationFrame() {}, scrollTo() {}, location, addEventListener() {},
+  };
+  sandbox = { window, document, location, console, setTimeout, clearTimeout, queueMicrotask,
+    CustomEvent: class { constructor(tp, i) { this.type = tp; Object.assign(this, i); } } };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(SHELL, sandbox, { filename: 'shell.js' });
+  return { apply: (state) => window.OTBShell.applyAccess(state), land: () => pending.splice(0).forEach((f) => f()), loaded, asked };
+}
+
+await t('the shell holds an unfinished builder on the setup screen, with no welcome or craft picker over it', () => {
+  const s = bootShell();
+  s.apply({ authed: true, rank: 'xenos', builder: { id: 9 }, setup: { complete: false, steps: STEPS(['signed_in']) } });
+  assert.equal(s.loaded.filter((u) => /^\/builders\/setup-gate\.js/.test(u)).length, 1, 'its file is loaded');
+  assert.deepEqual(s.asked, [['gate', false]], 'the screen, and nothing over it');
+});
+
+await t('the setup screen loads once, however often the shell re-checks access before it lands', () => {
+  const s = bootShell({ deferLoad: true });
+  const held = { authed: true, rank: 'xenos', builder: { id: 9 }, setup: { complete: false, steps: STEPS(['signed_in']) } };
+  s.apply(held);
+  s.apply(held);
+  s.apply(held);
+  assert.equal(s.loaded.filter((u) => /setup-gate\.js/.test(u)).length, 1, 'one script tag, so one screen');
+  s.land();
+  assert.deepEqual(s.asked, [['gate', false]]);
+});
+
+await t('a set-up builder loads no setup file and gets the hall as before', () => {
+  const s = bootShell();
+  s.apply({ authed: true, rank: 'xenos', builder: { id: 9 }, setup: { complete: true, steps: [] } });
+  assert.equal(s.loaded.filter((u) => /setup-gate/.test(u)).length, 0);
+  assert.ok(!s.asked.some(([k]) => k === 'gate'), 'no setup screen');
+  assert.deepEqual(s.asked.slice(0, 2), [['welcome'], ['craft']], 'the daily welcome and craft picker as before');
+  const unknown = bootShell();
+  unknown.apply({ authed: true, rank: 'xenos', builder: { id: 9 }, setup: null });
+  assert.equal(unknown.loaded.filter((u) => /setup-gate/.test(u)).length, 0, 'an older server that sends no setup holds nobody');
+});
+
+await t('Home carries no setup banner: the Welcome and Getting started panels are gone', () => {
+  const widgets = read('modules/hall-ui/public/hall-widgets.js');
+  assert.doesNotMatch(widgets, /w\('welcome-scroll'|w\('onboarding-scroll'/);
+  assert.doesNotMatch(read('modules/hall-ui/public/index.html'), /welcome-reopen|Show the setup guide again/);
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);

package/tests/task_visuals.mjs

@@ -280,7 +280,9 @@ await t('the callers reach for OTBVisual, and no longer for the kit', () => {
     assert.ok(!/OTBKit(\.|\[')?\s*(shipVisualThumbHtml|taskVisualFigureHtml|isTaskVisualUrl)/.test(src),
       `${f} still reads a visual renderer off OTBKit`);
   }
-  assert.ok(HALL('hall-render.js').includes('window.OTBVisual.shipVisualThumbHtml'));
+  // task 1005050: Home's ship ledger (the one hall-render.js thumbnail) left with
+  // Accomplishments; the Profile's Works ledger is the ship-thumbnail caller now.
+  assert.ok(HALL('profile.js').includes('window.OTBVisual.shipVisualThumbHtml'));
   assert.ok(HALL('studio.js').includes('vis.taskVisualFigureHtml('));
 });
 

package/tests/welcome_boot.mjs

@@ -122,6 +122,7 @@ test('Home loads the welcome before the shell, and the shell asks it before the
     'welcome-boot.js, then the shell trio');
   assert.ok(at('welcome-boot.css') > 0, 'and its sheet');
   const shell = fs.readFileSync(path.join(HALL, 'shell.js'), 'utf8');
-  assert.match(shell, /if \(!\(window\.OTBWelcome && window\.OTBWelcome\.onAccess\(access, state && state\.builder\)\) && CRAFT\) CRAFT\.onAccess\(/,
-    'the picker is asked only when the welcome did not show');
+  // task 1005076: and neither is asked while the setup screen holds the builder (tests/setup_flow.mjs).
+  assert.match(shell, /if \(!holdForSetup\(state && state\.builder\) && !\(window\.OTBWelcome && window\.OTBWelcome\.onAccess\(access, state && state\.builder\)\) && CRAFT\) CRAFT\.onAccess\(/,
+    'the picker is asked only when setup is done and the welcome did not show');
 });