@bongos/core 1.24.74 → 1.24.76

package/tests/government_agent_asks.mjs

@@ -169,6 +169,8 @@ async function call(method, p, body, source) {
   let json = null; try { json = await res.json(); } catch { /* none */ }
   return { ok: res.ok, status: res.status, data: json };
 }
+// What an agent opened or ran that showed a person is needed (task 1005120).
+const CHECKED = 'Opened the Plaid dashboard OAuth page: the Chase registration form is unsubmitted and needs the owner’s login.';
 // The helper's client: the CLI's request shape, against these routers.
 const client = { request: (method, p, opts = {}) => call(method, p, opts.body, 'cli') };
 
@@ -209,8 +211,8 @@ test('an agent that files prose is refused, rewrites with the helper, and files
   assert.match(passed.lines[0], /^✓ This ask has the shape\. As a person reads it:$/);
   assert.equal(passed.lines.slice(2).join('\n'), asks.cardText(OVERRIDE_CARD));
 
-  // 5. and files, stored against the blocker
-  const ok = await call('POST', '/blockers', rewrite, 'cli');
+  // 5. and files, stored against the blocker (with what the session checked: task 1005120)
+  const ok = await call('POST', '/blockers', { ...rewrite, checked: CHECKED }, 'cli');
   assert.equal(ok.status, 201, JSON.stringify(ok.data));
   assert.equal(store.get(`blockers:${ok.data.blocker.id}`).question, OVERRIDE_CARD.question);
   assert.equal(store.get(`blockers:${ok.data.blocker.id}`).detail, OVERRIDE.detail.trim(), 'the prose rides along');
@@ -231,6 +233,94 @@ test('every source an agent files with is held to it; the hall and the templated
   }
 });
 
