@bongos/core 1.19.392 → 1.19.394

package/tests/landing_page.mjs

@@ -195,8 +195,9 @@ test('the social card is the world card, stamped onto THIS instance', () => {
 test('every cross-host link is stamped to THIS instance, never the platform', () => {
   const out = stamp();
   const halls = [...out.matchAll(/data-link-hall href="([^"]*)"/g)].map((m) => m[1]);
-  // the header nav pill and the footer entry
-  assert.ok(halls.length >= 2, 'the header and the footer both point at the hall');
+  // the footer entry (the bar carries no hall link since task 1003300 — the hall is a
+  // per-project affordance and the footer's door, on both pages)
+  assert.ok(halls.length >= 1, 'the footer points at the hall');
   for (const href of halls) assert.equal(href, 'https://builders.spike-harbor.example');
   // C6: this is the bug the stamping fixes — clientBranding() omits domains, so a
   // client fill can never re-point these and every child sent visitors to the platform.
@@ -453,3 +454,72 @@ test('the page satisfies the parked platform_boot assertions', () => {
   // an ORG-level action that lives only on the gate — asserted absent there
   assert.doesNotMatch(HTML, /Create a project/);
 });
+
+// ── the bar and the bands (task 1003300) ───────────────────────────────────
+// The hub's chrome on the front door: one hairline bar, the Projects band and
+// the profile band. Everything a visitor can reach is markup; the script only
+// opens and closes. These pin the shape the grader could not see from a diff.
+
+test('the bar is markup: the mark, the Projects trigger, the mode glyph, the sign-in door (task 1003300)', () => {
+  const body = HTML.split('<body>')[1].split('<script>')[0];
+  assert.match(body, /<header class="topbar bar">/, 'one bar, the hub\'s class beside the page\'s');
+  assert.match(body, /<a class="barMark" href="\/" aria-label="\{\{productName\}\}">\s*<svg viewBox="0 0 26 20"/, 'the static mark is the way home, labelled from the stamped name');
+  assert.match(body, /<span class="mark-word">\{\{productName\}\}<\/span>/, 'the product name as plain type, folded away under 900');
+  assert.match(body, /<button class="trig" type="button" id="projTrig" data-menu="projects" aria-expanded="false" aria-controls="menuProjects">Projects<svg class="cv"/);
+  assert.match(body, /<button class="modeBtn" id="mode" type="button" aria-label="Toggle light or dark">/);
+  assert.match(body, /<span class="whoSlot" id="who">\s*<a class="pill signin" href="\/api\/bongos\/auth\/web\/start\?return=\/">Sign in<\/a>\s*<\/span>/, 'the door stands in the identity slot until the session resolves');
+  // what left with the pill bar
+  assert.doesNotMatch(body, /class="pill nav-pill"|class="right-pills"|class="pill mark-pill"|data-nav="home"/, 'no nav pill, no right pills, no Home');
+  assert.doesNotMatch(body.slice(body.indexOf('<header'), body.indexOf('</header>')), /data-link-hall/, 'the bar carries no hall link — the footer does');
+  assert.doesNotMatch(PAGE_CSS, /--sky-topscrim|\.topbar::before/, 'the top wash left with the grounded bar');
+  assert.match(PAGE_CSS, /\.topbar\{position:relative;z-index:50;height:var\(--top-h\);display:flex;align-items:center;gap:22px;\s*padding:0 26px;background:var\(--bg\);border-bottom:1px solid var\(--rule\)\}/, 'the page ground closed by one hairline, z-index unified with the hub');
+});
+
+test('the Projects band deep-links the hub\'s views; About and Docs sit under a hairline; no item is current here', () => {
+  const body = HTML.split('<body>')[1].split('<script>')[0];
+  assert.match(body, /<div class="menuBand" id="menuProjects" data-menu="projects" hidden>/);
+  assert.match(body, /<a class="bandT" href="\/projects\?view=map">Sky<\/a>/);
+  assert.match(body, /<a class="bandT" href="\/projects\?view=map&amp;sub=table">Table<\/a>/, 'the Table item lands on the table (the hub reads sub=table on boot)');
+  assert.match(body, /<li class="bandCell" id="mineCell" hidden><a class="bandT" href="\/projects\?view=mine">Your projects<\/a>/, 'member-gated: hidden until the session resolves');
+  assert.match(body, /<a class="bandT" href="\/projects\?view=new">New project<\/a>/);
+  assert.match(body, /<ul class="bandRow bandMore">\s*<li class="bandCell"><a class="bandT" href="#about">About<\/a><\/li>\s*<li class="bandCell"><a class="bandT" href="\/docs">Docs<\/a><\/li>/, 'About and Docs under the hairline (§5)');
+  assert.match(body, /<section class="band" id="about">/, 'About has a real anchor: the lifecycle band');
+  assert.doesNotMatch(body.split('<main')[0], /aria-current/, 'the landing is none of those views');
+  // the profile band: the person, My projects, the deferred slot, Sign out as the honest anchor
+  assert.match(body, /<div class="menuBand" id="menuProfile" data-menu="profile" hidden>/);
+  assert.match(body, /<p class="bandWho" id="bandWho"><\/p>/);
+  assert.match(body, /<a class="bandT" href="\/projects\?view=mine">My projects<\/a>/);
+  assert.match(body, /<li class="bandSlot" aria-hidden="true"><\/li>/);
+  assert.match(body, /<a class="bandT signout" href="\/api\/bongos\/auth\/logout">Sign out<\/a>/);
+  // a crawler reads every destination without scripting on
+  for (const copy of ['Sky', 'Table', 'Your projects', 'New project', 'About', 'Docs', 'My projects', 'Sign out']) {
+    assert.ok(body.includes('>' + copy + '<'), `"${copy}" is only reachable with scripting on`);
+  }
+  // the menu container is .menuBand: .band is this page's own content sections
+  assert.match(PAGE_CSS, /\.menuBand\{position:relative;z-index:49;background:var\(--bg-card\);border-bottom:1px solid var\(--rule\);/);
+  assert.doesNotMatch(PAGE_CSS, /\.band\{[^}]*animation:bandIn/, 'the menu rule never lands on the content bands');
+  assert.match(PAGE_CSS, /\.bandMore \.bandT\{font-size:17px;font-weight:400;min-height:24px;display:inline-flex;align-items:center\}/, 'the About/Docs links clear the 24px floor');
+});
+
+test('the bands are one disclosure: Escape returns focus, arrows cycle, Tab out closes, one closes the other', () => {
+  assert.match(CODE, /function openBand\(\) \{ return document\.querySelector\('\.menuBand:not\(\[hidden\]\)'\); \}/);
+  assert.match(CODE, /function closeMenus\(\) \{[\s\S]*?if \(inside && trig\) trig\.focus\(\);/, 'focus restoration is a property of the close, not of one caller');
+  assert.match(CODE, /function openMenu\(trig, byKeyboard\) \{[\s\S]*?closeMenus\(\);[\s\S]*?if \(byKeyboard\) \{ var first = band\.querySelector\('\.bandCell:not\(\[hidden\]\) a'\); if \(first\) first\.focus\(\); \}/, 'opening one closes the other; Enter lands on the first visible item');
+  assert.match(CODE, /else openMenu\(t, ev\.detail === 0\);/, 'a keyboard-fired click is told apart from a pointer');
+  assert.match(CODE, /if \(ev\.key === 'Escape'\) \{ closeMenus\(\); return; \}/);
+  assert.match(CODE, /if \(ev\.key !== 'ArrowDown' && ev\.key !== 'ArrowUp'\) return;/);
+  assert.match(CODE, /return !a\.closest\('\[hidden\]'\);/, 'the arrows skip the hidden Your-projects cell');
+  assert.match(CODE, /b\.addEventListener\('focusout', function \(ev\) \{[\s\S]*?if \(!to \|\| b\.contains\(to\) \|\| \(to\.closest && to\.closest\('\.trig'\)\)\) return;[\s\S]*?closeMenus\(\);/, 'Tab out closes; a null relatedTarget is left alone');
+  assert.match(CODE, /if \(ev\.target\.closest && \(ev\.target\.closest\('\.menuBand'\) \|\| ev\.target\.closest\('\.trig'\)\)\) return;[\s\S]*?closeMenus\(\);/, 'a click outside closes');
+  assert.doesNotMatch(HTML, /role="menu"|aria-haspopup/, 'plain links in a disclosure — what is announced is what ships');
+});
+
+test('the chip is the profile trigger, built with createElement; Sign out is the POST', () => {
+  assert.match(CODE, /var chip = document\.createElement\('button'\);[\s\S]*?chip\.className = 'trig who';[\s\S]*?chip\.setAttribute\('data-menu', 'profile'\);[\s\S]*?chip\.setAttribute\('aria-controls', 'menuProfile'\);/);
+  assert.match(CODE, /chip\.setAttribute\('aria-label', 'Account, ' \+ me\.github_login\);/, 'the trigger names the account');
+  assert.match(CODE, /wireTrigger\(chip\);/, 'a chip built after boot is wired like the static trigger');
+  assert.match(CODE, /if \(who\) who\.appendChild\(document\.createTextNode\(me\.github_login\)\);/, 'the band names the person');
+  assert.match(CODE, /if \(mine\) mine\.hidden = false;/, 'a member sees the Your-projects cell');
+  assert.match(CODE, /var signout = document\.querySelector\('#menuProfile a\.signout'\);\s*if \(signout\) signout\.addEventListener\('click', function \(e\) \{ e\.preventDefault\(\); doLogout\(\); \}\);/, 'the honest href, upgraded to the POST');
+  assert.doesNotMatch(CODE, /className = 'pill signout'/, 'no sign-out pill in the bar any more');
+});

package/tests/project_visibility_db.mjs

@@ -0,0 +1,175 @@
+// tests/project_visibility_db.mjs — BV1.R04, task 1002323 (goal 1000046; real DB).
+//
+// The DB-free sibling (modules/platform-identity/tests/platform-identity.mjs) pins the
+// JS gate and the migration's TEXT. This proves what only a real transaction engine can:
+//
+//   1. THE BACKFILL — a row that existed BEFORE migration 011 comes out `visibility =
+//      'public'` (today's behaviour, unchanged) with `description` still NULL, because
+//      ADR 0182 D4 refuses to seed the publish bar from `tagline`.
+//   2. THE CHECK actually refuses a fourth stored state — 'unlisted' / 'dark-matter'
+//      cannot be written, which is the constraint the whole 3+1 split rests on.
+//   3. THE DERIVED GATE agrees in SQL and in JS — publishableSql() and
+//      projectPublishability() return the same verdict for the same row, so the feed
+//      (R06) and the owner-facing refusal (R16) cannot disagree about who is on the map.
+//   4. `featured = true AND status = 'active'` is NO LONGER "is this public" — a
+//      featured, active, visibility='public' husk with no description is dark matter.
+//   5. A client re-registration (registerClient → upsertProject) never resets an owner's
+//      door: the hub row is a CACHE and the door arrives by report (ADR 0182 D5 / R08).
+//   6. The migration is IDEMPOTENT — replaying it over populated rows changes nothing.
+//
+// Real-DB integration test: self-skips without a reachable Postgres; in run-unit-tests.js's
+// INTEGRATION set so the default DB-free lane never runs it.
+//
+// Run:  DATABASE_URL=... node tests/project_visibility_db.mjs
+
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { strict as assert } from 'node:assert';
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+const pi = require('../modules/platform-identity/platform-identity.js');
+
+const here = dirname(fileURLToPath(import.meta.url));
+const MIG_DIR = join(here, '..', 'modules', 'platform-identity', 'migrations');
+const migrationSql = (f) => readFileSync(join(MIG_DIR, f), 'utf8');
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`project_visibility_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+// Fixture origins carry the task id so a shared DB can never collide with real rows.
+const LEGACY = 'https://legacy-1002323.test';
+const HUSK = 'https://husk-1002323.test';
+const FULL = 'https://full-1002323.test';
+const ALL = [LEGACY, HUSK, FULL];
+
+const q = (sql, params) => pool.query(sql, params);
+const cleanup = async () => {
+  await q(`DELETE FROM platform_identity_projects WHERE origin = ANY($1::text[])`, [ALL]).catch(() => {});
+  await q(`DELETE FROM platform_identity_sso_clients WHERE origin = ANY($1::text[])`, [ALL]).catch(() => {});
+};
+
+let pass = 0;
+const ok = (cond, msg) => { assert.ok(cond, msg); pass++; console.log(`  ok - ${msg}`); };
+const rowOf = async (origin) => (await q(
+  `SELECT id, origin, name, tagline, description, visibility, status, featured
+     FROM platform_identity_projects WHERE origin = $1`, [origin],
+)).rows[0];
+
+try {
+  // The table as it stood BEFORE this task, so the backfill has something to act on.
+  await q(migrationSql('platform_identity_001_tables.sql'));
+  await q(migrationSql('platform_identity_004_projects.sql'));
+  await q(migrationSql('platform_identity_006_project_type.sql'));
+  await cleanup();
+
+  // ---------------------------------------------------------------------------
+  // 1. The backfill: a pre-migration row keeps today's behaviour.
+  // ---------------------------------------------------------------------------
+  await q(
+    `INSERT INTO platform_identity_projects (origin, name, tagline, featured)
+     VALUES ($1, 'Legacy', 'a card one-liner', true)`, [LEGACY],
+  );
+  await q(migrationSql('platform_identity_011_project_visibility.sql'));
+
+  const legacy = await rowOf(LEGACY);
+  ok(legacy.visibility === 'public', 'the backfill IS the DEFAULT: a pre-migration row lands visibility=public');
+  ok(legacy.description === null, 'description is NOT seeded from tagline (ADR 0182 D4) — the card cannot publish the project');
+  ok(legacy.tagline === 'a card one-liner', 'the existing tagline is untouched');
+  ok(legacy.featured === true && legacy.status === 'active', 'nothing else about the row moved');
+
+  // ---------------------------------------------------------------------------
+  // 2. The CHECK refuses a stored fourth state.
+  // ---------------------------------------------------------------------------
+  for (const forbidden of ['unlisted', 'dark-matter', 'published', '']) {
+    let refused = false;
+    try {
+      await q(`UPDATE platform_identity_projects SET visibility = $2 WHERE origin = $1`, [LEGACY, forbidden]);
+    } catch (e) {
+      refused = e.code === '23514'; // check_violation
+    }
+    ok(refused, `the DB CHECK refuses visibility='${forbidden}' — there is no stored fourth state`);
+  }
+  for (const allowed of ['public', 'private', 'stealth']) {
+    await q(`UPDATE platform_identity_projects SET visibility = $2 WHERE origin = $1`, [LEGACY, allowed]);
+    ok((await rowOf(LEGACY)).visibility === allowed, `the DB accepts the door value '${allowed}'`);
+  }
+  await q(`UPDATE platform_identity_projects SET visibility = 'public' WHERE origin = $1`, [LEGACY]);
+
+  // ---------------------------------------------------------------------------
+  // 3 + 4. The derived gate: SQL and JS agree, and `featured` no longer answers it.
+  // ---------------------------------------------------------------------------
+  await pi.upsertProject({ origin: HUSK, name: 'Husk' }, { pool });
+  await pi.upsertProject({ origin: FULL, name: 'Full', description: 'A weather simulation.' }, { pool });
+  await q(`UPDATE platform_identity_projects SET featured = true WHERE origin = ANY($1::text[])`, [[HUSK, FULL]]);
+
+  const verdicts = (await q(
+    `SELECT origin, name, description, ${pi.publishableSql()} AS publishable
+       FROM platform_identity_projects WHERE origin = ANY($1::text[]) ORDER BY origin`,
+    [[HUSK, FULL, LEGACY]],
+  )).rows;
+  for (const row of verdicts) {
+    const js = pi.projectPublishability(row);
+    ok(row.publishable === js.publishable,
+      `SQL and JS agree on ${row.origin} (publishable=${row.publishable}) — the feed and the refusal cannot drift`);
+  }
+  const husk = verdicts.find((r) => r.origin === HUSK);
+  ok(husk.publishable === false, 'a featured, active, visibility=public project with no description is DARK MATTER');
+  ok(pi.projectPublishability(husk).missing.join() === 'description', 'and the gate NAMES the missing field, never merely refuses');
+  ok(verdicts.find((r) => r.origin === FULL).publishable === true, 'name + description alone clears the bar — the gate is identity only');
+
+  // A whitespace-only description is not an identity, in SQL too (btrim, not NULL-checks).
+  await q(`UPDATE platform_identity_projects SET description = '   ' WHERE origin = $1`, [FULL]);
+  const blank = (await q(
+    `SELECT ${pi.publishableSql()} AS publishable FROM platform_identity_projects WHERE origin = $1`, [FULL],
+  )).rows[0];
+  ok(blank.publishable === false, 'a whitespace-only description does not clear the bar in SQL either');
+  await q(`UPDATE platform_identity_projects SET description = 'A weather simulation.' WHERE origin = $1`, [FULL]);
+
+  // The aliased form is the one R06 will use across a join — prove it parses and agrees.
+  const joined = (await q(
+    `SELECT p.origin, ${pi.publishableSql('p')} AS publishable
+       FROM platform_identity_projects p WHERE p.origin = $1`, [FULL],
+  )).rows[0];
+  ok(joined.publishable === true, 'publishableSql(alias) is valid SQL in a joined query and agrees');
+
+  // ---------------------------------------------------------------------------
+  // 5. The hub row is a CACHE — no write path here resets an owner's door.
+  // ---------------------------------------------------------------------------
+  await q(`UPDATE platform_identity_projects SET visibility = 'stealth' WHERE origin = $1`, [FULL]);
+  await pi.registerClient(
+    { clientId: `c-1002323-${Date.now()}`, secret: 'z'.repeat(64), name: 'Full', redirectUris: [], origin: FULL },
+    { pool },
+  );
+  ok((await rowOf(FULL)).visibility === 'stealth',
+    'a client re-registration does not reset the door to public (ADR 0182 D5 — the door arrives by report, R08)');
+  await pi.upsertProject({ origin: FULL, name: 'Full renamed' }, { pool });
+  const afterUpsert = await rowOf(FULL);
+  ok(afterUpsert.visibility === 'stealth', 'nor does a descriptionless catalog upsert');
+  ok(afterUpsert.description === 'A weather simulation.', 'nor does it erase the description (COALESCE-preserved)');
+
+  // A stealth project is a NORMAL row in the curation list — all three doors are visible.
+  const listed = (await pi.listAllProjects({ pool })).find((p) => p.origin === FULL);
+  ok(listed && listed.visibility === 'stealth' && listed.publishable === true,
+    'listAllProjects carries the stored door and the derived verdict together');
+
+  // ---------------------------------------------------------------------------
+  // 6. Idempotent replay over populated rows.
+  // ---------------------------------------------------------------------------
+  await q(migrationSql('platform_identity_011_project_visibility.sql'));
+  const replayed = await rowOf(FULL);
+  ok(replayed.visibility === 'stealth' && replayed.description === 'A weather simulation.',
+    'replaying migration 011 over populated rows changes nothing');
+
+  console.log(`\nproject_visibility_db: ${pass} assertions passed`);
+} finally {
+  await cleanup();
+  await pool.end().catch(() => {});
+}

package/tests/projects_hub.mjs

@@ -36,17 +36,23 @@ test('all three views ship as real markup, not built by script (C7)', () => {
   assert.match(HUB, /Your projects/);
 });
 
-test('the nav carries Home plus the three views, and Home is not a view', () => {
-  assert.match(HUB, /data-nav="home"[^>]*>Home|<a href="\/" class="navHome" data-nav="home">Home/);
+test('the Projects band carries the views; Home is gone and the mark is the way home (task 1003300)', () => {
+  assert.doesNotMatch(HUB, /data-nav="home"/, 'no Home item — the logo is home');
+  assert.match(HUB, /<a class="barMark" id="barMark" href="\/">/, 'the mark links home');
   for (const v of ['map', 'mine', 'new']) {
     assert.match(HUB, new RegExp(`href="\\?view=${v}"\\s+data-nav="${v}"`),
-      `the nav must deep-link ?view=${v}`);
+      `the band must deep-link ?view=${v}`);
   }
-  // Home navigates to the landing page; it must never take the current-view pill
-  assert.match(SCRIPT, /if \(a\.dataset\.nav === 'home'\) return;/,
-    'the view router must leave Home as a real navigation');
-  assert.match(SCRIPT, /a\.dataset\.nav !== 'home' && a\.dataset\.nav === v/,
-    'Home must be excluded from the aria-current pill');
+  // Sky and Table are two VIEWS of the map (direction record §7): both are the
+  // map deep link, and the sub-view rides on the item so setSub lights the one
+  // on stage; the Sky|Table seg and the toolbar row it sat in are retired
+  assert.match(HUB, /href="\?view=map" data-nav="map" data-sub="sky" aria-current="page">Sky<\/a>/);
+  assert.match(HUB, /href="\?view=map&amp;sub=table" data-nav="map" data-sub="table">Table<\/a>/);
+  assert.match(SCRIPT, /get\('sub'\) === 'table'\) setSub\('table'\);/, 'the Table deep link lands on the table');
+  assert.match(HUB, /<a class="bandT" href="\/#about">About<\/a>/, 'About sits under the hairline (§5)');
+  assert.doesNotMatch(HUB, /id="sub-sky"|id="sub-table"|class="toolbar"|class="seg"/, 'the toolbar and its seg are retired');
+  assert.doesNotMatch(SCRIPT, /dataset\.nav === 'home'/, 'no dead Home branch in the router');
+  assert.match(SCRIPT, /if \(a\.dataset\.sub\) setSub\(a\.dataset\.sub\);/, 'a band item may pick the map sub-view');
 });
 
 test('?view= is the deep-link contract, read on boot and written with replaceState', () => {
@@ -113,24 +119,35 @@ test('the hall link is not labelled "Enter the Hall"', () => {
   assert.doesNotMatch(HUB, /Enter the Hall/i);
 });
 
-test('the wordmark holds bongos still and colors it apart (task 1002793)', () => {
-  // Owner-reported: the block caret glyph + a literal space read as two
-  // characters of air; every typed letter shifted bongos; both words wore the
-  // accent. The caret is now a thin drawn bar (no glyph), the prefix sits in a
-  // width-pinned box measured per word BEFORE typing, and only bongos keeps
-  // the accent — the landing's static mark already colors only its bongos
-  // span, so the two shells read as one system.
-  assert.match(HUB,
-    /<span class="markLeft" id="markLeft"><span id="markPrefix">cloud<\/span><span class="caret" aria-hidden="true"><\/span><\/span> <span id="markWord">bongos<\/span>/,
-    'prefix + caret share the pinned box; a single literal space reaches bongos; the caret carries no glyph');
-  assert.match(SCRIPT, /meas\.textContent = w/,
-    'the coming word is measured before it is typed');
-  assert.match(SCRIPT, /box\.style\.width = \(meas\.offsetWidth \+ 4\) \+ 'px'/,
-    'the box is pinned to the full word so bongos cannot move mid-word');
-  assert.ok(COSMOS.includes('.shell .mark #markPrefix{color:var(--chrome-ink);}'),
-    'the typed word wears the base ink — the shared span rule (which the landing relies on) stays');
-  assert.match(COSMOS, /\.shell \.caret\{[^}]*width:2px[^}]*background:var\(--chrome-accent\)/,
-    'the caret is a drawn 2px bar, not a full character cell');
+test('the hub carries the static mark; the self-typing wordmark lives on the landing only (task 1003300, §7)', () => {
+  // The owner's ruling with the v2 pick: the typing wordmark "can probably only
+  // live on the landing page". Here the bongo-pair glyph and the product name
+  // are plain type; the mark is the only way home and is labelled from the
+  // product name a re-branded instance stamps, never from its visible text.
+  assert.match(HUB, /<a class="barMark" id="barMark" href="\/">\s*<svg viewBox="0 0 26 20" aria-hidden="true"/);
+  assert.match(HUB, /<span data-brand-product-inline>Cloud Bongos<\/span>\s*<\/a>/);
+  assert.doesNotMatch(HUB, /id="markLeft"|id="markPrefix"|id="markWord"|id="markMeasure"|class="caret"/, 'no typing apparatus on the hub');
+  assert.doesNotMatch(SCRIPT, /function typeMark|var PREFIXES/, 'no typing loop on the hub');
+  assert.match(SCRIPT, /\$\('barMark'\)\.setAttribute\('aria-label', productName \+ ' — home'\);/);
+  assert.doesNotMatch(COSMOS, /\.shell \.mark|\.shell \.caret|cbBlink|\.navrow/, 'the wordmark and nav-row rules left cosmos with the markup');
+});
+
+test('the bands: one disclosure, two instances — Escape returns focus, the card yields, the search hides off the map (task 1003300)', () => {
+  assert.match(HUB, /<button class="trig" type="button" id="projTrig" data-menu="projects" aria-expanded="false" aria-controls="menuProjects">Projects/);
+  assert.match(HUB, /<button class="trig who" type="button" id="who" data-menu="profile" aria-expanded="false" aria-controls="menuProfile" hidden><\/button>/, 'signed out the profile trigger does not exist');
+  assert.match(HUB, /<div class="menuBand" id="menuProjects" data-menu="projects" hidden>/);
+  assert.match(HUB, /<div class="menuBand" id="menuProfile" data-menu="profile" hidden>/);
+  assert.doesNotMatch(HUB, /role="menu"|aria-haspopup/, 'plain links in a disclosure — announced as what ships');
+  assert.match(SCRIPT, /function closeMenus\(\) \{[\s\S]*?if \(inside && trig\) trig\.focus\(\);/, 'focus restoration is a property of the close, not of one caller');
+  assert.match(SCRIPT, /if \(ev\.key === 'Escape' && !openBand\(\)\) closeCard\(\);/, 'the card yields Escape to an open band');
+  assert.match(SCRIPT, /function setView\(v, focus\) \{[\s\S]*?\$\('qWrap'\)\.hidden = \$\('qToggle'\)\.hidden = \(v !== 'map'\);/, 'the search hides off the map in the router');
+  const identity = (SCRIPT.match(/function paintShellIdentity\(\) \{([\s\S]*?)\n  \}/) || [, ''])[1];
+  assert.ok(identity, 'paintShellIdentity must exist');
+  assert.doesNotMatch(identity, /qWrap|mapQ/, 'the search is public — never gated on identity');
+  assert.match(identity, /querySelectorAll\('\[data-nav="mine"\]'\)/, 'every mine item, never the singular query (§6)');
+  assert.match(HUB, /<a class="bandT signout" href="\/api\/bongos\/auth\/logout">Sign out<\/a>/, 'sign out is the honest hover target');
+  assert.match(SCRIPT, /\$\('menuProfile'\)\.addEventListener\('click', function \(ev\) \{\s*var a = ev\.target\.closest && ev\.target\.closest\('a\.signout'\);/, 'upgraded to the POST by delegation on the band');
+  assert.match(HUB, /<!--apex-only:start--><a data-link-hall href="\{\{buildersOrigin\}\}">Builders' hall<\/a><!--apex-only:end--><\/nav><\/footer>/, 'the hall link lives in the footer, as on the landing');
 });
 
 test('orb accents are tokens, never literal hexes (§6)', () => {
@@ -157,19 +174,9 @@ test('accents are assigned by canonical position, not by hashing the name', () =
     'name-hashed accents collide — assign from a canonical order');
 });
 
-test('the mark holds "bongos" and types the assistant, not the other way round', () => {
-  // `bongos` is the word a person types; the assistant is what varies. This is
-  // the same correction the landing hero needed.
-  assert.match(HUB, /<span id="markWord">bongos<\/span>/);
-  const prefixes = (SCRIPT.match(/var PREFIXES = \[([^\]]*)\]/) || [, ''])[1];
-  assert.ok(prefixes.length, 'the typed prefix list must be findable');
-  assert.doesNotMatch(prefixes, /'bongos'/, 'bongos is the constant, never a typed variant');
-  assert.match(prefixes, /'claude'/);
-});
-
 test('the typing and the map both respect prefers-reduced-motion (C9)', () => {
   assert.match(SCRIPT, /prefers-reduced-motion: reduce/);
-  assert.match(SCRIPT, /if \(REDUCED \|\|/, 'the typing loop must be skipped under reduced motion');
+  assert.match(SCRIPT, /if \(REDUCED\) stopSky\(\); else startSky\(\);/, 'a reduce-motion flip stops the sky');
 });
 
 test('the owner poll is view-guarded — it must not run on the map (C8)', () => {
@@ -393,44 +400,16 @@ test('the count includes the platform when it is shown', () => {
   assert.match(SCRIPT, /var shown = list\.length \+ \(selfShown \? 1 : 0\)/);
 });
 
-/* ── The wordmark's cadence (task 1002765) ──────────────────────────────────
-   The mark completed a word and erased it on the same tick, so the word the
-   animation exists to show was never legible. Owner-reported, twice. ── */
-
-test('the wordmark HOLDS the finished word before erasing it', () => {
-  const mark = (SCRIPT.match(/function typeMark\(\)([\s\S]*?)\n  \}\)\(\);/) || [, ''])[1];
-  assert.ok(mark, 'typeMark() must exist');
-  // the regression shape: one interval that flips direction the moment it
-  // completes a word, so there is no dwell at full length
-  assert.doesNotMatch(mark, /setInterval/,
-    'a single reversing interval cannot hold — it turns around on the tick it completes');
-  assert.match(mark, /HOLD\s*=\s*\d+/, 'the hold must be a named duration, not an accident of timing');
-  // and it must actually be a pause worth reading, not a couple of frames
-  const hold = Number((mark.match(/HOLD\s*=\s*(\d+)/) || [, 0])[1]);
-  assert.ok(hold >= 600, `the hold must be legible; got ${hold}ms`);
-});
-
-test('the wordmark rests on the real product name, not on a joke', () => {
-  const mark = (SCRIPT.match(/function typeMark\(\)([\s\S]*?)\n  \}\)\(\);/) || [, ''])[1];
-  assert.match(mark, /w === 'cloud' \? HOLD_HOME : HOLD/,
-    'the canonical prefix should dwell longest — it is the wordmark, the others are the gag');
-  const home = Number((mark.match(/HOLD_HOME\s*=\s*(\d+)/) || [, 0])[1]);
-  const hold = Number((mark.match(/HOLD\s*=\s*(\d+)/) || [, 0])[1]);
-  assert.ok(home > hold, 'the resting state must outlast the alternates');
-});
-
-test('the hub wordmark keeps its own typing cadence; the landing hero no longer types (task 1003298)', () => {
-  // The landing's self-typing eyebrow ("type bongos in any AI") retired with the
-  // chrome world: its hero is the h1, the lede and the doors, and its only motion is
-  // the CSS breath. The hub's typing wordmark stays; a shared cadence is no longer a
-  // thing to keep in step, so this pins the hub half and the landing's silence.
+/* ── The wordmark's cadence left the hub (task 1003300) ─────────────────────
+   The hub carries the static mark since the v2 pick; the typing loop, its hold
+   and its rest-on-cloud rule (task 1002765) are landing concerns now (direction
+   record §7). What stays pinned is the landing hero's silence (task 1003298)
+   and the hub's. ── */
+
+test('neither the landing hero nor the hub types (tasks 1003298, 1003300)', () => {
   const LANDING = fs.readFileSync(path.join(ROOT, 'public-landing', 'index.html'), 'utf8');
   assert.doesNotMatch(LANDING, /id="typed"|setTimeout\(type\b/, 'the landing hero does not type');
-  const mark = (SCRIPT.match(/function typeMark\(\)([\s\S]*?)\n  \}\)\(\);/) || [, ''])[1];
-  assert.ok(mark, 'the hub wordmark still types');
-  for (const name of ['HOLD_HOME', 'HOLD']) {
-    assert.match(mark, new RegExp(name + '\\s*=\\s*\\d+'), `the hub declares ${name}`);
-  }
+  assert.doesNotMatch(SCRIPT, /function typeMark\(\)|HOLD_HOME|setTimeout\(type\b/, 'the hub has no typing loop');
 });
 
 /* ── The project card (task 1002770) ────────────────────────────────────────

package/tests/projects_hub_pre_uat.mjs

@@ -198,12 +198,14 @@ test('Back moves between views — a deliberate view change is a history entry',
   assert.match(SCRIPT, /else if \(v === 'manage' && a\.dataset\.nav === 'mine'\) a\.setAttribute\('aria-current', 'page'\)/, 'manage keeps the Your-projects pill lit');
 });
 
-test('the signed-in header shrinks inside a phone and stays one row on a laptop', () => {
-  assert.match(COSMOS, /@media \(max-width:1079px\)\{[\s\S]*?\.shell-right\{flex:0 1 auto;min-width:0;max-width:100%;/, 'the cluster may shrink and wrap');
-  assert.match(COSMOS, /@media \(min-width:1080px\)\{[\s\S]*?\.shell \.navrow\{position:absolute;left:50%;top:50%;transform:translate\(-50%,-50%\);\}/, 'the nav is centred absolutely, flanks size to content');
-  assert.doesNotMatch(COSMOS, /@media \(max-width:820px\)\{\n\s*\.shell\{justify-content:center;\}/, 'no band is left between the two rules');
+test('the bar is the page ground closed by a hairline, holds one row on a phone, and the chip truncates (task 1003300)', () => {
+  assert.match(COSMOS, /\.bar\{display:flex;align-items:center;gap:22px;height:var\(--top-h\);padding:0 var\(--gutter\);\n\s*background:var\(--bar-bg\);border-bottom:1px solid var\(--rule\);\}/, 'the bar is the page ground closed by one hairline');
+  assert.match(COSMOS, /@media \(max-width:900px\)\{\n\s*:root\{--top-h:60px;/, 'one 60px row under 900');
+  assert.match(COSMOS, /@media \(max-width:900px\)\{[\s\S]*?\.barMark span\{display:none;\}/, 'the wordmark folds away, the glyph stays');
+  assert.match(COSMOS, /@media \(max-width:480px\)\{[\s\S]*?\.qToggle\{display:inline-flex;\}[\s\S]*?\.qWrap\{display:none;\}/, 'under 480 the search folds into the magnifier');
+  assert.doesNotMatch(COSMOS, /\.navrow|\.shell-right|\.shell \.mark/, 'the nav row and the equal-flank machinery left with the markup');
   assert.match(COSMOS, /\.who>span\{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;max-width:14ch;\}/, 'a long login truncates');
-  assert.match(COSMOS, /\.search:focus-within\{box-shadow:/, 'keyboard focus on the search pills is visible');
+  assert.match(COSMOS, /\.search:focus-within\{box-shadow:/, 'keyboard focus on the mine search pill is visible');
   assert.match(COSMOS, /\.mineBar \.search \.count\{display:none;\}/, 'the count leaves the placeholder alone at 390px');
   assert.match(COSMOS, /\.projMeta>span\+span::before\{content:'·'/, 'the meta separator rides its item');
   assert.match(HUB, /#view-mine \.hero,#view-manage \.hero\{max-width:none;\}/, 'titles align with their cards');
@@ -449,7 +451,7 @@ test('the hub has one main landmark, a heading for the map, a footer, and a skip
   assert.ok(main > 0 && main < map && close > HUB.indexOf('<section id="view-new"') && foot > close, 'the four views sit inside #hubMain, the footer after it');
   assert.equal((HUB.match(/<main\b/g) || []).length, 1, 'exactly one main');
   assert.match(HUB, /<section id="view-map">\n\s*<h1 class="vh">The project map<\/h1>/, 'the map view has a heading');
-  assert.match(HUB, /<a class="skip vh" href="#hubMain">Skip to content<\/a>\n<header class="shell">/, 'the skip link is the first thing before the shell');
+  assert.match(HUB, /<a class="skip vh" href="#hubMain">Skip to content<\/a>\n<header class="shell bar">/, 'the skip link is the first thing before the shell');
   assert.match(HUB, /\.skip:focus\{position:fixed;top:8px;left:8px;/, 'it becomes a real pill on focus');
   assert.doesNotMatch(HUB, /<main class="card">/, 'the old inner main is a div');
 });
@@ -480,10 +482,10 @@ test('control nits: orb cursor, caret under reduced motion, mode label, home lab
   assert.doesNotMatch(COSMOS, /\.orb\{flex:0 0 54px;[^}]*cursor:pointer/, 'the base orb is not a pointer');
   assert.match(COSMOS, /\na\.orb\{cursor:pointer;\}/, 'only the linked orb is');
   assert.doesNotMatch(COSMOS, /\.orb\.ghost\{[^}]*cursor:default/);
-  assert.match(HUB, /@media \(prefers-reduced-motion:reduce\)\{\.shell \.caret\{display:none;\}\}/, 'the caret hides instead of freezing solid');
+  assert.doesNotMatch(HUB, /\.shell \.caret/, 'no caret to hide — the hub mark is static (task 1003300)');
   assert.match(fn('paintModeToggle'), /el\.setAttribute\('aria-label', dark \? 'Switch to light mode' : 'Switch to dark mode'\);/);
   assert.doesNotMatch(fn('paintModeToggle'), /aria-pressed/);
-  assert.match(SCRIPT, /\$\('markLeft'\)\.parentNode\.setAttribute\('aria-label', productName \+ ' — home'\);\n\s*if \(REDUCED \|\|/, 'the home link is labelled before the typing loop’s early return');
+  assert.match(SCRIPT, /\$\('barMark'\)\.setAttribute\('aria-label', productName \+ ' — home'\);/, 'the mark — the only way home — is labelled from the product name');
   assert.match(SCRIPT, /var REDUCED_MQ = window\.matchMedia \? window\.matchMedia\('\(prefers-reduced-motion: reduce\)'\) : null;/);
   assert.match(SCRIPT, /if \(REDUCED\) stopSky\(\); else startSky\(\);/, 'a mid-session flip stops or restarts the sky');
   assert.match(SCRIPT, /REDUCED_MQ\.addEventListener\('change', onReducedChange\)/);