@bongos/core 1.24.75 → 1.24.77

package/tests/autonomy_gauge.mjs

@@ -343,6 +343,49 @@ test('evaluate on a missing file is UNKNOWN — the CLI never defaults to go', (
   });
 });
 
+// ── a device with no gauge at all (task 1005095) ────────────────────────────────
+test('a caller that asks for it gets GO on a device with NO gauge file, marked as that kind of go', () => {
+  const d = decideCapacity({ gauge: null, now: NOW, config: { absentMeansGo: true } });
+  assert.equal(d.go, true, 'a PC set up five minutes ago has no gauge and never will; it must still start work');
+  assert.equal(d.unknown, false);
+  assert.equal(d.absent, true);
+  assert.equal(d.derived, true, 'so the log never mistakes it for a measured reading');
+  assert.match(d.reason, /no usage gauge on this device/);
+});
+
+test('absentMeansGo opens NOTHING but the missing file — every reading that cannot be vouched for still holds', () => {
+  for (const [label, g] of [
+    ['not an object', 'nonsense'],
+    ['no written_at', { five_hour: { used_percentage: 1, resets_at: NOW + HOUR } }],
+    ['neither window', { written_at: NOW }],
+    ['unparseable numbers', { written_at: NOW, five_hour: { used_percentage: 'lots', resets_at: 'soon' } }],
+    ['dated in the future', { ...gaugeAt(0), written_at: NOW + 600 }],
+    ['aged out inside a window still running', gaugeAt(4 * HOUR)],
+  ]) {
+    const d = decideCapacity({ gauge: g, now: NOW, config: { absentMeansGo: true } });
+    assert.equal(d.go, false, `${label} must still hold`);
+    assert.equal(d.unknown, true, `${label} must still read as unknown`);
+  }
+  // …and a real reading that says stop is obeyed exactly as before.
+  const spent = decideCapacity({ gauge: gaugeAt(30, { five_hour: { used_percentage: 99, resets_at: NOW + HOUR } }), now: NOW, config: { absentMeansGo: true } });
+  assert.equal(spent.go, false);
+  assert.equal(spent.unknown, false);
+});
+
+test('the supervisor passes absentMeansGo through evaluate; the bare CLI call does not', () => {
+  inTempGauge(() => {
+    const now = Math.floor(Date.now() / 1000);
+    assert.equal(cli.evaluate(now, { absentMeansGo: true }).decision.go, true);
+    assert.equal(cli.evaluate(now).decision.go, false);
+    // A file that is THERE but torn is a bad reading, not a missing gauge.
+    fs.mkdirSync(path.dirname(cli.gaugePath()), { recursive: true });
+    fs.writeFileSync(cli.gaugePath(), '{"written_at": 17');
+    const torn = cli.evaluate(now, { absentMeansGo: true }).decision;
+    assert.equal(torn.go, false, 'a half-written gauge file must hold, even for the supervisor');
+    assert.equal(torn.unknown, true);
+  });
+});
+
 // --- a reading whose window has RESET is retired, not stale (task 1004178) ---
 //
 // An unattended host cannot refresh the gauge (see modules/autonomy/CLAUDE.md

package/tests/cli_sessions.mjs

@@ -142,6 +142,22 @@ test('the store anchor is FIXED, not brand-derived — that is the whole fix', (
   assert.ok(!/configHome|configDirName|safeBrand/.test(fn), `sessionStoreDir must not read the brand:\n${fn}`);
 });
 
