@bongos/core 1.19.1011 → 1.19.1013

package/tests/hall_thinking_room.mjs

@@ -1,366 +1,344 @@
-// tests/hall_thinking_room.mjs — THE ROOM, at the rendered layer
-// (task 1004098 / BV2.R03 of goal 1000095, criterion `ideator-nothing-is-lost`).
+// tests/hall_thinking_room.mjs — THE ROOM inside the sky, and the composer
+// (task 1004231 / sky part 3 of 5, goal 1000095; ADR 0331; criterion
+// `ideator-nothing-is-lost`).
 //
-// This suite boots the REAL modules/hall-ui/public/thinking.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.
+// The room (task 1004098) was a page; it is now the sky's list drawer, one key
+// away, and this suite is what its old suite was for: the last step, where a
+// correct server answer becomes a sentence a person reads. It boots the REAL
+// page through bootSkyPage (tests/helpers.mjs) and reads the drawer it
+// writes; the drawing half is tests/hall_sky.mjs.
 //
-// WHAT IT IS ACTUALLY GUARDING. Every number this page draws is computed and
-// tested server-side already — the five states (tests/idea_state.mjs), size
-// (tests/idea_size.mjs), brightness (tests/idea_brightness.mjs), the descent
-// (tests/idea_descent_surface.mjs). What none of those can see is the last
-// step, where a correct answer is turned into a sentence: a renderer that
-// collapses "we could not read the removal facts" into "none of it survived",
-// or that computes its own compression curve, or that counts its figures over
-// one window while labelling them as a life's work, fails nothing upstream. So
-// the cases below are mostly about the THREE ANSWERS staying three, and about
-// the page never deriving what the server already decided.
+// THE COMPOSER is the other half here, because the task's binding line is
+// that filing from the sky writes the SAME record the hall form writes: quick
+// is POST /inbox with the line, full is POST /inbox with the template's fields
+// — so a case asserts the request body byte for byte — and gravity is the real
+// landing verdict (POST /inbox/preview-landing over the suggester's pick),
+// never a keyword match, so a case makes the two disagree and checks which
+// one the page believed.
 
-import { makeRunner, settle } from './helpers.mjs';
-import { bootThinkingPage } from './helpers.mjs';
+import assert from 'node:assert/strict';
+import { makeRunner, settle, bootSkyPage } from './helpers.mjs';
 
 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);
 
-// Several awaits deep (the /me read, then a page, then the background loop),
-// so one microtask turn is not enough. Ten is comfortably past the longest
-// chain any case below sets up.
-const drain = async (n = 10) => { for (let i = 0; i < n; i += 1) await settle(); };
+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 — so every case below states only the
-// facts it is actually 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',
+  id: 10, title: 'It ignited', status: 'promoted', captured_at: '2026-09-05T00:00:00.000Z',
   lineage_tasks: [{ task_id: 500, origin: 'promote', title: 'The task', status: 'shipped', goal_id: 7 }],
+  descent_tasks: [{ task_id: 501, depth: 1, relation: 'split', title: 'A follow-up', status: 'active', goal_id: 7 }],
   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 },
+  state: { state: 'star', position: 'well', wellGoalId: '7', awaitingNod: false, brightness: 1, hasWork: true, attributable: true },
   ...over,
 });
