@bongos/core 1.19.1014 → 1.19.1015

package/tests/goal_map_page.mjs

@@ -1,267 +1,402 @@
-// tests/goal_map_page.mjs — the goal map page, EXECUTED (task 1003479, goal
-// 1000089; ADR 0227 §5 and §7).
+// tests/goal_map_page.mjs — THE PROJECT SKY at /goal-map, EXECUTED (task
+// 1004232 / sky part 4 of 5, goal 1000095; ADR 0331, ADR 0227 §11).
 //
-// The real hall-kit.js, the real goal-map-lib.js and the real goal-map.js run in
-// one vm against a stub DOM and a stubbed GET /goals/graph. What the ADR made
-// non-negotiable is asserted here as behaviour, not read off the source:
-//   - the TABLE is on the page by default (§5.1) — no toggle hides it;
-//   - category is TEXT on every node as well as a colour (§5.3);
-//   - the picture scrolls inside its own box and never widens the page (§5.2);
-//   - there is no control that could reach view A (every task) or view D
-//     (densified) (§7) — the only fetch is the aggregate;
-//   - the stand-alone goals are a list, not dots (§10.4 item 1), and the split is
-//     stated on the page.
-// Plus the one thing the browser adds that a lib test cannot see: a goal title is
-// builder-authored text and must never become markup.
+// The page that held this URL was the goal map (task 1003479): a layered
+// node-link picture with a table under it, no control, no nav slot. This
+// suite replaced the one that pinned it. The sky the owner adopted as the
+// design of record (docs/design/mocks/sky/) took the URL, in its "the whole
+// project" lens, and the nav slot the map was denied (ADR 0227 §11). What the
+// old page promised and the new one must keep is asserted here as behaviour:
+//   - the accessible path — every goal is a row in the ledger drawer, with
+//     both directions of each dependency by name (the old table's whole job);
+//   - ADR 0227 §1's refusal — tasks resolve only inside ONE well past the zoom
+//     threshold, never for every goal at once, and no control asks for them;
+//   - the nav slot, granted this time, directly under Goals.
+// And what the template adds: wells sized by credits with settled and
+// collapsed mass, alive as motion, routes charted by a shuttle that pulls the
+// camera back, the shuttle's five-line menu, explore on by default with
+// "where do you begin", "my ideas" off by default, the clock, band click.
+//
+// The REAL goal-map.html markup and the REAL seven sky-*.js files boot in a vm
+// through bootSkyPage (tests/helpers.mjs) — the same helper tests/hall_sky.mjs
+// uses for /thinking, pointed at this page's own file, so a button lost from
+// either door fails its own suite.
 //
 // Run:  node tests/goal_map_page.mjs
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import path from 'node:path';
-import vm from 'node:vm';
 import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
-import { makeRunner, makeEl, walk } from './helpers.mjs';
+import { makeRunner, settle, bootSkyPage } from './helpers.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const HALL = path.join(ROOT, 'modules/hall-ui/public');
 const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
-const KIT_JS = read('hall-kit.js');
-const LIB_JS = read('goal-map-lib.js');
-const FIT_JS = read('text-fit.js');
-const PAGE_JS = read('goal-map.js');
-const PAGE_HTML = read('goal-map.html');
-const PAGE_CSS = read('goal-map.css');
-const FIXTURE = JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts/hall-preview/fixtures/goals__graph.json'), 'utf8'));
 
 const { test, summary } = makeRunner();