+test('BONGOS_CONFIG_ROOT moves the store with it, still at the fixed dir name (task 1005095)', () => {
+  // An Autobongos runner keeps its own login under its own root. The store must
+  // follow that root, or the runner would file its login into the builder's store.
+  const root = path.join(os.tmpdir(), 'cfg-root-probe');
+  const prev = process.env.BONGOS_CONFIG_ROOT;
+  process.env.BONGOS_CONFIG_ROOT = root;
+  try {
+    assert.equal(lib.sessionStoreDir(), path.join(path.resolve(root), ic.FALLBACK_DIR, 'instances'));
+    assert.equal(ic.configHome(), path.join(path.resolve(root), ic.configDirName()));
+    assert.ok(ic.configReadDirs().every((d) => d.startsWith(path.resolve(root) + path.sep)), 'no legacy dir under the home is read as a fallback');
+  } finally {
+    if (prev === undefined) delete process.env.BONGOS_CONFIG_ROOT; else process.env.BONGOS_CONFIG_ROOT = prev;
+  }
+  assert.equal(lib.sessionStoreDir(), path.join(os.homedir(), '.config', ic.FALLBACK_DIR, 'instances'), 'and back where it was without it');
+});
+
 // ── 1b. The sandbox is really a sandbox ─────────────────────────────────────────────────────
 //
 // These guard the guard (task 1003760). Every test below writes to a session store, so if

package/tests/deploy_page_projects.mjs

@@ -238,6 +238,55 @@ test('a box with nothing newer offers no button', async () => {
   const b = boot({ controlPlane: preview('1', 'cloudbongos', { behind: false, recommended_version: null }) });
   await b.settle();
   assert.match(b.panel(), /There is nothing to deploy/);
+  assert.doesNotMatch(b.panel(), /id="dp-preview-1"/);
+});
+
+// ---- the plain status line and the deploy-now button (task 1005012) ----------------
+//
+// The owner opened this page to put merged work live and found neither a button nor a
+// sentence: the box was already on the newest version, which it had reached by itself on
+// its update rule, and the page said only "nothing to deploy". So the box now LEADS with
+// one plain line — up to date or not — and says how the next version arrives.
+
+test('up to date: says so in words, names the version, and says the next one arrives on its own', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { behind: false, recommended_version: null, served_version: '1.24.1', update_channel: 'minor' }) });
+  await b.settle();
+  const html = b.panel();
+  assert.match(html, /dp-status dp-status--ok/, 'a status line, in the ok tone');
+  assert.match(html, /<strong>Up to date\.<\/strong>/);
+  assert.match(html, /1\.24\.1/);
+  assert.match(html, /merged work inside core 1\.24\.1 is live/);
+  assert.match(html, /arrives on its own/, 'the update rule moves it, so nothing needs pressing');
+  assert.match(html, /not live until a published version carries it/, 'and merged work after it is still waiting');
+});
+
+test('up to date on Stay put: says a newer version waits for a person, not that it arrives', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { behind: false, recommended_version: null, update_channel: 'pinned' }) });
+  await b.settle();
+  const html = b.panel();
+  assert.match(html, /<strong>Up to date\.<\/strong>/);
+  assert.doesNotMatch(html, /arrives on its own/);
+  assert.match(html, /waits until you change the update rule/);
+});
+
+test('behind: a plain "not up to date" line and ONE primary deploy-now button', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { update_channel: 'patch' }) });
+  await b.settle();
+  const html = b.panel();
+  assert.match(html, /dp-status dp-status--behind/);
+  assert.match(html, /<strong>Not up to date\.<\/strong> Core <strong>1\.19\.871<\/strong> is published; this project still runs 1\.19\.800\./);
+  assert.match(html, /class="btn btn--primary" id="dp-preview-1">Deploy core 1\.19\.871 now<\/button>/);
+  assert.doesNotMatch(html, /See what would change/, 'the old two-word step label is gone');
+  assert.equal((html.match(/btn--primary/g) || []).length, 1, 'exactly one primary action');
+});
+
+test('the deploy-now button still leaves going live to a person: it opens the confirm, it moves nothing', async () => {
+  const b = boot();
+  await b.settle();
+  b.els.get('dp-preview-1')._on.click();
+  await b.settle();
+  assert.ok(b.posts.every((p) => p.body && p.body.dry_run === true), 'only the dry-run check is asked for');
+  assert.match(b.panel(), /id="dp-confirm-1"/, 'the person confirms the move themselves');
 });
 
 test('a box that did not answer is never rendered as up to date', async () => {

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/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}`);
+});