-const remnant = (over = {}) => star({
-  id: 11, title: 'It burned, then it went',
-  size: { credits: 180, payments: 5, scale: 0.81, historical: false },
-  state: { state: 'remnant', position: 'well', wellGoalId: 7, awaitingNod: false, brightness: 0, hasWork: true, attributable: true },
+const remnant = (over = {}) => star({ id: 11, title: 'It burned, then it went', descent_tasks: [], size: { credits: 180, payments: 5, scale: 0.81, historical: true }, 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', 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,
 });
-
-// ---------------------------------------------------------------------------
-// The five objects reach the reader as the design's words
-
-await test('every one of the five objects renders its own label from the shared table', async () => {
-  const rows = [
-    star(),
-    idea({ id: 2, state: { state: 'protostar', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: null, hasWork: false, attributable: true } }),
-    idea({ id: 3, status: 'merged', merged_into_idea_id: 9, merged_into_idea_title: 'The other one', state: { state: 'satellite', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: 1, hasWork: true, attributable: true } }),
-    remnant(),
-    idea({ id: 5, status: 'discarded', state: { state: 'cold-body', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: null, hasWork: false, attributable: false } }),
-  ];
-  const p = bootThinkingPage({ pages: [page(rows)] });
-  await drain();
-  const html = p.rows();
-  const objects = p.objects();
-  for (const key of objects.ORDER) {
-    const label = objects.objectFor(key).label;
-    if (!html.includes(`data-object="${key}"`)) throw new Error(`no row marked ${key}`);
-    if (!html.includes(`>${label}<`)) throw new Error(`${key} never says "${label}"`);
-  }
+const FIVE = () => [star(), idea(), satellite(), remnant(), coldBody()];
+const mine = (ideas, over = {}) => ({ builder_id: 95, ideas, total: ideas.length, cap: 1000, truncated: false, ...over });
+const well = (over = {}) => ({ goal_id: '7', title: 'The well — a goal', subtitle: null, status: 'open', version_id: 'V2', category: null, task_total: 1, task_done: 1, created_at: '2026-06-01T00:00:00.000Z', criteria: [], tasks: [{ id: '500', title: 'The task', status: 'shipped', credits_reward: 60, created_on: '2026-07-01', idea_id: '10' }], ...over });
+const sky = (goals) => ({ goals, edges: [], counts: {}, cache: {} });
+const versions = () => ({ versions: [{ id: 'V2', status: 'building', shipped_at: null }] });
+const findIdea = (p, id) => p.S().ideas.find((i) => i.id === String(id));
+const bodyOf = (p, method, path) => (p.requests.find((r) => r.method === method && r.url === `/api/bongos${path}`) || {}).body;
+const filed = (over = {}) => ({ status: 201, ok: true, data: { idea: { id: 900, title: 'a thought about the sky', kind: 'feature', status: 'open', captured_at: '2026-09-25T10:00:00.000Z', grade: 'quick', ...over } } });
+
+// ═══ the room ════════════════════════════════════════════════════════════════
+
+await test('the room lists everything, counts it, and its filters are the five in the shared order with their counts', async () => {
+  const p = await boot({ mine: mine(FIVE()), sky: sky([well()]), versions: versions() });
+  p.key('l');
+  assert.equal(p.el('roomTitle').textContent, 'the room');
+  assert.equal(p.el('roomCount').textContent, '5 of 5');
+  const f = p.filters();
+  assert.match(f, /data-f="all"[^>]*>everything <span[^>]*>5</);
+  for (const [k, n] of [['star', 1], ['protostar', 1], ['satellite', 1], ['remnant', 1], ['cold-body', 1]]) assert.match(f, new RegExp(`data-f="${k}"[^>]*>[^<]+<span[^>]*>${n}<`));
+  assert.equal((p.rows().match(/class="row"/g) || []).length, 5);
 });
 
-await test('the page does not re-derive the object — the server\'s state wins over the row\'s status', async () => {
-  // A discarded row the resolver nevertheless called a star. That combination
-  // is REAL (idea-state.js step 2: work beats a discard, because triage can
-  // decline a duplicate whose twin already routed and paid), and a page that
-  // switched on `status` instead of `state` would draw it as a cold body.
-  const p = bootThinkingPage({ pages: [page([star({ status: 'discarded' })])] });
-  await drain();
-  const html = p.rows();
-  if (!html.includes('data-object="star"')) throw new Error('the status overrode the state');
-  if (html.includes('cold-body')) throw new Error('drew a cold body over a star');
+await test('choosing a filter shows only that object, and the drawer says which', async () => {
+  const p = await boot({ mine: mine(FIVE()) });
+  p.key('l');
+  const btn = p.el('filters').querySelectorAll('button').find((b) => b.dataset.f === 'remnant');
+  btn.fire('click', { type: 'click' });
+  assert.equal((p.rows().match(/class="row"/g) || []).length, 1);
+  assert.match(p.rows(), /data-id="11"/);
+  assert.equal(p.el('roomCount').textContent, '1 of 5');
+  assert.equal(p.S().filter, 'remnant');
 });
 
-// ---------------------------------------------------------------------------
-// Size and brightness are two channels — the whole reason the model has two
-
-await test('a remnant renders LARGE and DEAD: full size, no colour, and it says so', async () => {
-  const p = bootThinkingPage({ pages: [page([remnant()])] });
-  await drain();
-  const html = p.rows();
-  if (!html.includes('180')) throw new Error('lost the true figure');
-  if (!html.includes('--w:81%')) throw new Error('the bar did not keep its size');
-  if (!html.includes('data-lit="out"')) throw new Error('the bar kept its colour');
-  if (!html.includes('none of it still alive')) throw new Error('never said the work is gone');
+await test('a row says what became of it, in words a reader can act on', async () => {
+  const p = await boot({ mine: mine([...FIVE(), waiting()]), sky: sky([well()]) });
+  p.key('l');
+  const rows = p.rows();
+  const rowOf = (id) => (new RegExp(`data-id="${id}"[\\s\\S]*?</button>`).exec(rows) || [''])[0];
+  assert.match(rowOf(10), /2 tasks, 1 shipped/, 'a star counts its roots and its descent, and how many shipped');
+  assert.match(rowOf(10), /size 240/);
+  assert.match(rowOf(1), /nothing yet/);
+  assert.match(rowOf(13), /folded into another thought/);
+  assert.match(rowOf(12), /declined at triage/);
+  assert.match(rowOf(14), /1 task/);
+  assert.match(rowOf(14), /· in The well/);
+  assert.match(rowOf(1), /· open space/);
 });
 
-await test('a thought that never mattered is distinguishable from a large dead one at a glance', async () => {
-  // The failure the two-channel model exists to prevent: one number would draw
-  // these two the same. The proof task (BV2.R21) demonstrates it live; this is
-  // the pin under it.
-  const p = bootThinkingPage({ pages: [page([remnant(), idea({ id: 20, title: 'Nothing came of it' })])] });
-  await drain();
-  const html = p.rows();
-  if (!html.includes('--w:81%')) throw new Error('the dead thought lost its size');
-  // The unignited one has no bar at all, only the dash.
-  const bars = html.match(/tr-size__bar/g) || [];
-  if (bars.length !== 1) throw new Error(`expected exactly one bar, got ${bars.length}`);
+await test('the panel spells a thought out: gravity, what it became, size, brightness, position, the descent, the record', async () => {
+  const p = await boot({ mine: mine([star(), waiting()]), sky: sky([well()]) });
+  p.SKY().pick({ kind: 'idea', ref: findIdea(p, 10) }, false);
+  const panel = p.panel();
+  assert.match(panel, /<h2>It ignited<\/h2>/);
+  assert.match(panel, /gravity<\/span><span class="v"><a href="#" data-goal="7">The well — a goal<\/a>/);
+  assert.match(panel, /became<\/span><span class="v">2 tasks, 1 shipped/);
+  assert.match(panel, /size — credits<\/span><span class="v num">240/);
+  assert.match(panel, /brightness — still alive[\s\S]*all of it still alive/);
+  assert.match(panel, /the descent — everything that fell out of it/);
+  assert.match(panel, /<span class="st">shipped<\/span><span>The task/);
+  assert.match(panel, /<span class="st live">active<\/span><span>A follow-up/);
+  assert.match(panel, /href="\/idea\/10"[^>]*>the record</, 'the record is one door away');
+  p.SKY().pick({ kind: 'idea', ref: findIdea(p, 14) }, false);
+  assert.match(p.panel(), /position<\/span><span class="v">waiting for a nod/);
 });
 
-await test('an UNREADABLE brightness is not a dead one', async () => {
-  // attributable:false with work — the lifecycle module could not be asked.
-  // idea-state.js is emphatic that this is not `share === 0`, and a renderer
-  // that dimmed the bar or said "none of it still alive" would state, in a
-  // sentence a person reads, something nobody checked.
-  const p = bootThinkingPage({
-    pages: [page([star({ state: { state: 'star', position: 'well', wellGoalId: 7, awaitingNod: false, brightness: null, hasWork: true, attributable: false } })])],
-  });
-  await drain();
-  const html = p.rows();
-  if (!html.includes('still alive — unknown')) throw new Error('did not say the share is unknown');
-  if (html.includes('none of it still alive')) throw new Error('called an unreadable share a dead one');
-  if (html.includes('data-lit="out"')) throw new Error('greyed a bar on a share nobody could read');
+await test('a title is escaped before it reaches the room', async () => {
+  const p = await boot({ mine: mine([idea({ title: '<script>alert(1)</script>' })]) });
+  p.key('l');
+  assert.ok(p.rows().includes('&lt;script&gt;alert(1)&lt;/script&gt;'));
+  assert.ok(!p.rows().includes('<script>'));
 });
 
-await test('a graded brightness reaches the reader as a percentage', async () => {
-  const p = bootThinkingPage({
-    pages: [page([star({ state: { state: 'star', position: 'well', wellGoalId: 7, awaitingNod: false, brightness: 0.67, hasWork: true, attributable: true } })])],
-  });
-  await drain();
-  if (!p.rows().includes('67% still alive')) throw new Error('lost the graded share');
+await test('the figures count the five states over the whole trail', async () => {
+  const p = await boot({ mine: mine([...FIVE(), star({ id: 15, title: 'Another star' })]) });
+  assert.match(p.stats(), /<b>6<\/b> thoughts · <b>2<\/b> burning · <b>1<\/b> waiting · <b>1<\/b> folded in · <b>1<\/b> burned out · <b>1<\/b> declined/);
 });
 
-await test('`size: null` reads as unknown, never as zero', async () => {
-  // trail-size.js sets null when the reward port could not be asked at all.
-  // Drawing that as a dash would claim the thought earned nothing.
-  const p = bootThinkingPage({ pages: [page([star({ size: null })])] });
-  await drain();
-  const html = p.rows();
-  if (!html.includes('unknown')) throw new Error('did not say the ledger could not be read');
-  if (html.includes('tr-size__bar')) throw new Error('drew a bar over a size nobody could read');
+await test('an empty trail renders the room empty, and the composer is there to fix it', async () => {
+  const p = await boot({ mine: mine([]) });
+  p.key('l');
+  assert.match(p.rows(), /Nothing of that kind in your sky\./);
+  assert.equal(p.el('roomCount').textContent, '0 of 0');
+  assert.equal(p.el('composerWrap').hidden, false);
+  assert.equal(p.el('thought').placeholder, 'release a thought — one line');
 });
 
-await test('a zero size is a dash, and a historical one carries its marker', async () => {
-  const p = bootThinkingPage({
-    pages: [page([
-      idea({ id: 30 }),
-      star({ id: 31, size: { credits: 96, payments: 3, scale: 0.71, historical: true } }),
-    ])],
-  });
-  await drain();
-  const html = p.rows();
-  if (!html.includes('—')) throw new Error('a zero size drew no dash');
-  if (!html.includes('part historical')) throw new Error('a historical size did not say so');
-});
+// ═══ the composer — quick ═══════════════════════════════════════════════════
 
-await test('the bar width is the server\'s compressed scale, not a second curve', async () => {
-  const p = bootThinkingPage({ pages: [page([star({ size: { credits: 9999, payments: 40, scale: 0.42, historical: false } })])] });
+await test('QUICK: Enter files the line through POST /inbox exactly as the hall form does', async () => {
+  const p = await boot({ mine: mine(FIVE()), versions: versions() });
+  p.handlers.push((m, u) => (m === 'POST' && u.endsWith('/inbox') ? filed() : null));
+  p.type('a thought about the sky');
+  assert.ok(p.el('file').classList.contains('live'), 'the file button lights as you type');
+  p.submit();
   await drain();
-  if (!p.rows().includes('--w:42%')) throw new Error('the page compressed the number itself');
+  same(bodyOf(p, 'POST', '/inbox'), { title: 'a thought about the sky', body_md: '', kind: 'feature' }, 'the hall form\'s quick body — title, body_md, kind — and nothing else');
+  assert.equal(p.el('thought').value, '', 'the line is released');
+  assert.match(p.receipt(), /^filed · nothing caught it · floating in open space$/);
+  const i = findIdea(p, 900);
+  assert.ok(i, 'the filed thought is in the sky');
+  assert.equal(i.st, 'protostar');
+  assert.equal(i.well, null);
+  assert.ok(p.S().flying && p.S().flying.idea === i, 'and it flies to where it landed');
+  p.key('l');
+  assert.match(p.rows(), /data-id="900"[\s\S]*?a thought about the sky/, 'and it is a row in the drawer at once');
 });
 
-// ---------------------------------------------------------------------------
-// What a row says it became
-
-await test('a folded thought names the thought that absorbed it, and links to it', async () => {
-  const p = bootThinkingPage({
-    pages: [page([idea({ id: 3, status: 'merged', merged_into_idea_id: 9, merged_into_idea_title: 'The other one', state: { state: 'satellite', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: 1, hasWork: true, attributable: true } })])],
-  });
+await test('an empty line files nothing', async () => {
+  const p = await boot({ mine: mine([]) });
+  p.type('   ');
+  p.submit();
   await drain();
-  const html = p.rows();
-  if (!html.includes('folded into')) throw new Error('did not say it was folded');
-  if (!html.includes('/idea/9')) throw new Error('did not link the absorbing thought');
+  assert.equal(bodyOf(p, 'POST', '/inbox'), undefined);
 });
 
-await test('a thought awaiting a nod says so — the one actionable phrase on the page', async () => {
-  const p = bootThinkingPage({
-    pages: [page([idea({
-      id: 4, status: 'open',
-      lineage_tasks: [{ task_id: 77, origin: 'route', title: 'The routed task', status: 'backlog', goal_id: 12 }],
-      state: { state: 'protostar', position: 'well', wellGoalId: 12, awaitingNod: true, brightness: null, hasWork: false, attributable: true },
-    })])],
-  });
+await test('a filing that fails keeps the line and says so — nothing is lost', async () => {
+  const p = await boot({ mine: mine([]) });
+  p.handlers.push((m, u) => (m === 'POST' && u.endsWith('/inbox') ? { status: 400, ok: false, data: { error: { code: 'validation_failed' } } } : null));
+  p.type('a thought about the sky');
+  p.submit();
   await drain();
-  if (!p.rows().includes('waiting for a nod')) throw new Error('a nod queue nobody can see is a list someone must remember');
+  assert.equal(p.el('thought').value, 'a thought about the sky', 'the line comes back');
+  assert.match(p.receipt(), /not filed — validation failed/);
+  assert.equal(p.S().ideas.length, 0, 'nothing was invented');
 });
 
-await test('a thought that caused nothing says so plainly, and a declined one gives the reason', async () => {
-  const p = bootThinkingPage({
-    pages: [page([
-      idea({ id: 5 }),
-      idea({ id: 6, status: 'discarded', triage_note: 'The digest already exists.', state: { state: 'cold-body', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: null, hasWork: false, attributable: false } }),
-    ])],
-  });
+// ═══ gravity — the real verdict ══════════════════════════════════════════════
+
+const gravityWorld = (verdict, suggestions = [{ id: 7, title: 'The well — a goal', score: 3, matched_terms: ['well'] }]) => (m, u, body) => {
+  if (m === 'GET' && u.includes('/goals/suggestions')) return { status: 200, ok: true, data: { suggestions } };
+  if (m === 'POST' && u.endsWith('/inbox/preview-landing')) return { status: 200, ok: true, data: typeof verdict === 'function' ? verdict(body) : verdict };
+  return null;
+};
+
+await test('GRAVITY: the well that would catch it lights from the real verdict, and the filing names that goal', async () => {
+  const p = await boot({ mine: mine([]), sky: sky([well()]), versions: versions() });
+  p.handlers.push(gravityWorld({ outcome: 'routed', reason: null, status: 'backlog', goal: { id: 7, title: 'The well — a goal' }, version_id: 'V2', refusal: null }));
+  p.handlers.push((m, u) => (m === 'POST' && u.endsWith('/inbox') ? filed({ routing: { routed: true, goal_id: 7 } }) : null));
+  p.handlers[p.handlers.length - 1] = ((h) => (m, u) => { const r = h(m, u); if (r) r.data.routed_task = { id: 9002, status: 'backlog', goal_id: 7, title: 'a thought about the sky' }; return r; })(p.handlers[p.handlers.length - 1]);
+  p.type('a thought about the well');
+  assert.equal(p.timers.pending(), 1, 'a keystroke schedules one debounced read, not a request');
+  await p.timers.flush();
   await drain();
-  const html = p.rows();
-  if (!html.includes('nothing yet')) throw new Error('an unignited thought read as an absence');
-  if (!html.includes('The digest already exists.')) throw new Error('lost the triager\'s reason');
-});
-
-await test('the descent below the roots is counted, not folded into the root count', async () => {
-  // attachDescentToTrail deliberately EXCLUDES the roots from descent_tasks, so
-  // a page that read one as the whole would under-report every deep thought.
-  const p = bootThinkingPage({
-    pages: [page([star({
-      lineage_tasks: [
-        { task_id: 500, origin: 'promote', title: 'One', status: 'shipped', goal_id: 7 },
-        { task_id: 501, origin: 'develop', title: 'Two', status: 'shipped', goal_id: 7 },
-      ],
-      descent_tasks: [
-        { task_id: 600, depth: 1, relation: 'split', title: 'Three', status: 'shipped' },
-        { task_id: 601, depth: 2, relation: 'rewrite', title: 'Four', status: 'shipped' },
-      ],
-    })])],
-  });
+  const sug = p.requests.find((r) => r.url.includes('/goals/suggestions'));
+  assert.ok(sug && sug.url.includes('version=V2') && sug.url.includes('title=a%20thought%20about%20the%20well'), 'the suggester is asked per building version, with the line');
+  same(bodyOf(p, 'POST', '/inbox/preview-landing'), { kind: 'feature', goal_id: 7 }, 'the preview is asked about the suggested goal');
+  assert.match(p.gravity(), /gravity · <b class="hot">The well — a goal<\/b> would catch it — a task in its well, waiting for a nod/);
+  assert.equal(p.S().gravityGoal, p.S().goalById.get('7'), 'the well lights in the sky');
+  p.submit();
   await drain();
-  const html = p.rows();
-  if (!html.includes('2 tasks')) throw new Error('lost a root');
-  if (!html.includes('2 more below them')) throw new Error('lost the descent');
+  same(bodyOf(p, 'POST', '/inbox'), { title: 'a thought about the well', body_md: '', kind: 'feature', goal_id: 7 }, 'the goal the verdict named rides the filing');
+  assert.match(p.receipt(), /caught by <b>The well<\/b> · a task in its well, waiting for a nod/);
+  const i = findIdea(p, 900);
+  assert.equal(i.well, '7');
+  assert.equal(i.awaiting, true);
+  same(i.lineage.map((t) => [t.id, t.status, t.origin]), [['9002', 'backlog', 'route']]);
+  assert.equal(p.S().gravityGoal, null, 'and the line is clear again');
 });
 
-// ---------------------------------------------------------------------------
-// The figures are a claim about a whole trail
-
-await test('the figures count the five states, and "filed" is the server\'s total', async () => {
-  const rows = [star(), star({ id: 12 }), remnant(), idea({ id: 13 })];
-  const p = bootThinkingPage({ pages: [page(rows, { total: 4 })] });
+await test('gravity READS the verdict, it does not compute one — the suggester\'s pick means nothing until the matrix says routed', async () => {
+  const p = await boot({ mine: mine([]), sky: sky([well()]), versions: versions() });
+  p.handlers.push(gravityWorld({ outcome: 'floats', reason: 'judgment_kind', status: null, goal: { id: 7, title: 'The well — a goal' }, version_id: null, refusal: null }));
+  p.type('the well the well the well');
+  await p.timers.flush();
   await drain();
-  const figs = p.figs();
-  // 4 filed, 3 ignited (two stars + the remnant), 2 burning, 1 burned out.
-  for (const [n, label] of [['4', 'filed'], ['3', 'ignited'], ['2', 'still burning'], ['1', 'burned out']]) {
-    if (!new RegExp(`>${n}</span>\\s*<span class="tr-fig__label">${label}<`).test(figs)) {
-      throw new Error(`figure "${label}" is not ${n}`);
-    }
-  }
-});
-
-await test('the page keeps reading until the trail is exhausted, so the figures cover all of it', async () => {
-  // The defect this is under: figures computed over ONE window look exactly
-  // like figures computed over a life.
-  const p = bootThinkingPage({
-    pages: [
-      page([star(), star({ id: 12 })], { total: 3, offset: 0 }),
-      page([remnant()], { total: 3, offset: 2 }),
-    ],
-  });
-  await drain(20);
-  if (p.requests.filter((u) => /by-builder/.test(u)).length !== 2) throw new Error('stopped after one window');
-  if (!/>3<\/span>\s*<span class="tr-fig__label">filed</.test(p.figs())) throw new Error('lost the total');
-  if (!/>1<\/span>\s*<span class="tr-fig__label">burned out</.test(p.figs())) throw new Error('never counted the second window');
-  if (p.foot().hidden) throw new Error('the foot vanished once loading finished');
-});
-
-await test('a trail longer than the cap says so rather than quietly describing its newest slice', async () => {
-  const big = (offset) => page(
-    Array.from({ length: 100 }, (_, i) => star({ id: offset * 100 + i })),
-    { total: 900, offset: offset * 100 }
-  );
-  const p = bootThinkingPage({ pages: [big(0), big(1), big(2), big(3)] });
-  await drain(40);
-  const foot = p.foot().innerHTML;
-  if (!/newest 300/.test(foot)) throw new Error(`the cap is silent: ${foot}`);
-  if (p.requests.filter((u) => /by-builder/.test(u)).length !== 3) throw new Error('read past the cap');
-});
-
-// ---------------------------------------------------------------------------
-// The filter strip
-
-await test('the filter strip is built from the five states, in the shared order', async () => {
-  const p = bootThinkingPage({ pages: [page([star()])] });
+  assert.equal(p.S().gravityGoal, null, 'every word matches the goal and the page still lights nothing');
+  assert.match(p.gravity(), /nothing catches it — it will float in open space until something does/);
+  p.handlers.push((m, u) => (m === 'POST' && u.endsWith('/inbox') ? filed() : null));
+  p.submit();
   await drain();
-  const ids = p.tabs().ids;
-  const expected = ['everything', ...p.objects().ORDER];
-  if (ids.join(',') !== expected.join(',')) throw new Error(`strip is ${ids.join(',')}`);
+  assert.equal(bodyOf(p, 'POST', '/inbox').goal_id, undefined, 'and no goal is sent that the verdict did not name');
 });
 
-await test('choosing a filter shows only that object', async () => {
-  const p = bootThinkingPage({ pages: [page([star(), remnant()])] });
+await test('a refusal is the server\'s own sentence, and a stale answer never paints over a newer one', async () => {
+  const p = await boot({ mine: mine([]), versions: versions() });
+  p.handlers.push(gravityWorld({ outcome: 'refused', reason: 'protected_scope', status: null, goal: { id: 7, title: 'The well' }, version_id: null, refusal: { reason: 'The well is protected scope; a Metic must file into it.' } }));
+  p.type('first draft');
+  p.type('second draft');
+  assert.equal(p.timers.pending(), 1, 'the debounce is one timer, the newer keystroke replacing the older');
+  await p.timers.flush();
   await drain();
-  p.filter('remnant');
-  const html = p.rows();
-  if (!html.includes('It burned, then it went')) throw new Error('the remnant is missing');
-  if (html.includes('It ignited')) throw new Error('the filter let a star through');
+  assert.equal(p.requests.filter((r) => r.url.endsWith('/inbox/preview-landing')).length, 1, 'one preview for the draft as it stands');
+  assert.equal(p.gravity(), 'The well is protected scope; a Metic must file into it.');
+  p.type('');
+  assert.match(p.gravity(), /^gravity — the goal that catches it lights as you type; letting it float is a real answer$/, 'an empty line rests the sentence');
 });
 
-await test('a filter nobody has any of is hidden — but never "everything", and never the active one', async () => {
-  const p = bootThinkingPage({ pages: [page([star()])] });
+// ═══ the composer — full ═════════════════════════════════════════════════════
+
+await test('FULL: the five questions are the template\'s, one at a time, with skip and cancel, then one POST /inbox with the fields', async () => {
+  const p = await boot({ mine: mine([]), versions: versions() });
+  p.handlers.push((m, u) => (m === 'POST' && u.endsWith('/inbox') ? filed({ grade: 'full', completeness_score: 40 }) : null));
+  assert.equal(p.el('fullToggle').hidden, false);
+  p.click('fullToggle');
+  assert.equal(p.el('fullToggle').getAttribute('aria-pressed'), 'true');
+  assert.equal(p.el('thought').placeholder, 'release a thought — one line, then five questions');
+  p.type('a full thought');
+  p.submit();
+  assert.match(p.steps(), /<b>full idea · 1 of 5<\/b><span>What made you have the idea<\/span><span class="hint">~25 characters<\/span>/);
+  assert.equal(p.el('thought').placeholder, 'What made you have the idea');
+  assert.equal(p.el('fileGo').textContent, 'next');
+  p.type('because the room was a list and a list is not a sky');
+  p.submit();
+  assert.match(p.steps(), /2 of 5<\/b><span>Scope it as best as you can here/);
+  p.click('stepSkip');
+  assert.match(p.steps(), /3 of 5<\/b><span>What should an engineer or artist know prior to building/);
+  // cancel: the line comes back as a quick idea, nothing filed
+  p.click('stepCancel');
+  assert.equal(p.el('fullToggle').getAttribute('aria-pressed'), 'false');
+  assert.equal(p.el('thought').value, 'a full thought');
+  assert.equal(p.el('fullSteps').hidden, true);
+  assert.equal(bodyOf(p, 'POST', '/inbox'), undefined, 'cancel files nothing');
+  // and again, all the way through
+  p.click('fullToggle');
+  p.type('a full thought');
+  p.submit();
+  const answers = ['because the room was a list and a list is not a sky', '', 'read the template first', 'it is the ideator\'s home', 'the owner reads it daily'];
+  for (let n = 0; n < 5; n++) {
+    assert.match(p.steps(), new RegExp(`${n + 1} of 5`));
+    if (n === 4) assert.equal(p.el('fileGo').textContent, 'file the full idea');
+    p.type(answers[n]); p.submit();
+  }
   await drain();
-  const t = p.tabs();
-  if (t.hidden.remnant !== true) throw new Error('an empty filter is offered');
-  if (t.hidden.star === true) throw new Error('hid a filter with rows behind it');
-  if (t.hidden.everything === true) throw new Error('hid the way back to everything');
-  // Select an empty one, then re-render: the control a reader is looking
-  // through must not disappear out from under them.
-  p.filter('remnant');
-  if (t.hidden.remnant === true) throw new Error('hid the filter the reader is using');
+  same(bodyOf(p, 'POST', '/inbox'), {
+    title: 'a full thought', grade: 'full', template_key: 'base-v2',
+    field_values: { why_had: answers[0], scope: '', build_context: answers[2], fit: answers[3], success: answers[4] },
+  }, 'the hall form\'s full body — grade, template_key and every field by its key');
+  assert.match(p.receipt(), /filed as a full idea · <b>1 of 5<\/b> answers above the floor · nothing caught it · floating in open space/);
+  assert.equal(findIdea(p, 900).grade, 'full');
+  assert.equal(p.el('fullSteps').hidden, true, 'the steps close');
 });
 
-await test('an empty filter says which one is empty, and an empty trail invites a first thought', async () => {
-  const p = bootThinkingPage({ pages: [page([star()])] });
-  await drain();
-  p.filter('remnant');
-  if (!/Nothing of yours is burned out/.test(p.rows())) throw new Error('an empty filter said nothing useful');
-
-  const q = bootThinkingPage({ pages: [page([])] });
-  await drain();
-  if (!/File a thought/.test(q.rows())) throw new Error('an empty trail read as a failure');
+await test('Escape inside the questions cancels them; the questions never live in the page', async () => {
+  const p = await boot({ mine: mine([]) });
+  p.click('fullToggle');
+  p.type('a full thought');
+  p.submit();
+  assert.equal(p.el('fullSteps').hidden, false);
+  p.el('thought').fire('keydown', { key: 'Escape', preventDefault() {} });
+  assert.equal(p.el('fullSteps').hidden, true);
+  assert.equal(p.el('thought').value, 'a full thought');
+  const fs = await import('node:fs');
+  const src = fs.readFileSync('modules/hall-ui/public/sky-composer.js', 'utf8');
+  for (const key of ['why_had', 'build_context']) assert.ok(!new RegExp(`['"]${key}['"]`).test(src), `the composer carries no copy of the template field ${key}`);
 });
 
-// ---------------------------------------------------------------------------
-// It is the AUTHOR'S own view
-
-await test('the trail read is for the viewer\'s own id, taken from /me', async () => {
-  const p = bootThinkingPage({ pages: [page([star()])], viewer: { id: 4242 } });
-  await drain();
-  if (!p.requests.some((u) => u.includes('/inbox/by-builder/4242'))) {
-    throw new Error(`never read the viewer's own trail: ${p.requests.join(' ')}`);
-  }
+await test('without a template there is no full idea to file, so the switch is not offered', async () => {
+  const p = await boot({ mine: mine([]), template: null });
+  assert.equal(p.el('fullToggle').hidden, true);
+  same(p.SKY().fields(), []);
 });
 
-await test('the table carries five columns and no id column', async () => {
-  // The agreed shape, and the reason: on the one page where every row is yours,
-  // an id is a lookup key with nothing to look up.
-  const p = bootThinkingPage({ pages: [page([star()])] });
-  await drain();
-  const html = p.rows();
-  const heads = html.match(/<th[ >]/g) || [];
-  if (heads.length !== 5) throw new Error(`expected 5 columns, got ${heads.length}`);
-  if (/ledger__num/.test(html)) throw new Error('the id column came back');
-});
+// ═══ the nod ═════════════════════════════════════════════════════════════════
 
-await test('a title is escaped before it reaches the page', async () => {
-  const p = bootThinkingPage({ pages: [page([star({ title: '<script>x</script>' })])] });
+await test('THE NOD is drawn only for a holder of idea.triage, and runs the existing promote path', async () => {
+  const held = await boot({ mine: mine([waiting()]), sky: sky([well()]), viewer: { id: 95, permissions: { 'idea.triage': true } } });
+  assert.equal(held.S().canNod, true);
+  held.SKY().pick({ kind: 'idea', ref: findIdea(held, 14) }, false);
+  assert.match(held.panel(), /id="nodBtn"[^>]*>nod — make it claimable</);
+  held.handlers.push((m, u) => (m === 'POST' && u.endsWith('/tasks/9001/promote') ? { status: 200, ok: true, data: { ok: true } } : null));
+  held.click('nodBtn');
   await drain();
-  if (p.rows().includes('<script>')) throw new Error('rendered raw markup from a row');
+  assert.ok(held.requests.some((r) => r.method === 'POST' && r.url === '/api/bongos/tasks/9001/promote'), 'the nod is the routed task\'s promote');
+  assert.equal(held.el('nodBtn').textContent, 'nodded — a builder can claim it now');
+  assert.equal(findIdea(held, 14).awaiting, false);
+  assert.equal(findIdea(held, 14).state.awaitingNod, false);
+
+  const not = await boot({ mine: mine([waiting()]), sky: sky([well()]), viewer: { id: 95, permissions: { 'board.vote.cast': true } } });
+  assert.equal(not.S().canNod, false);
+  not.SKY().pick({ kind: 'idea', ref: findIdea(not, 14) }, false);
+  assert.doesNotMatch(not.panel(), /nodBtn/, 'no button for a builder who may not triage');
+  assert.match(not.panel(), /waiting for a nod/, 'the fact is still spoken');
 });
 
-await test('a failed trail read leaves an honest line, not a blank page', async () => {
-  const p = bootThinkingPage({ pages: [], trailStatus: 500 });
+await test('a nod the server refuses says why and stays pressable', async () => {
+  const p = await boot({ mine: mine([waiting()]), sky: sky([well()]), viewer: { id: 95, permissions: { 'idea.triage': true } } });
+  p.SKY().pick({ kind: 'idea', ref: findIdea(p, 14) }, false);
+  p.handlers.push((m, u) => (m === 'POST' && u.endsWith('/promote') ? { status: 409, ok: false, data: { error: { code: 'deps_not_shipped' } } } : null));
+  p.click('nodBtn');
   await drain();
-  if (!/Could not read your idea trail/.test(p.rows())) throw new Error('failed silently');
+  assert.equal(p.el('nodBtn').textContent, 'could not nod — deps not shipped');
+  assert.equal(p.el('nodBtn').disabled, false);
+  assert.equal(findIdea(p, 14).state.awaitingNod, true);
 });
 
+console.log('');
 summary();