-const tick = () => new Promise((r) => setTimeout(r, 0));
-const settle = async () => { for (let i = 0; i < 20; i++) await tick(); };
-
-const node = (id, extra = {}) => ({ goal_id: String(id), title: `Goal ${id}`, status: 'open', version_id: 'V1', category: null, task_total: 5, task_done: 2, depends_on: 0, depended_on_by: 0, ...extra });
-
-async function boot(payload, { status = 200, fail = false } = {}) {
-  const root = makeEl('div');
-  const reg = (id, hidden = false) => { const el = makeEl('div', { id }); if (hidden) el.hidden = true; root.appendChild(el); return el; };
-  ['gm-sub', 'gm-graph', 'gm-legend', 'gm-alone', 'gm-alone-lede', 'gm-table'].forEach((id) => reg(id));
-  ['gm-alone-scroll', 'gm-table-scroll'].forEach((id) => reg(id, true));
-
-  const documentObj = {
-    getElementById: (id) => walk(root, (el) => (el.id === id ? el : null)),
-    // SVG elements: the stub's own class/id only follow attrs at construction, so
-    // mirror what a browser does when setAttribute writes them.
-    createElementNS(_ns, tag) {
-      const el = makeEl(tag);
-      const orig = el.setAttribute.bind(el);
-      el.setAttribute = (k, v) => { orig(k, v); if (k === 'class') el.className = String(v); if (k === 'id') el.id = String(v); };
-      // A proportional fake of SVGTextElement's measurement: a W is twice a letter.
-      if (tag === 'text') el.getComputedTextLength = () => Array.from(el.textContent).reduce((w, c) => w + (c === 'W' ? 12 : 6), 0);
-      return el;
-    },
-  };
-  const requests = [];
-  const navigations = [];
-  const locationObj = { hostname: 'builders.example.test', assign: (u) => navigations.push(u) };
-  const windowObj = {
-    OTB: { escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])) },
-    localStorage: { getItem: () => null, setItem() {} },
-    location: locationObj,
-    addEventListener() {},
-  };
-  const sandbox = {
-    window: windowObj, self: windowObj, document: documentObj, location: locationObj, console: { error() {}, log() {}, warn() {} },
-    setTimeout, clearTimeout, Promise, Date, Math, JSON, Error, Number, String, Object, Array, Boolean, Set, Map, RegExp, encodeURIComponent,
-    fetch: async (url) => {
-      requests.push(url);
-      if (fail) throw new Error('offline');
-      return { ok: status === 200, status, json: async () => payload };
-    },
+const drain = async (n = 30) => { for (let i = 0; i < n; i += 1) await settle(); };
+// Explore is ON by default (the template's rule) and remembers what you
+// reached; a case about the drawn sky rather than about explore turns it off,
+// the way a reader who pressed "show me everything" has.
+const boot = async (opts = {}) => { const p = bootSkyPage({ page: 'goal-map', storage: { 'sky-explore': 'off' }, ...opts }); await drain(); return p; };
+const fire = (el) => el.fire('click', { type: 'click', preventDefault() {} });
+
+// ── the rows, in the routes' own shapes ─────────────────────────────────────
+
+// A well as GET /sky emits one. Defaults: an open goal in the present, three
+// tasks on two rings, one held now.
+function well(over = {}) {
+  return {
+    goal_id: '7', title: 'The well — a goal that holds work', subtitle: null, status: 'open', version_id: 'V2', category: null,
+    task_total: 3, task_done: 1, created_at: '2026-06-01T00:00:00.000Z',
+    criteria: [
+      { id: '70', criterion_id: 'c1', criterion_md: 'The first ring is met', satisfied: true, pending_review: false, task_ids: ['500'] },
+      { id: '71', criterion_id: 'c2', criterion_md: 'The second ring is open', satisfied: false, pending_review: false, task_ids: ['501', '502'] },
+    ],
+    tasks: [
+      { id: '500', title: 'The task', status: 'shipped', credits_reward: 60, created_on: '2026-07-01', idea_id: '10' },
+      { id: '501', title: 'A held task', status: 'active', credits_reward: 40, created_on: '2026-08-01', idea_id: null },
+      { id: '502', title: 'A claimable task', status: 'ready', credits_reward: 30, created_on: '2026-08-02', idea_id: null },
+    ],
+    ...over,
   };
-  sandbox.globalThis = sandbox;
-  vm.createContext(sandbox);
-  vm.runInContext(KIT_JS, sandbox, { filename: 'hall-kit.js' });
-  vm.runInContext(LIB_JS, sandbox, { filename: 'goal-map-lib.js' });
-  vm.runInContext(FIT_JS, sandbox, { filename: 'text-fit.js' });
-  vm.runInContext(PAGE_JS, sandbox, { filename: 'goal-map.js' });
-  await settle();
-  const $ = (id) => documentObj.getElementById(id);
-  // The stub matches one compound selector at a time, so `tbody tr` is two steps.
-  const rows = () => { const tb = $('gm-table').querySelector('tbody'); return tb ? tb.querySelectorAll('tr') : []; };
-  return { $, requests, navigations, rows, svg: () => $('gm-graph').querySelector('svg') };
 }
+const tasksOf = (prefix, n, status, created = '2026-05-01') => Array.from({ length: n }, (_, i) => ({ id: `${prefix}${i}`, title: `task ${prefix}${i}`, status, credits_reward: 20, created_on: created, idea_id: null }));
+// A quiet well: nothing held, nothing landed this week.
+const quiet = (over = {}) => well({ goal_id: '9', title: 'A quiet well — nothing moves', task_total: 4, task_done: 4, criteria: [], tasks: tasksOf('9-', 4, 'shipped'), ...over });
+const settled = (over = {}) => well({ goal_id: '8', title: 'A settled system — it finished', status: 'achieved', task_total: 3, task_done: 3, tasks: tasksOf('8-', 3, 'shipped'), created_at: '2026-03-01T00:00:00.000Z', ...over });
+const collapsed = (over = {}) => well({ goal_id: '6', title: 'A collapsed goal — archived', status: 'archived', task_total: 3, task_done: 1, criteria: [], tasks: tasksOf('6-', 3, 'abandoned'), created_at: '2026-03-01T00:00:00.000Z', ...over });
+const sky = (goals, edges = []) => ({ goals, edges, counts: { goals: goals.length, edges: edges.length, criteria: 0, tasks: 0 }, cache: { hit: false, ttl_seconds: 60, taken_at: '2026-09-25T00:00:00.000Z' } });
+const versions = () => ({ versions: [
+  { id: 'V2', status: 'building', shipped_at: null, started_at: '2026-08-01T00:00:00.000Z' },
+  { id: 'V1', status: 'shipped', shipped_at: '2026-05-12T00:00:00.000Z', started_at: '2026-05-01T00:00:00.000Z' },
+] });
+const star = () => ({
+  id: 10, title: 'It ignited', kind: 'feature', status: 'promoted', captured_at: '2026-09-01T00:00:00.000Z',
+  triage_note: null, promoted_to_task_id: null, promoted_task_title: null, promoted_task_status: null, merged_into_idea_id: null, merged_into_idea_title: null, grade: 'quick', field_values: null,
+  lineage_tasks: [{ task_id: 500, origin: 'promote', title: 'The task', status: 'shipped', goal_id: 7 }], descent_tasks: [],
+  size: { credits: 240, payments: 4, scale: 0.86, historical: false },
+  state: { state: 'star', position: 'well', wellGoalId: '7', awaitingNod: false, brightness: 1, hasWork: true, attributable: true },
+});
+const mine = (ideas) => ({ builder_id: 95, ideas, total: ideas.length, cap: 1000, truncated: false });
+// 7 waits on 9 (a route), 8 and 6 stand alone.
+const FOUR = () => sky([well(), quiet(), settled(), collapsed()], [{ from: '7', to: '9', count: 2 }]);
+const goal = (p, id) => p.S().goalById.get(String(id));
 
-// ---- the table is the page ---------------------------------------------------------
+// ═══ the lens is home ════════════════════════════════════════════════════════
 
-await test('the TABLE is on the page by default — every goal is a row, and nothing hides it behind a toggle', async () => {
-  const h = await boot(FIXTURE);
-  assert.equal(h.$('gm-table-scroll').hidden, false);
-  const rows = h.rows();
-  assert.equal(rows.length, FIXTURE.nodes.length, 'stand-alone goals are rows too');
-  assert.ok(h.$('gm-table').querySelector('table').getAttribute('aria-label'), 'the table is named for a screen reader');
+await test('it opens in "the whole project": the brand line, the switcher, the tools and the figures are the project sky\'s', async () => {
+  const p = await boot({ sky: FOUR(), versions: versions(), mine: mine([star()]) });
+  assert.ok(p.ready(), 'the page booted');
+  const S = p.S();
+  assert.equal(S.home, 'all', 'the body says which lens is home');
+  assert.equal(S.lens, 'all');
+  assert.equal(p.el('lensAll').getAttribute('aria-pressed'), 'true');
+  assert.equal(p.el('lensMine').getAttribute('aria-pressed'), 'false');
+  assert.equal(p.el('lensWord').textContent, '— the whole project');
+  assert.equal(p.el('lensWord').parentNode.textContent, 'the sky — the whole project', 'the h1 is the project sky\'s');
+  assert.equal(p.el('roomTitle').textContent, 'the ledger');
+  assert.equal(p.el('exploreBtn').hidden, false, 'explore is a tool here');
+  assert.equal(p.el('ideasBtn').hidden, false, 'so is "my ideas"');
+  assert.equal(p.el('claudeBtn').hidden, true, 'the ideator\'s pills are not');
+  assert.equal(p.el('influenceBtn').hidden, true);
+  assert.match(p.stats(), /<b>4<\/b> goals · <b>1<\/b> alive · <b>2<\/b> wells · <b>1<\/b> settled · <b>1<\/b> collapsed · <b>1<\/b> routes · <b>13<\/b> tasks/, 'the figures line is the goals\' line');
+  const urls = p.requests.map((r) => r.url);
+  for (const want of ['/api/bongos/sky', '/api/bongos/sky/mine', '/api/bongos/me', '/api/bongos/inbox/template']) assert.ok(urls.includes(want), `reads ${want}`);
+  assert.ok(!urls.some((u) => /goals\/graph/.test(u)), 'the goal map\'s aggregate read is gone — the sky\'s own reads carry the routes');
 });
 
-await test('the picture is the enhancement, and it is a role=img figure: no focus stops, no links inside the drawing', async () => {
-  const h = await boot(FIXTURE);
-  const svg = h.svg();
-  assert.ok(svg, 'the map is drawn');
-  assert.equal(svg.getAttribute('role'), 'img');
-  assert.equal(svg.getAttribute('aria-labelledby'), 'gm-cap');
-  assert.equal(svg.querySelectorAll('a').length, 0, 'thirty-six hidden interactive elements from a drawing is the wrong trade');
-  assert.equal(svg.querySelectorAll('[tabindex]').length, 0);
-  assert.match(h.$('gm-graph').querySelector('figcaption').textContent, /also in the table below/);
+await test('the same seven files open /thinking in "your thinking" — one page, two doors', async () => {
+  const p = bootSkyPage({ page: 'thinking', sky: FOUR(), versions: versions() }); await drain();
+  assert.equal(p.S().home, 'mine');
+  assert.equal(p.S().lens, 'mine');
+  assert.equal(p.el('lensWord').parentNode.textContent, 'your sky — your thinking');
 });
 
-await test('every goal in the map is a table row too, and every drawn dependency is named in the table', async () => {
-  const h = await boot(FIXTURE);
-  const drawn = h.svg().querySelectorAll('.gm-node').length;
-  assert.equal(drawn, FIXTURE.counts.connected);
-  const tableText = h.$('gm-table').textContent;
-  for (const e of FIXTURE.edges) {
-    const dependent = FIXTURE.nodes.find((n) => n.goal_id === e.from);
-    const dependency = FIXTURE.nodes.find((n) => n.goal_id === e.to);
-    assert.ok(tableText.includes(dependency.title || 'A private goal'), `the table names ${dependency.title}`);
-    assert.ok(tableText.includes(dependent.title || 'A private goal'));
-  }
+await test('the switcher is two doors: "simple" and "your thinking" leave for /thinking, and "the whole project" stays', async () => {
+  const a = await boot({ sky: FOUR() });
+  a.click('lensSimple');
+  assert.equal(a.navigated, '/thinking');
+  const b = await boot({ sky: FOUR() });
+  b.click('lensMine');
+  assert.equal(b.navigated, '/thinking');
+  const c = await boot({ sky: FOUR() });
+  c.click('lensAll');
+  assert.equal(c.navigated, null, 'already here');
+  assert.equal(c.S().lens, 'all');
 });
 
-// ---- category is text, not only colour ------------------------------------------------
+// ═══ the wells ═══════════════════════════════════════════════════════════════
 
-await test('CATEGORY IS A WORD on every drawn node, not only a colour — and "No category" is said too', async () => {
-  const h = await boot(FIXTURE);
-  const cats = h.svg().querySelectorAll('.gm-cat').map((t) => t.textContent);
-  assert.equal(cats.length, FIXTURE.counts.connected);
-  assert.ok(cats.every((c) => c.length > 0));
-  assert.ok(cats.includes('No category'), 'an uncategorised goal is legal and named as such (ADR 0192)');
-  assert.ok(cats.some((c) => /Modules|Security|Builders Hall|Economics/.test(c)));
-  assert.ok(h.$('gm-legend').textContent.includes('Modules'), 'and the legend spells each category out');
+await test('a goal is a well sized by its credits; settled and collapsed goals keep their mass at 0.8× and 0.5×', async () => {
+  const same = (over) => ({ ...over, task_total: 3, task_done: 3, criteria: [], tasks: tasksOf(over.goal_id + '-', 3, 'shipped') });
+  const p = await boot({ sky: sky([well(same({ goal_id: '1', title: 'open' })), well(same({ goal_id: '2', title: 'done', status: 'achieved' })), well(same({ goal_id: '3', title: 'gone', status: 'archived' }))]), versions: versions() });
+  const [o, a, c] = ['1', '2', '3'].map((id) => goal(p, id));
+  assert.equal(o.credits, 60, 'mass is the credits across the goal\'s tasks');
+  assert.equal(o.mass, 60);
+  assert.ok(Math.abs(a.r - o.r * 0.8) < 1e-9, 'a settled system is 0.8× the well it would have been');
+  assert.ok(Math.abs(c.r - o.r * 0.5) < 1e-9, 'a collapsed goal is half');
+  const big = await boot({ sky: sky([well(same({ goal_id: '1' })), well({ ...same({ goal_id: '4' }), tasks: tasksOf('4-', 3, 'shipped').map((t) => ({ ...t, credits_reward: 400 })) })]) });
+  assert.ok(goal(big, '4').r > goal(big, '1').r, 'more credits, a bigger well');
 });
 
-await test('node text is fitted to its card by MEASURED width, clipped as a backstop, and kept whole in the tooltip and table (task 1004204)', async () => {
-  const wide = 'W'.repeat(60);
-  const long = 'Agents module — framework, runtime, and the whole event router rewrite';
-  const h = await boot({
-    nodes: [node(1, { title: wide, depended_on_by: 1 }), node(2, { title: 'Fix', depends_on: 1, category: { slug: 'x', label: long } })],
-    edges: [{ from: '2', to: '1', count: 1 }],
-    counts: {},
-  });
-  const lib = createRequire(import.meta.url)(path.join(HALL, 'goal-map-lib.js'));
-  const inner = lib.layout(lib.analyse({ nodes: [node(1), node(2)], edges: [] })).nodeW - 32;
-  const texts = h.svg().querySelectorAll('.gm-node').flatMap((g) => g.querySelectorAll('text'));
-  assert.equal(texts.length, 6, 'name, category and task count on each of two nodes');
-  for (const t of texts) {
-    assert.ok(t.getComputedTextLength() <= inner, `"${t.textContent}" measures ${t.getComputedTextLength()}px, past the card's ${inner}px`);
-    assert.equal(t.getAttribute('clip-path'), 'url(#gm-text-clip)');
-  }
-  assert.ok(h.svg().querySelector('#gm-text-clip'), 'the clip the lines point at exists');
-  const names = h.svg().querySelectorAll('.gm-name').map((t) => t.textContent);
-  assert.ok(names.includes('Fix'), 'a title that fits is left whole');
-  assert.ok(names.some((n) => /^W+…$/.test(n)), 'a wide title is cut by width and says so');
-  assert.ok(h.svg().querySelectorAll('.gm-cat').some((t) => t.textContent.endsWith('…')), 'the category line is fitted too');
-  assert.ok(h.svg().querySelectorAll('title').some((x) => x.textContent.includes(wide)), 'the full title is still readable on hover');
-  assert.ok(h.$('gm-table').textContent.includes(wide), 'and in the table');
+await test('ALIVE IS MOTION, NOT STATUS: a builder holding a task now, or more than three landing this week', async () => {
+  const thisWeek = new Date(Date.now() - 2 * 86400000).toISOString().slice(0, 10);
+  const p = await boot({ sky: sky([
+    well(),
+    quiet(),
+    well({ goal_id: '11', title: 'Busy — four landed this week', criteria: [], tasks: tasksOf('11-', 4, 'shipped', thisWeek) }),
+    well({ goal_id: '12', title: 'Three landed — not yet alive', criteria: [], tasks: tasksOf('12-', 3, 'shipped', thisWeek) }),
+    settled({ tasks: [{ id: '8-0', title: 'held in a settled system', status: 'active', credits_reward: 20, created_on: thisWeek, idea_id: null }] }),
+  ]), versions: versions() });
+  assert.ok(goal(p, '7').live > 0, 'a held task lights the well');
+  assert.equal(goal(p, '9').live, 0, 'a quiet well stays white');
+  assert.ok(goal(p, '11').live > 0, 'four landings this week light it');
+  assert.equal(goal(p, '12').live, 0, 'three do not — the rule is MORE than three');
+  assert.equal(goal(p, '8').live, 0, 'a settled system is never alive, whatever its tasks say');
+  p.key('l');
+  const alive = p.el('filters').querySelectorAll('button').find((b) => b.dataset.f === 'alive');
+  assert.ok(alive, 'the ledger has an alive filter');
+  fire(alive);
+  assert.ok(p.rows().includes('data-id="7"') && p.rows().includes('data-id="11"'));
+  assert.ok(!p.rows().includes('data-id="9"') && !p.rows().includes('data-id="8"'));
 });
 
-// ---- the split is stated, the alone goals are a list ----------------------------------
+// ═══ the routes and the shuttle ══════════════════════════════════════════════
+
+await test('routes are the graph\'s edges; charting one pulls the camera back to hold both ends', async () => {
+  const p = await boot({ sky: FOUR(), versions: versions() });
+  const S = p.S(); const SKY = p.SKY();
+  assert.equal(S.edges.length, 1);
+  const e = S.edges[0];
+  assert.equal(e.a, goal(p, '7')); assert.equal(e.b, goal(p, '9')); assert.equal(e.count, 2);
+  assert.equal(S.charted.size, 0, 'a whisper until asked');
+  // Zoomed into the waiting goal, the far end is off screen.
+  S.cam.x = e.a.x; S.cam.y = e.a.y; S.cam.k = 5; S.flight = null;
+  SKY.chartRoute(e, e.a);
+  assert.ok(S.charted.has(e.id), 'the route is charted');
+  assert.equal(S.charted.get(e.id).done, true, 'under reduced motion the shuttle arrives at once');
+  assert.ok(S.cam.k < 5, 'the camera pulled back');
+  assert.doesNotThrow(() => p.frame(), 'and the charted route draws');
+});
 
-await test('the stand-alone goals are a LIST, never dots, and the split is stated in the page head', async () => {
-  const h = await boot(FIXTURE);
-  const drawnIds = new Set(h.svg().querySelectorAll('.gm-node').map((g) => g.attrs.transform));
-  assert.equal(drawnIds.size, FIXTURE.counts.connected);
-  assert.equal(h.$('gm-alone-scroll').hidden, false);
-  assert.equal(h.$('gm-alone').querySelectorAll('li').length, FIXTURE.counts.isolated);
-  assert.match(h.$('gm-sub').textContent, new RegExp(`the other ${FIXTURE.counts.isolated} stand alone`));
+await test('the shuttle\'s menu offers the five lines, and each does what it says', async () => {
+  const p = await boot({ sky: sky([well(), quiet(), settled(), collapsed()], [{ from: '7', to: '9', count: 2 }, { from: '9', to: '8', count: 1 }]), versions: versions() });
+  const S = p.S(); const SKY = p.SKY();
+  SKY.showMenu(S.edges[0], 10, 10);
+  const menu = p.el('menu');
+  assert.equal(menu.hidden, false);
+  const acts = menu.querySelectorAll('button').map((b) => [b.dataset.act, b.textContent]);
+  assert.deepEqual(acts.map((a) => a[0]), ['goal', 'all', 'latest', 'hide', 'clear']);
+  assert.match(acts[0][1], /^chart every route from /);
+  assert.equal(acts[1][1], 'map every route in the sky');
+  assert.equal(acts[2][1], 'trace only the latest');
+  assert.equal(acts[3][1], 'hide unrelated systems');
+  assert.equal(acts[4][1], 'land every shuttle');
+  const act = (k) => { SKY.showMenu(S.edges[0], 10, 10); fire(menu.querySelectorAll('button').find((b) => b.dataset.act === k)); };
+  act('all');
+  assert.equal(S.charted.size, 2, 'every route in the sky');
+  assert.equal(menu.hidden, true, 'the menu closes on a choice');
+  act('hide');
+  assert.ok(S.focusSet && S.focusSet.has('7') && S.focusSet.has('9') && S.focusSet.has('8') && !S.focusSet.has('6'), 'the unrelated system is faded');
+  assert.ok(SKY.goalAlpha(goal(p, '6'), Date.now()) <= 0.1);
+  act('hide');
+  assert.equal(S.focusSet, null, 'and shown again');
+  act('clear');
+  assert.equal(S.charted.size, 0, 'every shuttle landed');
+  act('goal');
+  assert.equal(S.charted.size, 1, 'every route from this goal — 7 has one');
+  SKY.clearCharts();
+  act('latest');
+  assert.equal(S.charted.size, 1, 'only the latest: both ends in the present band');
 });
 
-// ---- no view A, no view D -------------------------------------------------------------------
+// ═══ explore ═════════════════════════════════════════════════════════════════
 
-await test('NEITHER VIEW A NOR VIEW D is reachable: one aggregate fetch, and no control on the page that changes what is drawn', async () => {
-  const h = await boot(FIXTURE);
-  assert.deepEqual(h.requests, ['/api/bongos/goals/graph'], 'the only read is the aggregate — it carries no task identity');
-  const controls = /<(?:button|select|input|textarea)\b/i;
-  assert.equal(controls.test(PAGE_HTML), false, 'the page markup has no control at all');
-  assert.equal(h.$('gm-graph').querySelectorAll('button, select, input').length, 0);
-  assert.equal(/include=|\/tasks|task_id|densif/i.test(PAGE_JS.replace(/^\s*\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '')), false,
-    'no path in the page script can ask for a task');
+await test('EXPLORE IS ON BY DEFAULT: the sky asks where you begin, and the ledger knows only what you have reached', async () => {
+  const p = await boot({ sky: FOUR(), versions: versions(), storage: {} });
+  const S = p.S(); const SKY = p.SKY();
+  assert.equal(S.explore.on, true);
+  assert.equal(p.el('exploreBtn').getAttribute('aria-pressed'), 'true');
+  assert.equal(p.el('start').hidden, false, '"where do you begin" is up');
+  const opts = p.el('startOpts').querySelectorAll('button');
+  assert.equal(opts[0].textContent, 'where my thoughts are');
+  assert.deepEqual(opts.slice(1, -1).map((b) => b.dataset.start), ['7', '9'], 'one door per open well, biggest first');
+  assert.equal(opts.at(-1).textContent, 'show me everything');
+  assert.equal(SKY.seen(goal(p, '7')), false, 'nothing is reached yet');
+  p.key('l');
+  assert.match(p.rows(), /Nothing explored yet\. Pick a starting point in the sky\./);
+  fire(opts.find((b) => b.dataset.start === '7'));
+  assert.equal(p.el('start').hidden, true);
+  assert.equal(SKY.seen(goal(p, '7')), true, 'the well you began in is revealed');
+  assert.equal(SKY.seen(goal(p, '9')), false, 'the one at the far end of its route is not');
+  assert.ok(p.rows().includes('data-id="7"') && !p.rows().includes('data-id="9"'), 'the ledger lists what you reached');
+  assert.equal(p.el('roomCount').textContent, '1 of 1 · 3 unexplored');
+  SKY.chartRoute(S.edges[0], goal(p, '7'));
+  assert.equal(SKY.seen(goal(p, '9')), true, 'charting the route brings the goal at its far end into view');
+  assert.ok(p.rows().includes('data-id="9"'));
+  assert.match(p.stats(), /explored 2 of 4/);
 });
 
-// ---- scrolling ----------------------------------------------------------------------------
-
-await test('the picture scrolls INSIDE its own region and names both overflow axes (the page never scrolls sideways)', async () => {
-  const h = await boot(FIXTURE);
-  const region = h.$('gm-graph').querySelector('.gm-scroll');
-  assert.ok(region && region.contains(h.svg()));
-  assert.equal(region.getAttribute('tabindex'), '0', 'a keyboard reader can scroll it');
-  assert.equal(region.getAttribute('role'), 'region');
-  const rule = PAGE_CSS.match(/\.gm-scroll\s*\{[^}]*\}/)[0];
-  assert.match(rule, /overflow-x:\s*auto/);
-  assert.match(rule, /overflow-y:\s*hidden/, 'one axis named alone makes the other auto (task 1004130)');
-  assert.match(rule, /max-width:\s*100%/);
+await test('"show me everything" turns explore off, and every goal is then a row', async () => {
+  const p = await boot({ sky: FOUR(), versions: versions(), storage: {} });
+  fire(p.el('startOpts').querySelectorAll('button').find((b) => b.dataset.start === 'all'));
+  assert.equal(p.S().explore.on, false);
+  assert.equal(p.el('exploreBtn').getAttribute('aria-pressed'), 'false');
+  p.key('l');
+  for (const id of ['7', '9', '8', '6']) assert.ok(p.rows().includes(`data-id="${id}"`), `goal ${id} is a row`);
+  assert.equal(p.el('roomCount').textContent, '4 of 4');
 });
 
-// ---- text is never markup -------------------------------------------------------------------
-
-await test('a goal title is builder-authored text: it never becomes markup, in the picture or the table or the chips', async () => {
-  const evil = '<img src=x onerror=alert(1)>';
-  const h = await boot({
-    nodes: [node(1, { title: evil, depends_on: 1 }), node(2, { depended_on_by: 1 }), node(3, { title: evil })],
-    edges: [{ from: '1', to: '2', count: 1 }],
-    counts: {},
-  });
-  assert.equal(h.svg().querySelectorAll('img').length, 0);
-  assert.ok(h.svg().querySelectorAll('.gm-name').some((t) => t.textContent.includes('<img')), 'as literal text in the drawing');
-  assert.equal(h.$('gm-table').querySelectorAll('img').length, 0);
-  assert.equal(h.$('gm-alone').querySelectorAll('img').length, 0);
-  assert.ok(h.$('gm-table').textContent.includes(evil), 'shown as the characters the author typed');
+// ═══ "my ideas" ══════════════════════════════════════════════════════════════
+
+await test('"my ideas" is OFF by default: no thought is drawn over the project until the pill is pressed', async () => {
+  const p = await boot({ sky: FOUR(), versions: versions(), mine: mine([star()]) });
+  const S = p.S(); const SKY = p.SKY();
+  const i = S.ideas.find((x) => x.id === '10');
+  assert.ok(i, 'the thought was read');
+  assert.equal(S.ideasOnMap, false);
+  assert.equal(p.el('ideasBtn').getAttribute('aria-pressed'), 'false');
+  assert.equal(SKY.shown(i), false, 'not drawn');
+  assert.equal(p.el('rehearse').hidden, true, 'and "what if" waits behind it');
+  p.click('ideasBtn');
+  assert.equal(SKY.shown(i), true, 'laid over the map');
+  assert.equal(p.el('rehearse').hidden, false);
 });
 
-// ---- honest states ----------------------------------------------------------------------------
+// ═══ the ledger drawer — the accessible path ═════════════════════════════════
 
-await test('a private goal the viewer cannot read is named as one and is not a link', async () => {
-  const h = await boot({ nodes: [node(1, { title: null, depended_on_by: 1 }), node(2, { depends_on: 1 })], edges: [{ from: '2', to: '1', count: 2 }], counts: {} });
-  const row = h.rows().find((r) => r.textContent.includes('A private goal'));
-  assert.ok(row, 'the row exists');
-  assert.equal(row.querySelectorAll('a').length, 0, 'nothing to open');
+await test('THE LEDGER IS THE ACCESSIBLE PATH: every goal is a row, both directions of each dependency are counted on it and named in the panel, and the five filters are there', async () => {
+  const p = await boot({ sky: FOUR(), versions: versions() });
+  p.key('l');
+  assert.equal(p.el('room').hidden, false);
+  assert.equal(p.el('roomTitle').textContent, 'the ledger');
+  const rows = p.rows(); const S = p.S(); const SKY = p.SKY();
+  for (const g of S.goals) {
+    assert.ok(rows.includes(`data-id="${g.id}"`), `${g.title} has a row`);
+    assert.ok(rows.includes(SKY.esc(g.title)), `${g.title} is named whole`);
+  }
+  const rowOf = (id) => (new RegExp(`data-id="${id}"[\\s\\S]*?</button>`).exec(rows) || [''])[0];
+  assert.match(rowOf('7'), /alive · 1\/3 tasks · 130 cr · 1\/2 rings · waits on 1/, 'the waiting goal (alive: a task is held) counts what it waits on');
+  assert.match(rowOf('9'), /waited on by 1/, 'the goal waited on counts it the other way');
+  assert.match(rowOf('8'), /settled/); assert.match(rowOf('6'), /collapsed/);
+  const filters = p.el('filters').querySelectorAll('button').map((b) => [b.dataset.f, b.textContent.replace(/\s*\d+$/, '').trim()]);
+  assert.deepEqual(filters, [['all', 'every goal'], ['alive', 'alive'], ['open', 'wells'], ['achieved', 'settled'], ['archived', 'collapsed'], ['routes', 'with routes']]);
+  fire(p.el('filters').querySelectorAll('button').find((b) => b.dataset.f === 'routes'));
+  assert.ok(p.rows().includes('data-id="7"') && p.rows().includes('data-id="9"') && !p.rows().includes('data-id="8"'), '"with routes" keeps the two ends of the route');
+  // The panel names both directions, by name, as doors.
+  SKY.pick({ kind: 'goal', ref: goal(p, '7') }, false);
+  assert.match(p.panel(), /waits on<\/span><span class="v"><a href="#" data-goal="9">A quiet well<\/a>/);
+  SKY.pick({ kind: 'goal', ref: goal(p, '9') }, false);
+  assert.match(p.panel(), /waited on by<\/span><span class="v"><a href="#" data-goal="7">The well<\/a>/);
+  assert.match(p.panel(), /href="\/goals#\/goal\/9"/, 'and the goal itself is a door');
 });
 
-await test('no dependency at all says so plainly, draws no picture, and the table is still the whole map', async () => {
-  const h = await boot({ nodes: [node(1), node(2)], edges: [], counts: {} });
-  assert.equal(h.svg(), null);
-  assert.match(h.$('gm-graph').textContent, /no graph to draw — the table below is the whole map/);
-  assert.equal(h.rows().length, 2);
-  assert.equal(h.$('gm-alone-scroll').hidden, true, 'nothing to split when nothing is connected');
+// ═══ ADR 0227 §1 stands ══════════════════════════════════════════════════════
+
+await test('TASKS RESOLVE ONLY INSIDE ONE WELL PAST THE ZOOM THRESHOLD — never for every goal at once — and no control asks for them', async () => {
+  const p = await boot({ sky: FOUR(), versions: versions() });
+  const S = p.S(); const SKY = p.SKY();
+  const bodies = () => [...S.taskById.values()].filter((t) => t._sx != null);
+  p.frame();
+  assert.equal(bodies().length, 0, 'at the whole-sky fit no task is a body — dust on the rings at most');
+  SKY.fitGoal(goal(p, '7'));
+  p.frame();
+  const drawn = bodies();
+  assert.ok(drawn.length > 0, 'descended into one well, its tasks resolve onto their rings');
+  assert.ok(drawn.every((t) => t.goal.id === '7'), 'and only that well\'s');
+  const html = read('goal-map.html');
+  assert.equal(/<button[^>]*>[^<]*(every task|all tasks|show tasks|densif)/i.test(html), false, 'no control offers every task');
+  assert.equal(/<button[^>]*>[^<]*task/i.test(html), false, 'no button on the page speaks of tasks at all');
+  assert.deepEqual([...read('sky-interaction.js').matchAll(/data-act="(\w+)"/g)].map((m) => m[1]), ['goal', 'all', 'latest', 'hide', 'clear'], 'the shuttle menu is the five lines, none of them about tasks');
 });
 
-await test('an empty corpus renders the empty state and no table', async () => {
-  const h = await boot({ nodes: [], edges: [], counts: {} });
-  assert.match(h.$('gm-graph').textContent, /No goal carries any work yet/);
-  assert.equal(h.$('gm-table-scroll').hidden, true);
+// ═══ the clock and the bands ═════════════════════════════════════════════════
+
+await test('the clock draws the sky as it stood on a day: a goal born after it is not there, and the figures say as of', async () => {
+  const p = await boot({ sky: sky([well(), well({ goal_id: '13', title: 'Born in September', created_at: '2026-09-01T00:00:00.000Z', criteria: [], tasks: tasksOf('13-', 2, 'ready', '2026-09-02') })]), versions: versions() });
+  const SKY = p.SKY();
+  assert.match(p.stats(), /<b>2<\/b> goals/);
+  SKY.setClock(new Date('2026-08-01T12:00:00.000Z').getTime());
+  assert.equal(SKY.present(goal(p, '7')), true);
+  assert.equal(SKY.present(goal(p, '13')), false);
+  assert.match(p.stats(), /<b>1<\/b> goals/);
+  assert.match(p.stats(), /as of 01 aug 2026/);
+  assert.match(p.el('when').textContent, /01 aug 2026/);
 });
 
-await test('a failed read is one honest line — not a blank page, not a stack', async () => {
-  const h = await boot(null, { fail: true });
-  assert.match(h.$('gm-sub').textContent, /Couldn.t load the goal map/);
-  assert.equal(h.svg(), null);
-  assert.equal(h.$('gm-table-scroll').hidden, true);
+await test('a band is a version, and clicking one fills the screen with it', async () => {
+  const p = await boot({ sky: FOUR(), versions: versions() });
+  const S = p.S(); const SKY = p.SKY();
+  assert.equal(S.BANDS.length, 2);
+  assert.deepEqual(JSON.parse(JSON.stringify(S.BANDS[0].versions)), ['V2']);
+  const b = S.BANDS[1];
+  S.cam.x = 999; S.cam.k = 3;
+  SKY.fitBand(b);
+  assert.equal(S.cam.x, 0); assert.equal(S.cam.y, 0);
+  assert.equal(S.cam.k, SKY.fitRad(b.r1 + 80));
 });
 
-await test('signed out (401) goes to sign-in like every other hall read', async () => {
-  const h = await boot(null, { status: 401 });
-  assert.deepEqual(h.navigations, ['/api/bongos/auth/web/start']);
+// ═══ the tour ════════════════════════════════════════════════════════════════
+
+await test('the tour walks all three lenses here too, and hands the sky back to the whole project', async () => {
+  const p = await boot({ sky: FOUR(), versions: versions() });
+  p.key('?');
+  assert.equal(p.el('tour').hidden, false);
+  assert.equal(p.S().lens, 'mine', 'step one is "This is your sky"');
+  for (let n = 0; n < 6; n++) p.click('tourNext');
+  assert.equal(p.S().lens, 'all', 'step seven is the alive well, on the project map');
+  p.key('Escape');
+  assert.equal(p.el('tour').hidden, true);
+  assert.equal(p.S().lens, 'all', 'back to the whole project, not to your thinking');
+  assert.equal(p.el('lensAll').getAttribute('aria-pressed'), 'true');
+  const first = await boot({ sky: FOUR(), tourSeen: false });
+  assert.equal(first.timers.pending(), 1, 'a first visit schedules the tour here as well');
 });
 
-// ---- the shell ---------------------------------------------------------------------------------
+// ═══ the words are never markup ══════════════════════════════════════════════
 
-await test('the page has its h1 in static markup (so every state has one) and loads the lib before the page script', () => {
-  assert.match(PAGE_HTML, /<h1 class="page-head__h">Goal map<\/h1>/);
-  assert.ok(PAGE_HTML.indexOf('goal-map-lib.js') > -1 && PAGE_HTML.indexOf('goal-map-lib.js') < PAGE_HTML.indexOf('goal-map.js'));
-  assert.ok(PAGE_HTML.indexOf('hall-kit.js') < PAGE_HTML.indexOf('goal-map.js'));
-  assert.ok(PAGE_HTML.indexOf('text-fit.js') > -1 && PAGE_HTML.indexOf('text-fit.js') < PAGE_HTML.indexOf('goal-map.js'));
+await test('a goal title never becomes markup — in the ledger, the panel or the hover card', async () => {
+  const evil = '<img src=x onerror=alert(1)> & "quotes"';
+  const p = await boot({ sky: sky([well({ title: evil }), quiet()], [{ from: '7', to: '9', count: 1 }]), versions: versions() });
+  const SKY = p.SKY(); const g = goal(p, '7');
+  p.key('l');
+  SKY.pick({ kind: 'goal', ref: g }, false);
+  SKY.showCard({ kind: 'goal', ref: g }, 10, 10);
+  for (const [where, html] of [['rows', p.rows()], ['panel', p.panel()], ['card', p.card()]]) {
+    assert.ok(html.includes('&lt;img src=x onerror=alert(1)&gt; &amp; &quot;quotes&quot;'), `${where} escapes the title`);
+    assert.ok(!html.includes('<img'), `${where} carries no element from the title`);
+  }
+  SKY.pick({ kind: 'goal', ref: goal(p, '9') }, false);
+  assert.ok(p.panel().includes('data-goal="7">&lt;img src=x') && !p.panel().includes('<img'), 'the named dependency is escaped too');
 });
 
-await test('it takes NO nav slot (the sky’s rule) — the Goals page is its door', () => {
+// ═══ the page and the nav ════════════════════════════════════════════════════
+
+await test('Sky sits directly under Goals in the nav, member-gated, at the URL Goals links to', () => {
   const shell = read('shell.js');
-  assert.equal(/goal-map/.test(shell), false, 'no nav item');
-  assert.match(read('goals.html'), /href="\/builders\/goal-map"/);
+  const item = shell.indexOf("{ id: 'goal-map', label: 'Sky', icon: 'goals', href: '/goal-map', gate: 'member' }");
+  assert.ok(item > -1, 'the nav item, with the slot the map was denied (ADR 0227 §11)');
+  const goals = shell.indexOf("{ id: 'goals', label: 'Goals'"); const work = shell.indexOf("{ id: 'work', label: 'Tasks'");
+  assert.ok(goals > -1 && goals < item && item < work, 'under Goals, above Tasks');
+  assert.match(read('goals.html'), /href="\/builders\/goal-map"/, 'Goals still links to it');
+});
+
+await test('the page is the sky\'s own surface — the same sheet and the same seven scripts as /thinking, one cache-bust between them, and the old goal map is gone', () => {
+  const html = read('goal-map.html'); const thinking = read('thinking.html');
+  assert.match(html, /<body data-page="goal-map" data-page-title="The sky" data-sky-lens="all">/);
+  assert.match(html, /<title>The sky — \{\{worldName\}\}<\/title>/);
+  assert.match(html, /<h1>the sky <em id="lensWord">— the whole project<\/em><\/h1>/, 'the h1 is in static markup, so every state has one');
+  assert.equal(/shell\.js|style\.css/.test(html), false, 'no hall chrome, like /thinking');
+  const scripts = (h) => [...h.matchAll(/<script src="\/builders\/([^"?]+)\?v=([^"]+)"/g)].map((m) => [m[1], m[2]]);
+  assert.deepEqual(scripts(html).map((s) => s[0]), ['idea-objects.js', 'sky-data.js', 'sky-layout.js', 'sky-draw.js', 'sky-interaction.js', 'sky-panel.js', 'sky-composer.js', 'sky-tour.js']);
+  assert.deepEqual(scripts(html), scripts(thinking), 'the two doors load the same files at the same stamp');
+  assert.equal(html.match(/thinking\.css\?v=([^"]+)/)[1], thinking.match(/thinking\.css\?v=([^"]+)/)[1]);
+  assert.match(read('thinking.css'), /body\[data-page="thinking"\], body\[data-page="goal-map"\] \{/, 'the sheet names both bodies');
+  for (const f of ['goal-map.css', 'goal-map.js', 'goal-map-lib.js']) assert.equal(fs.existsSync(path.join(HALL, f)), false, `${f} is retired`);
+  assert.equal(fs.existsSync(path.join(ROOT, 'tests/goal_map_lib.mjs')), false, 'and so is the lib\'s test');
+  assert.equal(/goal-map-lib|goal-map\.js|goal-map\.css/.test(html), false);
 });
 
+console.log('');
 summary();