@bongos/core 1.19.1012 → 1.19.1014

package/tests/hall_sky.mjs

@@ -1,77 +1,53 @@
-// tests/hall_sky.mjs — THE SKY, at the rendered layer
-// (task 1004105 / BV2.R26 of goal 1000095, criterion `ideator-sky-tells-the-truth`).
+// tests/hall_sky.mjs — THE SKY, at the rendered layer (task 1004231 / sky part
+// 3 of 5, goal 1000095; ADR 0331, ADR 0227 §11; criterion
+// `ideator-sky-tells-the-truth`).
 //
-// This suite boots the REAL modules/hall-ui/public/sky.js and the REAL
-// modules/hall-ui/public/idea-objects.js in a vm and reads the HTML they write.
-// Nothing here asserts against a projection built by hand: every row goes in
-// shaped the way `GET /inbox/by-builder/:id` shapes one, so a test cannot stay
-// green over a page that reads a field the route does not send.
+// This suite boots the REAL page — thinking.html's markup, the REAL
+// idea-objects.js and the REAL seven sky-*.js files — in a vm through
+// bootSkyPage and reads what it wrote. Every trail row goes in shaped the way
+// GET /sky/mine emits one and every well the way GET /sky emits one, so a case
+// cannot stay green over a page that reads a field the routes do not send.
 //
-// WHAT IT IS ACTUALLY GUARDING, and why it is not tests/hall_thinking_room.mjs
-// again. Everything the sky draws is already correct and already tested: the
-// five states (tests/idea_state.mjs), size (tests/idea_size.mjs), brightness
-// (tests/idea_brightness.mjs), the descent (tests/idea_descent_surface.mjs),
-// and the room proves the WORDS. What is new here is that the answers become
-// GEOMETRY, and a drawing has its own ways of lying that nothing upstream can
-// see:
-//
-//   - a diameter computed from a second curve, so one thought is two sizes on
-//     two pages;
-//   - a remnant drawn small, which destroys the entire two-channel model — the
-//     criterion's own proof (BV2.R27) is "large and dead", and if the glyph
-//     shrinks with brightness there is nothing left to prove;
-//   - an unreadable brightness drawn as a dim star, which states that work was
-//     removed when the only thing that happened is that nobody could look;
-//   - a picture with no words, which is a page a screen reader cannot use;
-//   - a well drawn around a goal that never caught the thought, or rings
-//     claiming a goal has no criteria when the truth is nobody asked.
-//
-// It also holds the one structural promise of spec decision 11: the sky is
-// never the only path to anything it shows.
+// WHAT IT GUARDS. The page is the pixel contract of the prototype the owner
+// adopted (docs/design/mocks/sky/), built over the two part-2 reads. What can
+// go wrong is the wiring, not the drawing: a thought drawn in a well the ledger
+// never put it in, a diameter computed from a curve of its own, a remnant
+// shrunk for being dead, an unreadable brightness drawn as a dim star, a
+// heuristic layer (the claude layer, born-of marks) shipped as if it were a
+// ledger fact, a title that became markup, a band that names this instance's
+// versions by hand, and — the structural promise of spec decision 11 — a drawn
+// thought with no row in the drawer. The composer's side is
+// tests/hall_thinking_room.mjs.
 
 import assert from 'node:assert/strict';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { makeRunner, settle, bootSkyPage } from './helpers.mjs';
 
-const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const readFile = (rel) => fs.readFile(path.join(ROOT, rel), 'utf8');
-
 const { test, summary } = makeRunner();
+// Values born inside the vm carry that realm's prototypes, so a strict deepEqual
+// reports "same structure but not reference-equal"; compare them as plain data.
+const same = (actual, expected, msg) => assert.deepEqual(JSON.parse(JSON.stringify(actual)), expected, msg);
 
-// The /me read, then a trail page, then the background loop, then /goals and a
-// goal detail each — several awaits deep, so one microtask turn is far short.
-const drain = async (n = 20) => { for (let i = 0; i < n; i += 1) await settle(); };
+// Five reads in parallel, then the world is built, then the boot line runs —
+// several awaits deep, so one microtask turn is far short.
+const drain = async (n = 30) => { for (let i = 0; i < n; i += 1) await settle(); };
+const boot = async (opts = {}) => { const p = bootSkyPage(opts); await drain(); return p; };
 
-// A trail row in the shape the route emits. Defaults are the dullest possible
-// thought — filed, nothing came of it, floating — so every case below states
-// only the facts it is actually about.
+// ── the rows, in the routes' own shapes ─────────────────────────────────────
+
+// A trail row as GET /sky/mine emits one (the trail's own projection, plus the
+// three attachers). Defaults are the dullest possible thought — filed, nothing
+// came of it, floating — so every case states only the facts it is about.
 function idea(over = {}) {
   return {
-    id: 1,
-    title: 'A thought',
-    kind: 'feature',
-    status: 'open',
-    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,
-    lineage_tasks: [],
-    descent_tasks: [],
+    id: 1, title: 'A thought', kind: 'feature', status: 'open', 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: [], descent_tasks: [],
     size: { credits: 0, payments: 0, scale: 0, historical: false },
-    state: {
-      state: 'protostar', position: 'open-space', wellGoalId: null,
-      awaitingNod: false, brightness: null, hasWork: false, attributable: true,
-    },
+    state: { state: 'protostar', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: null, hasWork: false, attributable: true },
     ...over,
   };
 }