+// ── A HIGHER BAR FOR FILING, AND A RE-CHECK BEFORE ASKING AGAIN (task 1005120) ──
+//
+// A project's blocker asked its owner to "apply to Plaid for OAuth" for days after the
+// project's own shipped work had found there was nothing to apply for. It was filed on an
+// inference (one bank worked, one did not) when the page that settled it was one click
+// away. So an agent filing by hand now says what it CHECKED that showed a person is
+// needed, and that sentence rides in the blocker's body where every later reader sees it.
+
+test('an agent files a blocker only with what it checked; the check rides in the body', async () => {
+  const before = filed.length;
+  const card = { title: OVERRIDE.title, source: 'task', source_ref: '1005120-a', ask: OVERRIDE_CARD };
+
+  // no check at all: refused, nothing filed, and told what to send
+  const bare = await call('POST', '/blockers', card, 'cli');
+  assert.equal(bare.status, 400);
+  assert.equal(bare.data.error.code, 'checked_required');
+  assert.match(bare.data.error.message, /what you opened or ran/);
+  assert.equal(filed.length, before, 'nothing was filed');
+
+  // a hunch is not a check: too short to name what was looked at
+  const hunch = await call('POST', '/blockers', { ...card, checked: 'probably needed' }, 'cli');
+  assert.equal(hunch.status, 400);
+  assert.equal(hunch.data.error.code, 'checked_required');
+  assert.equal(filed.length, before, 'nothing was filed');
+
+  // with the check: filed, and the check is written into the blocker for its next reader
+  const ok = await call('POST', '/blockers', { ...card, body_md: 'Long detail.', checked: CHECKED }, 'cli');
+  assert.equal(ok.status, 201, JSON.stringify(ok.data));
+  assert.match(ok.data.blocker.body_md, /^Long detail\.\n\n\*\*Checked before filing \(by @someone\):\*\* Opened the Plaid dashboard/,
+    'the check rides in the body, tracked back to the filer');
+});
+
+test('the check floor is exactly 30 characters, trimmed', async () => {
+  const card = { title: OVERRIDE.title, source: 'task', ask: OVERRIDE_CARD };
+  const short = await call('POST', '/blockers', { ...card, source_ref: '1005120-29', checked: `  ${'x'.repeat(29)}  ` }, 'cli');
+  assert.equal(short.status, 400, '29 characters (padding trimmed) is below the floor');
+  assert.equal(short.data.error.code, 'checked_required');
+  assert.equal(short.data.error.details.min_length, 30);
+  const exact = await call('POST', '/blockers', { ...card, source_ref: '1005120-30', checked: 'x'.repeat(30) }, 'cli');
+  assert.equal(exact.status, 201, '30 characters is enough');
+});
+
+test('a body that the check line pushes past the cap is refused, not silently grown', async () => {
+  const before = filed.length;
+  const r = await call('POST', '/blockers', { title: OVERRIDE.title, source: 'task', source_ref: '1005120-long', ask: OVERRIDE_CARD,
+    body_md: 'y'.repeat(api.LIMITS.DESCRIPTION), checked: CHECKED }, 'cli');
+  assert.equal(r.status, 400);
+  assert.equal(r.data.error.code, 'body_too_long');
+  assert.equal(filed.length, before, 'nothing was filed');
+});
+
+test('the hall and the templated scripts are not held to the check', async () => {
+  assert.equal((await call('POST', '/blockers', { title: 'A person typed this' }, 'web')).status, 201);
+  for (const source of blockersRoutes.TEMPLATED_SOURCES) {
+    const r = await call('POST', '/blockers', { title: `Checked-free ${source}`, source, source_ref: `c-${source}` }, 'cli');
+    assert.equal(r.status, 201, source);
+  }
+});
+
+// The re-check the daily review runs (scripts/bongos/blocker-recheck.js): the shipped work
+// since a blocker was filed that shares its subject — the case that went unread for days.
+const recheck = require(path.join(ROOT, 'scripts', 'bongos', 'blocker-recheck.js'));
+const PLAID = { id: '1', title: 'Chase and Bank of America need OAuth registration on toast\'s Plaid account',
+  body_md: 'Apply to Plaid for OAuth; approval takes weeks.', created_at: '2026-11-06T10:00:00Z' };
+
+test('the re-check finds the shipped work that answered a blocker, and only work after it', () => {
+  const tasks = [
+    { id: 7, short_name: 'plaid oauth check', status: 'shipped', shipped_at: '2026-11-07T12:00:00Z',
+      title: 'Check Plaid OAuth access for Chase', value_summary: 'Plaid already granted OAuth; Chase works, Bank of America needs one settings field.' },
+    { id: 5, status: 'shipped', shipped_at: '2026-11-05T12:00:00Z', title: 'Plaid OAuth groundwork for Chase', value_summary: '' },
+    { id: 8, status: 'active', shipped_at: null, title: 'Plaid OAuth for Chase', value_summary: '' },
+    { id: 9, status: 'shipped', shipped_at: '2026-11-08T12:00:00Z', title: 'Landing page spacing', value_summary: 'Tighter hero.' },
+  ];
+  const hits = recheck.relatedShipped(PLAID, tasks);
+  assert.deepEqual(hits.map((h) => h.id), [7], 'shipped after filing, on the subject; not before, not unshipped, not unrelated');
+  assert.ok(hits[0].shared.includes('plaid') && hits[0].shared.includes('oauth'), 'it says which words matched');
+  const lines = recheck.reportLines(PLAID, hits).join('\n');
+  assert.match(lines, /task 7 - plaid oauth check/, 'named as task N - name, never a bare number');
+  assert.match(lines, /read these before asking again/);
+});
+
+test('one shared word is not enough, and no match never claims the blocker still holds', () => {
+  const hits = recheck.relatedShipped(PLAID, [{ id: 3, status: 'shipped', shipped_at: '2026-11-08T00:00:00Z', title: 'Plaid logo swap', value_summary: '' }]);
+  assert.deepEqual(hits, []);
+  assert.match(recheck.reportLines(PLAID, hits).join('\n'), /not proof it still holds/);
+  assert.deepEqual(recheck.relatedShipped({ ...PLAID, created_at: 'not a date' }, []), [], 'an unreadable filing date re-checks nothing');
+});
+
 test('the helper checks locally, and says so, when the server cannot answer', async () => {
   const offline = { request: async () => { throw new Error('ECONNREFUSED'); } };
   const r = await askCli.check(writeCard('slop2.json', { question: 'Can you look at the deploy and tell me what you think about it all?' }), { client: offline });

package/tests/government_board_genesis_stage.mjs

@@ -303,3 +303,86 @@ test('the port carries the open and the status; the status route is pinned on th
   const pins = fs.readFileSync(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'), 'utf8');
   assert.match(pins, /'GET \/government\/board\/genesis-stages': 'perm:board\.vote\.cast'/);
 });
+
+// ── task 1005121: closing a stage is ONE call ────────────────────────────────
+
+const { closeGenesisStage } = require(path.join(GOV, 'genesis-close.js'));
+
+test('task 1005121: under Monarchy / BDFL closeGenesisStage opens, confirms and CLOSES in one call, and records HOW', async () => {
+  const votes = [];
+  let karma = 0;
+  const passed = await capturing('board.genesis_stage.passed', () => withDb({
+    getTaskStatuses: async () => [{ id: '101', status: 'shipped' }],
+    openBoardItem: async (args) => ({ ...stageItem(), constitution: MONARCHY, opened_by: args.openedBy }),
+    getBoardItemForVote: async () => stageItem(),
+    builderHoldsRankActive: async (id) => id === FOUNDER,
+    getActiveBuildersWithRank: async () => [member(FOUNDER, 'founder')],
+    getBoardItemAuthor: async (item) => item.opened_by,
+    insertBoardVote: async (row) => { const v = { ...row, voter_id: row.voterId, cast_via: row.castVia }; votes.push(v); return v; },
+    insertVoteKarma: async () => { karma += 1; },
+    getVotesForItem: async () => votes,
+    closeBoardItem: async ({ outcome }) => ({ ...stageItem(), closed_at: 'T', outcome }),
+    insertAuthorRatifyKarma: async () => true,
+  }, async () => {
+    const out = await closeGenesisStage({ stageKey: 'charter', taskIds: [101], closedBy: FOUNDER });
+    assert.equal(out.closed, true, 'the answer says CLOSED — no second request needed');
+    assert.equal(out.stage.key, 'charter');
+    assert.equal(out.cast.cast_via, 'stage_close');
+  }));
+  assert.equal(votes.length, 1);
+  assert.equal(votes[0].castVia, 'stage_close', 'the vote row records it was a confirm given by closing the stage');
+  assert.equal(votes[0].direction, 'yes');
+  assert.equal(karma, 0, 'the confirm decided nothing the ask had not — no vote karma');
+  assert.equal(passed.length, 1, 'the genesis home hears the pass');
+});
+
+test('task 1005121: where one yes cannot carry it, nothing is cast and the answer says what the sitting waits on', async () => {
+  let inserted = 0;
+  await withDb({
+    getTaskStatuses: async () => [{ id: '101', status: 'shipped' }],
+    openBoardItem: async () => ({ ...stageItem({ constitution: CONSENT }) }),
+    insertBoardVote: async () => { inserted += 1; return null; },
+    listLatestGenesisStageItems: async () => [stageItem({ constitution: CONSENT })],
+    getVotesForItems: async () => [],
+    getActiveBuildersWithRank: async () => [member(FOUNDER, 'founder'), member(AVERY, 'avery')],
+  }, async () => {
+    const out = await closeGenesisStage({ stageKey: 'charter', taskIds: [101], closedBy: FOUNDER });
+    assert.equal(out.closed, false);
+    assert.equal(out.opened, true);
+    assert.equal(out.item.id, '90');
+    assert.equal(out.status.state, 'sitting');
+    assert.deepEqual(out.status.waiting_on.map((m) => m.builder_id), [FOUNDER, AVERY]);
+    assert.ok(out.status.needs, 'the rule, in words');
+  });
+  assert.equal(inserted, 0, 'no vote is cast on anyone\'s behalf under a rule one person cannot carry');
+});
+
+test('task 1005121: a refusal from the gate passes straight through, nothing opened', async () => {
+  await withDb({
+    getTaskStatuses: async () => [{ id: '101', status: 'active' }],
+    openBoardItem: async () => { throw new Error('must not be reached'); },
+  }, async () => {
+    const out = await closeGenesisStage({ stageKey: 'charter', taskIds: [101], closedBy: FOUNDER });
+    assert.equal(out.closed, false);
+    assert.equal(out.reason, 'stage_tasks_unfinished');
+  });
+});
+
+test('task 1005121: cast_via stage_close is internal, genesis-only and yes-only; the vote route never passes it', async () => {
+  assert.equal((await castVote({ itemId: '90', voterId: FOUNDER, direction: 'yes', castVia: 'proxy' })).reason, 'bad_cast_via');
+  await withDb({
+    getBoardItemForVote: async () => ({ ...stageItem(), subject_type: 'full_idea' }),
+    insertBoardVote: async () => { throw new Error('must not be reached'); },
+  }, async () => {
+    assert.equal((await castVote({ itemId: '90', voterId: FOUNDER, direction: 'yes', castVia: 'stage_close' })).reason, 'bad_cast_via');
+  });
+  const routes = fs.readFileSync(path.join(GOV, 'routes', 'government.js'), 'utf8');
+  const call = routes.slice(routes.indexOf('const out = await board.castVote({'), routes.indexOf('const out = await board.castVote({') + 300);
+  assert.doesNotMatch(call, /castVia|cast_via/, 'a request can never claim its vote was a stage-close confirm');
+  assert.ok(routes.includes("closeGenesisStage: require('../genesis-close').closeGenesisStage"), 'the one-call close is on the port');
+  const sql = fs.readFileSync(path.join(GOV, 'migrations', 'government_038_vote_cast_via.sql'), 'utf8');
+  assert.match(sql, /cast_via text NOT NULL DEFAULT 'ballot'/, 'every vote before the column reads as a ballot');
+  assert.match(sql, /cast_via IN \('ballot', 'stage_close'\) AND \(cast_via = 'ballot' OR direction = 'yes'\)/);
+  const dbSrc = fs.readFileSync(path.join(GOV, 'db.js'), 'utf8');
+  assert.match(dbSrc, /INSERT INTO government_board_votes \(item_id, voter_id, direction, reason_md, section_key, cast_via\)/);
+});

package/tests/government_seed.mjs

@@ -54,6 +54,7 @@ const NON_GRANT_MIGRATIONS = new Set([
   'government_032_ask_flags.sql',                  // the reword list: matters a reader flagged as unclear (owner 2026-10-23)
   'government_036_access_holders.sql',             // who holds the keys outside Bongos + the access:<key> ask seat (task 1005000)
   'government_037_constitution.sql',               // the constitution in force as a durable row (task 1005140)
+  'government_038_vote_cast_via.sql',               // HOW a vote was cast: a ballot, or a stage-close confirm (task 1005121)
 ]);
 
 // Permission keys RENAMED after the grant migrations that first granted them.

package/tests/home_idea_box.mjs

@@ -0,0 +1,178 @@
+// tests/home_idea_box.mjs — the ideator's Home opens on the idea box (task 1005078,
+// goal 1000095, the owner's work-first hall).
+//
+// Runs modules/hall-ui/public/home-idea-box.js with the city's three files in a real
+// page, the reads stubbed by the hall-preview fixture: the box shows only in Ideating
+// and sits above the sky; it is ONE box and a button (owner, 2026-11-05); filing is
+// POST /inbox with { title, body_md: '', kind: 'feature' }; an empty line files
+// nothing; a refused filing keeps the words and says why; a filed one clears and links
+// to Your thinking; the box shows in Ideating even when the sky could not be read; at
+// phone width nothing scrolls sideways. The pure halves run in node. Skips the browser
+// cases where no system Edge or Chrome is installed.
+//
+// Run:  node --test tests/home_idea_box.mjs
+import assert from 'node:assert/strict';
+import { test, after } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const lib = require(path.join(ROOT, 'modules', 'ui-design', 'kit', 'lib.js'));
+const pub = (f) => fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', f), 'utf8');
+const Box = require(path.join(ROOT, 'modules', 'hall-ui', 'public', 'home-idea-box.js'));
+const CSS = pub('style.css') + pub('home-city.css') + pub('home-idea-box.css');
+const CITY = fs.readFileSync(path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', 'home__city.json'), 'utf8');
+const FILED = fs.readFileSync(path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', 'inbox.post.json'), 'utf8');
+
+let browser = null;
+try { browser = await lib.launchBrowser(); } catch (e) { if (!(e instanceof lib.NoBrowserError)) throw e; }
+after(() => browser && browser.close());
+const skip = !browser && 'no system Edge or Chrome';
+
+const stubs = (craft, { city = true, refuse = false } = {}) => `
+  window.__asked = [];
+  window.BongosClient = { createClient: () => ({ request: async (m, p, o) => {
+    window.__asked.push(m + ' ' + p + (o && o.body ? ' ' + JSON.stringify(o.body) : ''));
+    if (p.startsWith('/api/bongos/home/city')) return ${city} ? { ok: true, status: 200, data: ${CITY} } : { ok: false, status: 500, data: null };
+    if (m === 'POST' && p === '/api/bongos/inbox') return ${refuse}
+      ? { ok: false, status: 422, data: { error: { code: 'idea_rejected', details: { reason: 'the title is a duplicate' } } } }
+      : { ok: true, status: 201, data: ${FILED} };
+    return { ok: false, status: 404, data: null };
+  } }) };
+  window.OTBCraftMode = { iconHtml: () => '', choose: () => {}, current: () => document.documentElement.dataset.craft || null };
+  window.OTB = { contributeHallWidget(w) { window.__widget = w; } };`;
+
+async function boot({ craft = 'ideating', width = 1440, ...opts } = {}) {
+  const ctx = await browser.newContext({ viewport: { width, height: 900 }, reducedMotion: 'reduce' });
+  const page = await ctx.newPage();
+  await page.setContent(`<!doctype html><html data-theme="dark"${craft ? ` data-craft="${craft}"` : ''}><head><style>${CSS}</style></head><body><section id="welcome-scroll" class="scroll">setup guide</section><section id="home-city" class="scroll home-city" hidden></section></body></html>`);
+  await page.addScriptTag({ content: stubs(craft, opts) });
+  for (const f of ['home-idea-box.js', 'city-draw.js', 'home-city-draw.js', 'home-city.js']) await page.addScriptTag({ content: pub(f) });
+  await page.evaluate(() => window.__widget.mount(document.getElementById('home-city')));
+  await page.waitForFunction(() => window.__asked.some((a) => a.includes('/home/city')));
+  return { ctx, page };
+}
+
+test('the pure halves: the first line is the title and the rest the details; a refusal says why', () => {
+  assert.deepEqual(Box.body('  a new idea  '), { title: 'a new idea', body_md: '', kind: 'feature' });
+  assert.deepEqual(Box.body('\n  the title\r\nline two\n\nline three\n'), { title: 'the title', body_md: 'line two\n\nline three', kind: 'feature' });
+  assert.deepEqual(Box.body('   \n  '), { title: '', body_md: '', kind: 'feature' });
+  assert.match(Box.explain({ status: 422, data: { error: { details: { reason: 'too short' } } } }), /^Not filed: too short\. Your idea is still here\.$/);
+  assert.match(Box.explain({ status: 401, data: null }), /session may have expired/);
+  assert.match(Box.explain(null), /Nothing was saved/);
+});
+
+test('in Ideating the box is the first thing in the section, ONE box and a button, and the setup guide is hidden', { skip }, async () => {
+  const { ctx, page } = await boot();
+  await page.waitForFunction(() => document.querySelector('.hc-svg').childElementCount > 0);
+  const s = await page.evaluate(() => {
+    const host = document.getElementById('home-city'), box = host.querySelector('.hib');
+    return {
+      first: host.firstElementChild === box, shown: !box.hidden && !host.hidden,
+      fields: box.querySelectorAll('input, textarea, select').length,
+      keys: document.getElementById(box.querySelector('.hib-title').getAttribute('aria-describedby')).textContent,
+      buttons: [...box.querySelectorAll('button')].map((b) => b.textContent),
+      label: box.querySelector('label[for="hib-title"]').textContent,
+      boxAboveSky: box.getBoundingClientRect().bottom <= host.querySelector('.hc-svg').getBoundingClientRect().top,
+      guide: getComputedStyle(document.getElementById('welcome-scroll')).display,
+    };
+  });
+  await ctx.close();
+  assert.equal(s.first, true);
+  assert.equal(s.shown, true);
+  assert.equal(s.fields, 1, 'one box (owner, 2026-11-05)');
+  assert.equal(s.keys, 'Enter files the idea. Shift and Enter starts a new line.');
+  assert.deepEqual(s.buttons, ['File idea']);
+  assert.equal(s.label, 'What is your idea?');
+  assert.equal(s.boxAboveSky, true);
+  assert.equal(s.guide, 'none');
+});
+
+test('in any other craft, or none, there is no box and the setup guide shows', { skip }, async () => {
+  for (const craft of ['building', null]) {
+    const { ctx, page } = await boot({ craft });
+    const s = await page.evaluate(() => ({ hidden: document.querySelector('.hib').hidden, guide: getComputedStyle(document.getElementById('welcome-scroll')).display }));
+    await ctx.close();
+    assert.equal(s.hidden, true, String(craft));
+    assert.equal(s.guide, 'block', String(craft));
+  }
+});
+
+test('filing posts the line as a feature idea, clears the box and links to Your thinking; an empty line files nothing', { skip }, async () => {
+  const { ctx, page } = await boot();
+  await page.click('.hib-file');
+  const empty = await page.evaluate(() => ({ said: document.querySelector('.hib-said').textContent, posts: window.__asked.filter((a) => a.startsWith('POST')).length }));
+  await page.fill('.hib-title', '  A place to type an idea  ');
+  await page.press('.hib-title', 'Enter');
+  await page.waitForFunction(() => document.querySelector('.hib-said a'));
+  const s = await page.evaluate(() => ({
+    posts: window.__asked.filter((a) => a.startsWith('POST')),
+    value: document.querySelector('.hib-title').value,
+    said: document.querySelector('.hib-said').textContent,
+    href: document.querySelector('.hib-said a').getAttribute('href'),
+    err: document.querySelector('.hib-said').classList.contains('hib-said--err'),
+  }));
+  await ctx.close();
+  assert.equal(empty.posts, 0);
+  assert.equal(empty.said, 'Type your idea first.');
+  assert.deepEqual(s.posts, ['POST /api/bongos/inbox {"title":"A place to type an idea","body_md":"","kind":"feature"}']);
+  assert.equal(s.value, '');
+  assert.match(s.said, /^Filed\. It waits for the next triage\. See it in Your thinking$/);
+  assert.equal(s.href, '/thinking');
+  assert.equal(s.err, false);
+});
+
+test('Shift+Enter is a new line and the box grows; Enter then files the first line as the title, the rest as details', { skip }, async () => {
+  const { ctx, page } = await boot();
+  await page.click('.hib-title');
+  const h0 = await page.evaluate(() => document.querySelector('.hib-title').getBoundingClientRect().height);
+  await page.keyboard.type('The title');
+  await page.keyboard.press('Shift+Enter');
+  await page.keyboard.type('more about it');
+  await page.keyboard.press('Shift+Enter');
+  await page.keyboard.type('and more');
+  const before = await page.evaluate(() => ({ value: document.querySelector('.hib-title').value, h: document.querySelector('.hib-title').getBoundingClientRect().height, posts: window.__asked.filter((a) => a.startsWith('POST')).length }));
+  await page.keyboard.press('Enter');
+  await page.waitForFunction(() => document.querySelector('.hib-said a'));
+  const after = await page.evaluate(() => ({ posts: window.__asked.filter((a) => a.startsWith('POST')), h: document.querySelector('.hib-title').getBoundingClientRect().height }));
+  await ctx.close();
+  assert.equal(before.value, 'The title\nmore about it\nand more');
+  assert.equal(before.posts, 0, 'Shift+Enter never files');
+  assert.ok(before.h > h0, `the box grew (${h0} -> ${before.h})`);
+  assert.deepEqual(after.posts, ['POST /api/bongos/inbox {"title":"The title","body_md":"more about it\\nand more","kind":"feature"}']);
+  assert.equal(after.h, h0, 'and shrinks back once filed');
+});
+
+test('a refused filing keeps the words and says why', { skip }, async () => {
+  const { ctx, page } = await boot({ refuse: true });
+  await page.fill('.hib-title', 'A duplicate');
+  await page.click('.hib-file');
+  await page.waitForFunction(() => document.querySelector('.hib-said').textContent);
+  const s = await page.evaluate(() => ({ value: document.querySelector('.hib-title').value, said: document.querySelector('.hib-said').textContent, err: document.querySelector('.hib-said').classList.contains('hib-said--err'), link: !!document.querySelector('.hib-said a') }));
+  await ctx.close();
+  assert.equal(s.value, 'A duplicate');
+  assert.equal(s.said, 'Not filed: the title is a duplicate. Your idea is still here.');
+  assert.equal(s.err, true);
+  assert.equal(s.link, false);
+});
+
+test('the box shows in Ideating even when the sky could not be read', { skip }, async () => {
+  const { ctx, page } = await boot({ city: false });
+  const s = await page.evaluate(() => ({ host: document.getElementById('home-city').hidden, box: document.querySelector('.hib').hidden }));
+  await ctx.close();
+  assert.deepEqual(s, { host: false, box: false });
+});
+
+test('at phone width the box stacks, every control clears 24px, and nothing scrolls sideways', { skip }, async () => {
+  const { ctx, page } = await boot({ width: 320 });
+  const s = await page.evaluate(() => ({
+    over: document.documentElement.scrollWidth - document.documentElement.clientWidth,
+    sizes: [...document.querySelectorAll('.hib-title, .hib-file')].map((e) => { const r = e.getBoundingClientRect(); return [Math.round(r.width), Math.round(r.height)]; }),
+  }));
+  await ctx.close();
+  assert.equal(s.over, 0);
+  for (const [w, h] of s.sizes) assert.ok(w >= 24 && h >= 24, `${w}x${h}`);
+});