-const page = (ideas, over = {}) => ({ ideas, total: ideas.length, offset: 0, limit: 100, ...over });
-
 const star = (over = {}) => idea({
   id: 10, title: 'It ignited', status: 'promoted',
   lineage_tasks: [{ task_id: 500, origin: 'promote', title: 'The task', status: 'shipped', goal_id: 7 }],
@@ -85,374 +61,386 @@ const remnant = (over = {}) => star({
   state: { state: 'remnant', position: 'well', wellGoalId: '7', awaitingNod: false, brightness: 0, hasWork: true, attributable: true },
   ...over,
 });
+const satellite = (over = {}) => idea({
+  id: 13, title: 'Folded', status: 'merged', merged_into_idea_id: 10, merged_into_idea_title: 'It ignited',
+  state: { state: 'satellite', position: 'well', wellGoalId: '7', awaitingNod: false, brightness: 1, hasWork: true, attributable: true },
+  ...over,
+});
 const coldBody = (over = {}) => idea({
   id: 12, title: 'It never ignited', status: 'discarded',
-  size: { credits: 0, payments: 0, scale: 0, historical: false },
   state: { state: 'cold-body', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: null, hasWork: false, attributable: true },
   ...over,
 });
+const waiting = (over = {}) => idea({
+  id: 14, title: 'Caught, waiting for a nod', status: 'promoted',
+  lineage_tasks: [{ task_id: 9001, origin: 'route', title: 'Caught, waiting for a nod', status: 'backlog', goal_id: 7 }],
+  state: { state: 'protostar', position: 'well', wellGoalId: '7', awaitingNod: true, brightness: 1, hasWork: false, attributable: true },
+  ...over,
+});
+const FIVE = () => [star(), idea(), satellite(), remnant(), coldBody()];
+const mine = (ideas, over = {}) => ({ builder_id: 95, ideas, total: ideas.length, cap: 1000, truncated: false, ...over });
 
-// The diameter a glyph was drawn at, and the object it says it is, pulled off
-// the markup by the idea's own button so a case never has to guess which glyph
-// belongs to which thought.
-function glyphOf(html, ideaId) {
-  const re = new RegExp(`data-idea="${ideaId}"[\\s\\S]*?<span class="sky-glyph"([^>]*)>`);
-  const m = re.exec(html);
-  if (!m) return null;
-  const attrs = m[1];
+// A well as GET /sky emits one: the graph's node plus its criteria and its
+// compact tasks.
+function well(over = {}) {
   return {
-    object: (/data-object="([^"]+)"/.exec(attrs) || [])[1] || null,
-    d: Number((/--d:(\d+)px/.exec(attrs) || [])[1]),
-    lit: Number((/--lit:([\d.]+)/.exec(attrs) || [])[1]),
-    unknownSize: /data-size="unknown"/.test(attrs),
+    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,
   };
 }
-const labelOf = (html, ideaId) => (new RegExp(`data-idea="${ideaId}"[\\s\\S]*?aria-label="([^"]*)"`).exec(html) || [])[1] || '';
+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 glyphWidth = (rows, id) => Number((new RegExp(`data-id="${id}"[\\s\\S]*?<span class="mk [^"]*" style="width:(\\d+)px`).exec(rows) || [])[1]);
+const glyphClass = (rows, id) => (new RegExp(`data-id="${id}"[\\s\\S]*?<span class="mk ([^"]*)"`).exec(rows) || [])[1] || '';
+const findIdea = (p, id) => p.S().ideas.find((i) => i.id === String(id));
+
+// ═══ the reads ═══════════════════════════════════════════════════════════════
+
+await test('it reads the whole sky in five requests, and never the old trail read', async () => {
+  const p = await boot({ mine: mine(FIVE()), sky: sky([well()]), versions: versions() });
+  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) => u.startsWith('/api/bongos/versions')), 'reads the versions for the bands');
+  assert.ok(!urls.some((u) => /by-builder|\/goals\/\d+$|\/goals$/.test(u)), 'the room\'s paged trail read and the per-goal reads are gone — one read each (ADR 0331)');
+  assert.equal(urls.filter((u) => u.endsWith('/sky/mine')).length, 1, 'the trail is one request, whole — the route pages it server-side');
+  assert.ok(p.ready(), 'the page booted');
+});
 
-// ═══ the five objects, in the shared vocabulary ═════════════════════════════
+await test('the trail is the VIEWER\'s — /sky/mine carries no id, and nothing in the URL could name another builder', async () => {
+  const p = await boot({ mine: mine(FIVE()) });
+  assert.ok(p.requests.some((r) => r.url === '/api/bongos/sky/mine'), 'the exact path, no id');
+});
+
+// ═══ the five objects ════════════════════════════════════════════════════════
 
 await test('every one of the five draws its own object, and the word comes from the shared table', async () => {
-  const all = [
-    star(),
-    remnant(),
-    coldBody(),
-    idea({ id: 13, title: 'Folded', status: 'merged', merged_into_idea_id: 999, merged_into_idea_title: 'The host',
-      state: { state: 'satellite', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: 1, hasWork: true, attributable: true } }),
-    idea({ id: 14, title: 'Waiting' }),
-  ];
-  const p = bootSkyPage({ pages: [page(all)] });
-  await drain();
-  const html = p.field();
-  const seen = [10, 11, 12, 13, 14].map((id) => glyphOf(html, id).object);
-  assert.deepEqual(seen, ['star', 'remnant', 'cold-body', 'satellite', 'protostar']);
-  // The words are the shared table's, never this page's.
-  const objects = p.objects();
-  for (const id of objects.ORDER) assert.ok(p.legend().includes(objects.objectFor(id).label), `the legend says "${objects.objectFor(id).label}"`);
-});
-
-await test('the legend is built from ORDER, so the page cannot grow a sixth object or lose one', async () => {
-  const p = bootSkyPage({ pages: [page([star()])] });
-  await drain();
-  const marks = [...p.legend().matchAll(/class="sky-glyph" data-object="([^"]+)"/g)].map((m) => m[1]);
-  assert.deepEqual(marks, [...p.objects().ORDER]);
-});
-
-// ═══ size is geometry, and the curve is the server's ════════════════════════
-
-await test('the diameter tracks the server scale, and nothing on this page re-compresses it', async () => {
-  const small = star({ id: 20, size: { credits: 12, payments: 1, scale: 0.1, historical: false } });
-  const big = star({ id: 21, size: { credits: 2400, payments: 40, scale: 1, historical: false } });
-  const p = bootSkyPage({ pages: [page([small, big])] });
-  await drain();
-  const a = glyphOf(p.field(), 20);
-  const b = glyphOf(p.field(), 21);
-  assert.ok(b.d > a.d, 'a bigger scale draws a bigger body');
-  // The mapping is AFFINE in the server's scale — that is the whole claim. A
-  // page taking its own log of an already-compressed figure is how the sky and
-  // the room end up drawing one thought at two sizes, and the only way to catch
-  // it is to check a third point against the line the other two define.
-  const mid = star({ id: 22, size: { credits: 200, payments: 4, scale: 0.55, historical: false } });
-  const q = bootSkyPage({ pages: [page([small, big, mid])] });
-  await drain();
-  const c = glyphOf(q.field(), 22);
-  const expected = a.d + (b.d - a.d) * ((0.55 - 0.1) / (1 - 0.1));
-  assert.ok(Math.abs(c.d - expected) <= 1, `0.55 lands on the line the endpoints define (${c.d} vs ~${expected.toFixed(1)})`);
-});
-
-await test('A LARGE DEAD THOUGHT RENDERS LARGE AND DEAD — it keeps its diameter and loses its fill', async () => {
-  // The criterion's own picture, and the thing BV2.R27 goes on to prove live.
-  // The two rows differ ONLY in what happened to the work: same scale on the
-  // remnant as on the star, nothing at all on the cold body.
-  const p = bootSkyPage({ pages: [page([star(), remnant(), coldBody()])] });
-  await drain();
-  const html = p.field();
-  const alive = glyphOf(html, 10);
-  const dead = glyphOf(html, 11);
-  const never = glyphOf(html, 12);
-  assert.equal(dead.d, alive.d, 'size never falls: the remnant is exactly as big as the star');
-  assert.ok(dead.d > never.d, 'and it is visibly bigger than a thought that never mattered');
-  assert.equal(dead.object, 'remnant');
-  assert.equal(never.object, 'cold-body');
-  // Distinguishable in WORDS too, not only in shape — the picture is not the
-  // only channel a reader has.
-  assert.match(labelOf(html, 11), /burned out/);
-  assert.match(labelOf(html, 11), /none of it still alive/);
-  assert.match(labelOf(html, 12), /declined/);
-});
-
-await test('a size that could not be read draws at the floor and says so, never as a measured zero', async () => {
-  const unreadable = star({ id: 30, size: null });
-  const zero = coldBody({ id: 31 });
-  const p = bootSkyPage({ pages: [page([unreadable, zero])] });
-  await drain();
-  const a = glyphOf(p.field(), 30);
-  const b = glyphOf(p.field(), 31);
-  assert.equal(a.unknownSize, true, 'the unreadable one is marked');
-  assert.equal(b.unknownSize, false, 'a real zero is not');
-  assert.match(labelOf(p.field(), 30), /size unknown/);
-  p.pick(30);
-  assert.match(p.panel(), /unknown/, 'the panel says unknown rather than a number');
-  assert.ok(!/size — the work it caused<\/span><span class="sky-fact__v">0/.test(p.panel()));
-});
-
-await test('a historical size carries its marker wherever the number is shown', async () => {
-  const p = bootSkyPage({ pages: [page([star({ size: { credits: 96, payments: 3, scale: 0.71, historical: true } })])] });
-  await drain();
-  p.pick(10);
-  assert.match(p.panel(), /part historical/);
-  assert.match(p.panel(), /not payouts that were made/);
-});
-
-// ═══ brightness: the three answers stay three ═══════════════════════════════
-
-await test('brightness rides the glyph, and a dimmer star is drawn dimmer', async () => {
-  const full = star({ id: 40 });
-  const half = star({ id: 41, state: { ...star().state, brightness: 0.5 } });
-  const p = bootSkyPage({ pages: [page([full, half])] });
-  await drain();
-  assert.equal(glyphOf(p.field(), 40).lit, 1);
-  assert.equal(glyphOf(p.field(), 41).lit, 0.5);
-  assert.match(labelOf(p.field(), 41), /50% still alive/);
+  const p = await boot({ mine: mine(FIVE()), sky: sky([well()]), versions: versions() });
+  p.key('l');
+  const rows = p.rows(); const filters = p.filters(); const objects = p.objects();
+  for (const key of objects.ORDER) {
+    const cls = key === 'cold-body' ? 'cold' : key;
+    assert.ok(new RegExp(`class="mk ${cls}(?: |")`).test(rows), `a row draws the ${key} mark`);
+    assert.ok(filters.includes(objects.objectFor(key).label), `the drawer's filter says "${objects.objectFor(key).label}"`);
+  }
+  const order = objects.ORDER.map((k) => filters.indexOf(`data-f="${k}"`));
+  same(order, [...order].sort((a, b) => a - b), 'the filters sit in the shared ORDER');
+});
+
+await test('the state wins over the row\'s status — the page re-derives nothing', async () => {
+  const p = await boot({ mine: mine([star({ status: 'discarded' })]) });
+  p.key('l');
+  assert.equal(glyphClass(p.rows(), 10).split(' ')[0], 'star', 'a discarded row the resolver called a star is drawn as a star');
+});
+
+await test('a state the page has never heard of is drawn through, not swallowed', async () => {
+  const p = await boot({ mine: mine([idea({ id: 99, state: { state: 'nebula', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: null, hasWork: false, attributable: true } })]) });
+  p.key('l');
+  assert.equal(glyphClass(p.rows(), 99), 'nebula');
+  assert.equal(findIdea(p, 99).st, 'nebula');
+});
+
+// ═══ size and brightness — the two channels ══════════════════════════════════
+
+await test('the diameter is the server scale and nothing else — one curve, drawn by no page', async () => {
+  const p = await boot({ mine: mine([star({ size: { credits: 240, payments: 4, scale: 0.5, historical: false } }), star({ id: 20, size: { credits: 9000, payments: 40, scale: 0.5, historical: false } })]) });
+  const SKY = p.SKY();
+  assert.equal(SKY.diameter(findIdea(p, 10)), SKY.diameter(findIdea(p, 20)), 'same scale, same diameter — the credits do not get a second curve here');
+  assert.equal(SKY.diameter(findIdea(p, 10)), 6 + 22 * 0.5, 'affine in scale (the prototype\'s 6 + 22·scale)');
+  assert.equal(SKY.diameter({ size: null }), 6, 'no size draws at the floor');
+});
+
+await test('A LARGE DEAD THOUGHT IS LARGE AND DEAD — the remnant keeps its diameter and loses its light', async () => {
+  const p = await boot({ mine: mine([star(), remnant()]), sky: sky([well()]) });
+  p.key('l');
+  const rows = p.rows();
+  assert.equal(glyphWidth(rows, 11), glyphWidth(rows, 10), 'the dead one is drawn exactly as wide as the live one it was paid like');
+  assert.equal(glyphClass(rows, 11), 'remnant');
+  assert.equal(findIdea(p, 11).lit, 0);
+  p.SKY().pick({ kind: 'idea', ref: findIdea(p, 11) }, false);
+  assert.match(p.panel(), /none of it still alive/, 'and the words say so');
+  assert.match(p.panel(), /180/, 'while the size is spoken whole');
 });
 
 await test('AN UNREADABLE BRIGHTNESS LEAVES THE STAR FULLY LIT and puts the doubt in words', async () => {
-  // idea-state.js step 3, one layer up and one channel over: `attributable:
-  // false` means the removal facts could not be read, and dimming on it would
-  // draw a healthy instance as a field of half-dead stars the moment the
-  // lifecycle module failed to mount.
-  const unknown = star({ id: 50, state: { ...star().state, brightness: null, attributable: false } });
-  const out = star({ id: 51, state: { ...star().state, brightness: 0, attributable: true } });
-  const p = bootSkyPage({ pages: [page([unknown, out])] });
-  await drain();
-  assert.equal(glyphOf(p.field(), 50).lit, 1, 'unreadable is drawn at full');
-  assert.equal(glyphOf(p.field(), 51).lit, 0, 'a confirmed-dead descent is not');
-  assert.match(labelOf(p.field(), 50), /still alive — unknown/);
-});
-
-await test('the panel draws no brightness BAR for a share nobody could measure', async () => {
-  // A bar at zero and a bar that could not be measured look identical, and one
-  // of them is a claim. The words carry it instead.
-  const unknown = star({ id: 60, state: { ...star().state, brightness: null, attributable: false } });
-  const p = bootSkyPage({ pages: [page([unknown])] });
-  await drain();
-  p.pick(60);
-  assert.ok(!/sky-bar/.test(p.panel()), 'no bar on an unreadable share');
+  const p = await boot({ mine: mine([star({ state: { state: 'star', position: 'well', wellGoalId: '7', awaitingNod: false, brightness: null, hasWork: true, attributable: false } })]) });
+  const i = findIdea(p, 10);
+  assert.equal(i.lit, 1, 'nobody could look, so nothing is drawn as lost');
+  assert.equal(p.SKY().brightnessWord(i), 'still alive — unknown');
+  p.SKY().pick({ kind: 'idea', ref: i }, false);
   assert.match(p.panel(), /still alive — unknown/);
+});
 
-  const q = bootSkyPage({ pages: [page([star({ id: 61, state: { ...star().state, brightness: 0 } })])] });
-  await drain();
-  q.pick(61);
-  assert.match(q.panel(), /sky-bar[^>]*data-lit="out"/, 'a measured zero DOES get a bar, drawn out');
-});
-
-await test('a thought with no work yet says there is nothing to be alive, not that it died', async () => {
-  const p = bootSkyPage({ pages: [page([idea({ id: 70 })])] });
-  await drain();
-  p.pick(70);
-  assert.match(p.panel(), /nothing to be alive yet/);
-  assert.ok(!/none of it still alive/.test(p.panel()));
-});
-
-// ═══ gravity: the wells, and the rings inside them ══════════════════════════
-
-await test('a well is the goal that HOLDS the work, and its name comes from the goals read', async () => {
-  const p = bootSkyPage({
-    pages: [page([star(), idea({ id: 80 })])],
-    goals: [{ id: '7', title: 'The catching goal' }],
-  });
-  await drain();
-  assert.match(p.field(), /The catching goal/);
-  // The floating one is not in it.
-  assert.match(p.field(), /Open space/);
-  assert.match(p.field(), /no goal has claimed this one/);
-});
-
-await test('a well whose goal could not be named keeps its id — never a blank label', async () => {
-  const p = bootSkyPage({ pages: [page([star()])], goals: null });
-  await drain();
-  assert.match(p.field(), /Goal 7/);
-});
-
-await test('the rings are the criteria, closing as each is satisfied', async () => {
-  const p = bootSkyPage({
-    pages: [page([star()])],
-    goals: [{ id: '7', title: 'The catching goal' }],
-    criteria: { 7: [{ satisfied: true }, { satisfied: true }, { satisfied: false }] },
-  });
-  await drain();
-  const rings = [...p.field().matchAll(/class="sky-ring"( data-closed="1")?/g)].map((m) => !!m[1]);
-  assert.deepEqual(rings, [true, true, false]);
-  assert.match(p.field(), /2 of 3 criteria met/);
-});
-
-await test('a goal whose criteria were NOT READ draws no rings, and does not claim it has none', async () => {
-  const p = bootSkyPage({
-    pages: [page([star()])],
-    goals: [{ id: '7', title: 'The catching goal' }],
-    criteria: {},
-  });
-  await drain();
-  assert.ok(!/sky-ring/.test(p.field()), 'no rings at all');
-  assert.ok(!/0 of 0 criteria/.test(p.field()), 'and no claim about how many there are');
-  assert.match(p.field(), /1 thought/, 'it falls back to what it does know');
-});
-
-await test('a satellite is drawn ON the thought it was folded into, when that one is in view', async () => {
-  const host = star({ id: 90 });
-  const moon = idea({
-    id: 91, title: 'Folded in', status: 'merged', merged_into_idea_id: 90, merged_into_idea_title: 'It ignited',
-    state: { state: 'satellite', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: 1, hasWork: true, attributable: true },
-  });
-  const p = bootSkyPage({ pages: [page([host, moon])], goals: [{ id: '7', title: 'The catching goal' }] });
-  await drain();
-  const html = p.field();
-  // Both in the HOST's well, not one in open space — the satellite's own
-  // wellGoalId is null, so grouping by that alone would separate them.
-  assert.ok(!/Open space/.test(html), 'the satellite did not float off on its own');
-  const pos = (id) => {
-    const m = new RegExp(`data-idea="${id}"[\\s\\S]*?left:([\\d.-]+)%;top:([\\d.-]+)%`).exec(html);
-    return { left: Number(m[1]), top: Number(m[2]) };
-  };
-  const a = pos(90);
-  const b = pos(91);
-  const gap = Math.hypot(a.left - b.left, a.top - b.top);
-  assert.ok(gap > 0 && gap < 12, `it orbits the host rather than taking a slot of its own (gap ${gap.toFixed(1)}%)`);
-});
-
-await test('a protostar in a well says a nod is waiting; one in open space says nobody claimed it', async () => {
-  const waiting = idea({
-    id: 100, title: 'Caught, not lit', status: 'promoted',
-    lineage_tasks: [{ task_id: 7, origin: 'promote', title: 'T', status: 'backlog', goal_id: 7 }],
-    state: { state: 'protostar', position: 'well', wellGoalId: '7', awaitingNod: true, brightness: null, hasWork: false, attributable: true },
-  });
-  const floating = idea({ id: 101, title: 'Nobody caught it' });
-  const p = bootSkyPage({ pages: [page([waiting, floating])], goals: [{ id: '7', title: 'A goal' }] });
-  await drain();
-  assert.match(labelOf(p.field(), 100), /waiting for a nod/);
-  assert.match(labelOf(p.field(), 101), /nothing has claimed it/);
-});
-
-// ═══ never the only path ════════════════════════════════════════════════════
-
-await test('every thought carries its whole sentence, so the picture is readable without seeing it', async () => {
-  const p = bootSkyPage({ pages: [page([star({ id: 110, title: 'A named thought' })])] });
-  await drain();
-  const label = labelOf(p.field(), 110);
-  for (const bit of ['A named thought', 'burning', 'size 240', 'all of it still alive']) {
-    assert.ok(label.includes(bit), `the aria-label says "${bit}" — got "${label}"`);
+await test('a thought with no work yet says nothing about what survived', async () => {
+  const p = await boot({ mine: mine([idea()]) });
+  const i = findIdea(p, 1);
+  assert.equal(p.SKY().brightnessWord(i), null);
+  p.SKY().pick({ kind: 'idea', ref: i }, false);
+  assert.doesNotMatch(p.panel(), /still alive/);
+});
+
+// ═══ the wells ═══════════════════════════════════════════════════════════════
+
+await test('a well is the goal that holds the work, from GET /sky, and a caught thought sits inside it', async () => {
+  const p = await boot({ mine: mine([star()]), sky: sky([well()]), versions: versions() });
+  const S = p.S(); const g = S.goalById.get('7'); const i = findIdea(p, 10);
+  assert.ok(g, 'the goal is a well');
+  assert.equal(g.title, 'The well — a goal that holds work');
+  assert.ok(Math.hypot(i.x - g.x, i.y - g.y) <= g.r, 'the thought is placed inside the well that caught it');
+  assert.ok(g.thoughts.includes(i));
+  p.key('l');
+  assert.match(p.rows(), /· in The well/, 'and the row names the well');
+});
+
+await test('the rings are the criteria, closing as each is satisfied and thick with the credits on them', async () => {
+  const p = await boot({ sky: sky([well()]) });
+  const g = p.S().goalById.get('7');
+  assert.equal(g.crit.length, 2);
+  same(g.crit.map((c) => c.satisfied), [true, false]);
+  same(g.crit.map((c) => c.credits), [60, 70], 'a ring\'s credits are the credits of the tasks on it');
+  assert.equal(g.tasks.find((t) => t.id === '500').ci, 0, 'a task knows which ring it gates');
+  assert.equal(g.tasks.find((t) => t.id === '500').sourceRef, '10', 'and which thought it was born of');
+});
+
+await test('a private goal keeps its structure and none of its prose', async () => {
+  const p = await boot({ sky: sky([well({ goal_id: '8', title: null, subtitle: null, criteria: [{ id: '80', criterion_id: 'c1', criterion_md: null, satisfied: false, pending_review: false, task_ids: [] }], tasks: [{ id: '800', title: null, status: 'ready', credits_reward: 10, created_on: '2026-08-01', idea_id: null }] })]) });
+  const g = p.S().goalById.get('8');
+  assert.equal(g.title, 'A private goal');
+  assert.equal(g.crit.length, 1, 'the ring count is structure');
+  assert.equal(g.tasks.length, 1);
+});
+
+await test('a satellite is drawn on the thought it was folded into', async () => {
+  const p = await boot({ mine: mine([star(), satellite()]), sky: sky([well()]) });
+  const host = findIdea(p, 10); const sat = findIdea(p, 13);
+  assert.equal(sat.host, host);
+  assert.ok(Math.abs(Math.hypot(sat.x - host.x, sat.y - host.y) - 14) < 0.001, 'a fixed step off its host, not a slot of its own');
+});
+
+await test('a protostar in a well says a nod is waiting; one in open space says nothing claimed it', async () => {
+  const p = await boot({ mine: mine([waiting(), idea()]), sky: sky([well()]) });
+  const SKY = p.SKY();
+  assert.equal(SKY.positionWord(findIdea(p, 14)), 'waiting for a nod');
+  assert.equal(SKY.positionWord(findIdea(p, 1)), 'nothing has claimed it');
+  assert.equal(SKY.positionWord(findIdea(p, 14)), 'waiting for a nod');
+});
+
+// ═══ the drawer — never the only path ════════════════════════════════════════
+
+await test('EVERY DRAWN THOUGHT IS A ROW IN THE DRAWER with its whole sentence', async () => {
+  const p = await boot({ mine: mine([...FIVE(), waiting()]), sky: sky([well()]) });
+  p.key('l');
+  const rows = p.rows(); const SKY = p.SKY();
+  for (const i of p.S().ideas) {
+    assert.ok(rows.includes(`data-id="${i.id}"`), `${i.title} has a row`);
+    assert.ok(rows.includes(SKY.esc(i.title)), `${i.title} is named whole`);
+    assert.ok(rows.includes(SKY.esc(SKY.became(i))), `${i.title} says what it became`);
+    assert.ok(rows.includes(i.well ? '· in The well' : '· open space'), `${i.title} says where it sits`);
+    if (i.size && i.size.credits) assert.ok(rows.includes(`size ${i.size.credits}`), `${i.title} says its size`);
   }
-  // And it is a real control, not a div with a handler.
-  assert.match(p.field(), /<button type="button" class="sky-body"/);
-});
-
-await test('the page points at the list before anything is picked, and the panel links out after', async () => {
-  const p = bootSkyPage({ pages: [page([star()])], goals: [{ id: '7', title: 'A goal' }] });
-  await drain();
-  assert.match(p.panel(), /href="\/thinking"/, 'the unpicked panel names the room');
-  p.pick(10);
-  const html = p.panel();
-  assert.match(html, /href="\/idea\/10"/, 'the record');
-  assert.match(html, /href="\/goals#\/goal\/7"/, 'the well');
-  assert.match(html, /href="\/task\/500"/, 'and the work it became');
-});
-
-await test('the shell markup itself carries the way back to the list', async () => {
-  const html = await readFile('modules/hall-ui/public/sky.html');
-  assert.match(html, /href="\/builders\/thinking"/);
-  // …and the room carries the way here, so the pair is reachable both ways.
-  const room = await readFile('modules/hall-ui/public/thinking.html');
-  assert.match(room, /href="\/builders\/sky"/);
-});
-
-// ═══ the read ═══════════════════════════════════════════════════════════════
-
-await test('it reads the VIEWER own trail — the id comes from /me, never from the URL', async () => {
-  const p = bootSkyPage({ pages: [page([star()])], viewer: { id: 4242 } });
-  await drain();
-  assert.ok(p.requests.some((u) => u.includes('/inbox/by-builder/4242')));
-  assert.ok(!p.requests.some((u) => /builder=/.test(u)), 'no builder query parameter anywhere');
-});
-
-await test('the whole trail is read in the background, and the figures count what arrived', async () => {
-  const first = page([star({ id: 200 }), star({ id: 201 })], { total: 3, offset: 0 });
-  const second = page([remnant({ id: 202 })], { total: 3, offset: 2 });
-  const p = bootSkyPage({ pages: [first, second] });
-  await drain(40);
-  assert.equal(p.requests.filter((u) => u.includes('/inbox/by-builder/')).length, 2);
-  assert.match(p.sub(), /2 burning, 1 burned out, 3 in all/);
-});
-
-await test('the wells are read AFTER the field is on screen, so the picture never waits on them', async () => {
-  const p = bootSkyPage({ pages: [page([star()])], goals: [{ id: '7', title: 'A goal' }] });
-  await drain();
-  const trailAt = p.requests.findIndex((u) => u.includes('/inbox/by-builder/'));
-  const goalsAt = p.requests.findIndex((u) => /\/goals$/.test(u));
-  assert.ok(trailAt >= 0 && goalsAt > trailAt, 'the trail is asked for first');
-});
-
-await test('an empty trail says so, and points at the one gesture that fixes it', async () => {
-  const p = bootSkyPage({ pages: [page([])] });
-  await drain();
-  assert.match(p.field(), /nothing in your sky/);
-  assert.match(p.field(), /href="\/ideas"/);
-});
-
-await test('a trail that could not be read says so rather than drawing an empty sky', async () => {
-  const p = bootSkyPage({ pages: [page([star()])], trailStatus: 500 });
-  await drain();
-  assert.match(p.field(), /Could not read your idea trail/);
-  assert.ok(!/sky-body/.test(p.field()));
-});
-
-// ═══ it derives nothing the server already answered ═════════════════════════
-
-await test('when the status and the resolved state disagree, the page draws the STATE', async () => {
-  // The room's rule, and it matters more here: a state decided twice is two
-  // states, and the sky is the surface most tempted to guess because it draws
-  // rather than lists. `status` may only be read for what a thought BECAME.
-  //
-  // A GREP CANNOT ASK THIS. `headline()` legitimately counts `state === 'star'`
-  // — the server's own vocabulary, used as the server emitted it — so banning
-  // the five words from the source would fail a correct page while still
-  // passing one that re-derived the object from something else entirely. So the
-  // question is put as a disagreement the page has to resolve: a row whose
-  // `status` says it was discarded and whose resolver says it is a burning
-  // star. Anything reading the status draws a cold body.
-  const liar = star({
-    id: 300, title: 'Discarded, and still burning', status: 'discarded', triage_note: 'a duplicate',
-  });
-  const p = bootSkyPage({ pages: [page([liar])] });
-  await drain();
-  assert.equal(glyphOf(p.field(), 300).object, 'star', 'the resolver wins');
-  assert.match(labelOf(p.field(), 300), /burning/);
-  assert.ok(!/declined/.test(labelOf(p.field(), 300)));
-  // …and the other direction: a row the resolver calls a cold body draws one
-  // however alive its own columns look.
-  const other = star({
-    id: 301, title: 'Promoted, and never lit', status: 'promoted',
-    state: { state: 'cold-body', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: null, hasWork: false, attributable: true },
-  });
-  const q = bootSkyPage({ pages: [page([other])] });
-  await drain();
-  assert.equal(glyphOf(q.field(), 301).object, 'cold-body');
+  assert.equal(p.el('roomCount').textContent, '6 of 6');
 });
 
-await test('a state the page has never heard of is drawn through, not swallowed', async () => {
-  // idea-objects.js passes an unknown state through rather than defaulting it,
-  // because a sixth object would be a real answer the server gave. Drawing it
-  // unstyled beats drawing nothing, and beats drawing it as a protostar.
-  const sixth = star({ id: 310, state: { ...star().state, state: 'pulsar' } });
-  const p = bootSkyPage({ pages: [page([sixth])] });
-  await drain();
-  assert.equal(glyphOf(p.field(), 310).object, 'pulsar');
-  assert.match(labelOf(p.field(), 310), /pulsar/);
+await test('the drawer is one key away — L opens it, L closes it, and the button agrees', async () => {
+  const p = await boot({ mine: mine(FIVE()) });
+  const room = p.el('room');
+  assert.equal(room.hidden, true, 'closed at first');
+  p.key('l');
+  assert.equal(room.hidden, false);
+  assert.equal(p.el('roomBtn').getAttribute('aria-pressed'), 'true');
+  assert.match(p.rows(), /class="row"/);
+  p.key('l');
+  assert.equal(room.hidden, true);
+  assert.equal(p.el('roomBtn').getAttribute('aria-pressed'), 'false');
+});
+
+await test('a key pressed inside the composer is the composer\'s, not the sky\'s', async () => {
+  const p = await boot({ mine: mine(FIVE()) });
+  p.key('l', { tagName: 'INPUT', blur() {} });
+  assert.equal(p.el('room').hidden, true, 'typing an l into the line does not open the drawer');
+});
+
+// ═══ empty and failed ════════════════════════════════════════════════════════
+
+await test('THE PAGE RENDERS WITH AN EMPTY TRAIL — an empty sky is a state, not an error', async () => {
+  const p = await boot({ mine: mine([]), sky: sky([]), versions: versions() });
+  assert.ok(p.ready());
+  assert.match(p.stats(), /<b>0<\/b> thoughts/);
+  p.key('l');
+  assert.match(p.rows(), /Nothing of that kind in your sky\./);
+  assert.doesNotThrow(() => p.frame(), 'a frame draws with nothing in it');
+  assert.equal(p.S().BANDS.length, 2, 'the bands are still the versions\'');
+});
+
+await test('reads that fail still leave a sky that draws', async () => {
+  const p = await boot({ status: { sky: 500, mine: 500 } });
+  assert.ok(p.ready());
+  assert.match(p.stats(), /<b>0<\/b> thoughts/);
+  assert.doesNotThrow(() => p.frame());
+  assert.equal(p.S().BANDS[0].r0, 0, 'with no versions read there is still a present band to draw in');
+});
+
+// ═══ the two heuristics that must not ship (part 5's facts) ══════════════════
+
+await test('the claude layer is HIDDEN until filed_via exists, and every thought shows', async () => {
+  const p = await boot({ mine: mine(FIVE()) });
+  assert.equal(p.S().hasFiledVia, false);
+  assert.equal(p.el('claudeBtn').hidden, true, 'the pill is not offered');
+  assert.equal(p.S().ideas.filter(p.SKY().inLayer).length, 5, 'nothing is guessed to be a session\'s');
+  assert.ok(p.S().ideas.every((i) => i.origin === 'human'));
+});
+
+await test('once filed_via is on a row the pill appears, that thought waits behind it, and historic rows still show', async () => {
+  const p = await boot({ mine: mine([star(), idea({ id: 2, title: 'A session filed this', filed_via: 'session' }), idea({ id: 3, title: 'A person filed this', filed_via: 'person' })]) });
+  assert.equal(p.S().hasFiledVia, true);
+  assert.equal(p.el('claudeBtn').hidden, false);
+  const SKY = p.SKY();
+  assert.equal(SKY.inLayer(findIdea(p, 2)), false, 'off by default: only what a person filed');
+  assert.equal(SKY.inLayer(findIdea(p, 10)), true, 'a historic row with no filed_via shows (the owner\'s rule)');
+  assert.equal(SKY.inLayer(findIdea(p, 3)), true);
+  p.click('claudeBtn');
+  assert.equal(SKY.inLayer(findIdea(p, 2)), true, 'the pill reveals it');
+});
+
+await test('NO BORN-OF MARK IS DRAWN — the read does not exist yet, so nothing is guessed', async () => {
+  const p = await boot({ mine: mine(FIVE()), sky: sky([well()]) });
+  const S = p.S();
+  assert.equal(S.becameGoal.size, 0);
+  assert.equal(S.becameCrit.size, 0);
+  assert.ok(S.ideas.every((i) => i.shaped === null));
+  assert.ok(S.goals.every((g) => g.bornOf === null && g.crit.every((c) => c.bornOf === null)));
+  p.key('l');
+  assert.doesNotMatch(p.rows(), /born of a thought/);
+});
+
+// ═══ the bands — derived, never named by hand ════════════════════════════════
+
+await test('the bands come from the versions read: building at the centre, shipped outward, small ones sharing a band', async () => {
+  const p = await boot({});
+  const goalsIn = (v, n) => Array.from({ length: n }, (_, i) => ({ version: v, id: `${v}-${i}` }));
+  const bands = p.SKY().bandsFor([
+    { id: 'NEW', status: 'building', shipped_at: null },
+    { id: 'OLD-1', status: 'shipped', shipped_at: '2026-06-01T00:00:00.000Z' },
+    { id: 'OLD-2', status: 'shipped', shipped_at: '2026-04-01T00:00:00.000Z' },
+    { id: 'OLD-3', status: 'shipped', shipped_at: '2026-03-01T00:00:00.000Z' },
+    { id: 'PLAN', status: 'planning', shipped_at: null },
+  ], [...goalsIn('NEW', 4), ...goalsIn('OLD-1', 12), ...goalsIn('OLD-2', 1), ...goalsIn('OLD-3', 2)]);
+  same(bands[0].versions, ['NEW', 'PLAN'], 'the present holds whatever is not shipped');
+  assert.equal(bands[0].r0, 0);
+  same(bands[1].versions, ['OLD-1'], 'the newest shipped version is the first ring out');
+  same(bands[2].versions, ['OLD-2', 'OLD-3'], 'two small versions share a band so no ring is razor-thin');
+  assert.equal(bands[2].state, 'the beginning');
+  assert.equal(bands[1].label, 'old-1');
+  assert.ok(bands[1].r0 > bands[0].r1 && bands[2].r0 > bands[1].r1, 'rings never overlap');
+  const src = ['sky-data.js', 'sky-layout.js', 'sky-draw.js', 'sky-interaction.js', 'sky-panel.js', 'sky-composer.js', 'sky-tour.js'];
+  const fs = await import('node:fs'); const path = await import('node:path');
+  for (const f of src) assert.doesNotMatch(fs.readFileSync(path.join('modules/hall-ui/public', f), 'utf8'), /BONGOS-V\d|GDS-V\d|PMS-V\d|CB-V\d/, `${f} names no instance version`);
+});
+
+await test('"the whole project" leaves for the project sky at /goal-map', async () => {
+  const p = await boot({ mine: mine(FIVE()) });
+  p.click('lensAll');
+  assert.equal(p.navigated, '/goal-map');
+  assert.equal(p.S().lens, 'mine', 'this page does not switch — part 4 owns that view');
+});
+
+// ═══ the words are never markup ══════════════════════════════════════════════
+
+await test('a title never becomes markup — in the drawer, the panel and the hover card', async () => {
+  const evil = '<img src=x onerror=alert(1)> & "quotes"';
+  const p = await boot({ mine: mine([star({ title: evil })]), sky: sky([well({ title: '<b>bold goal</b>' })]) });
+  p.key('l');
+  const i = findIdea(p, 10);
+  p.SKY().pick({ kind: 'idea', ref: i }, false);
+  p.SKY().showCard({ kind: 'idea', ref: i }, 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`);
+  }
+  assert.ok(p.rows().includes('&lt;b&gt;bold goal') && !p.rows().includes('<b>bold goal'), 'a goal title is escaped too');
+});
+
+// ═══ the tour, the lenses and the keys ═══════════════════════════════════════
+
+await test('the tour is the template\'s thirteen steps — ? opens it, Escape closes it', async () => {
+  const p = await boot({ mine: mine(FIVE()), sky: sky([well()]), versions: versions() });
+  const STEPS = p.SKY().STEPS;
+  assert.equal(STEPS.length, 13);
+  same(STEPS.map((s) => s.h), [
+    'This is your sky.', 'A goal is a gravity well.', 'A ring is a criterion.', 'A burning thought is a star.', 'Some thoughts became the structure.',
+    'Unclaimed thoughts drift.', 'An alive well glows.', 'Routes run between goals that wait on each other.', 'A settled system is a goal that finished.',
+    'The sky has a clock.', 'By default, you explore.', 'Release a thought here.', 'When it is too much, go simple.',
+  ]);
+  assert.equal(p.el('tour').hidden, true);
+  p.key('?');
+  assert.equal(p.el('tour').hidden, false);
+  assert.equal(p.el('tourN').textContent, 'how to read the sky · 1 of 13');
+  for (let n = 0; n < 12; n++) p.click('tourNext');
+  assert.equal(p.el('tourN').textContent, 'how to read the sky · 13 of 13');
+  assert.equal(p.el('tourNext').textContent, 'start reading');
+  p.key('Escape');
+  assert.equal(p.el('tour').hidden, true);
+  assert.equal(p.S().lens, 'mine', 'the tour hands the sky back to your thinking');
+});
+
+await test('the tour opens by itself on a first visit, and only then', async () => {
+  const first = await boot({ mine: mine(FIVE()), tourSeen: false });
+  assert.equal(first.timers.pending(), 1, 'a first visit schedules the tour');
+  await first.timers.flush();
+  assert.equal(first.el('tour').hidden, false);
+  const again = await boot({ mine: mine(FIVE()), tourSeen: true });
+  assert.equal(again.timers.pending(), 0);
+});
+
+await test('the simple lens: no drawer, no jump, no legend, just the thoughts in their wells', async () => {
+  const p = await boot({ mine: mine(FIVE()), sky: sky([well()]) });
+  p.key('l');
+  p.click('lensSimple');
+  assert.equal(p.S().lens, 'simple');
+  assert.equal(p.el('room').hidden, true, 'the drawer closes');
+  assert.equal(p.el('roomBtn').hidden, true);
+  assert.equal(p.el('legend').hidden, true);
+  assert.equal(p.el('recentBtn').hidden, false, 'recent / all is the one control');
+  assert.equal(p.el('lensWord').textContent, '— simply');
+  p.click('recentBtn');
+  assert.equal(p.S().recentOnly, true);
+  assert.match(p.stats(), /the last thirty days/);
+});
+
+await test('keys: 0 fits the sky and / puts the cursor in the composer', async () => {
+  const p = await boot({ mine: mine(FIVE()) });
+  p.S().cam.k = 5;
+  p.key('0');
+  assert.notEqual(p.S().cam.k, 5, 'the camera moved to the fit');
+  p.key('/');
+  assert.equal(p.focused(), p.el('thought'));
+});
+
+await test('"my influence" fades every well your thoughts never touched', async () => {
+  const p = await boot({ mine: mine([star()]), sky: sky([well(), well({ goal_id: '9', title: 'Untouched', tasks: [{ id: '900', title: 'x', status: 'ready', credits_reward: 10, created_on: '2026-08-01', idea_id: null }] })]) });
+  p.click('influenceBtn');
+  const SKY = p.SKY(); const now = Date.now();
+  assert.equal(SKY.goalAlpha(p.S().goalById.get('7'), now), 1);
+  assert.ok(SKY.goalAlpha(p.S().goalById.get('9'), now) <= 0.12);
 });
 
-await test('it computes no brightness and no compression of its own', async () => {
-  const src = await readFile('modules/hall-ui/public/sky.js');
-  const code = src.split('\n').filter((l) => !/^\s*\/\//.test(l)).join('\n');
-  assert.ok(!/Math\.log/.test(code), 'no second compression curve');
-  assert.ok(!/descent_tasks\s*\.\s*length\s*\/\s*/.test(code), 'no brightness computed from a descent length');
+await test('a capped trail is spoken, never a silent slice', async () => {
+  const p = await boot({ mine: mine(FIVE(), { total: 1400, truncated: true }) });
+  assert.match(p.stats(), /the newest 5 only/);
 });
 
+console.log('');
 summary();