@bongos/core 1.19.1007 → 1.19.1009

package/tests/hall_record_world.mjs

@@ -105,9 +105,30 @@ test('the shell owns BOTH halves of the rail, measured from one value', () => {
     'the panel is placed from --topbar-h; ideas.css hand-copied it as 6.5rem and nothing kept the two in step');
 });
 
-test('the ideas composer OPTS IN from its markup', () => {
-  assert.match(ideasHtml, /class="app-content app-content--railed"/, 'the content column reserves the room');
-  assert.match(ideasHtml, /class="fi-meter app-rail"/, 'and the meter takes the shell\'s rail frame');
+test('the ideas composer OPTS IN, and since the fold it opts in WITH THE METER', () => {
+  // The rule this case has always guarded is that a page takes the rail from the
+  // shell's own opt-in and never reaches into shell layout from its own sheet.
+  // Task 1004087 (spec R04) folded the Full Idea form away by default, so the
+  // opt-in moved from the markup to the moment the meter appears: the reserve
+  // narrows the one-line composer at every wide width, and holding it open for a
+  // panel nobody asked for is the same defect as hand-copying its offset was.
+  const ideasJs = read('ideas.js');
+  assert.match(ideasHtml, /class="fi-meter app-rail"/, 'the meter still takes the shell\'s rail frame');
+  // Matched on a class ATTRIBUTE, not anywhere in the file: the markup carries a
+  // comment naming the class to say why it is not there, and a bare substring
+  // search cannot tell an explanation from the thing it explains.
+  assert.doesNotMatch(ideasHtml, /class="[^"]*app-content--railed/,
+    'and the reserve is no longer held open in the markup');
+  assert.match(ideasJs, /classList\.add\('app-content--railed'\)/, 'ideas.js grants the reserve');
+  assert.match(ideasJs, /classList\.remove\('app-content--railed'\)/,
+    'and hands it back — a reserve only ever added is a static one written the long way');
+  // The half that would otherwise rot: the page must still not style shell
+  // layout. Read with the comments STRIPPED — the sheet's header explains at
+  // length which override it used to carry and where that override went, and a
+  // check that cannot tell a rule from the note about it fails on the note.
+  const ideasRules = ideasCss.replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.doesNotMatch(ideasRules, /(^|[\s,>])\.app-(content|rail)\b/m,
+    'ideas.css says what the meter LOOKS like, never where the shell puts it');
 });
 
 // ---- 2. the button vocabulary that had no rule -----------------------------

package/tests/idea_spark_hall.mjs

@@ -65,6 +65,13 @@ function boot({
   // `{ outcome: null }`, which is the server saying "nothing to state yet"; the
   // line must go quiet for both, and there is a case below for each.
   landing = undefined,
+  // task 1004087 (spec R04) — the #full deep link, which auto-opens the folded
+  // Full Idea form. Part of boot() because the fold reads it once, at boot.
+  hash = '',
+  // task 1004087: a template read that FAILS. bootFullIdea returns early, so no
+  // form and no meter — distinct from "folded", and the distinction is the
+  // reason the meter follows formRendered rather than the boot flag.
+  templateOk = true,
   // OUT-OF-ORDER READS (task 1004108). Names of fakes whose answers are PARKED
   // instead of returned: the call is recorded and its response computed at once,
   // but the caller's `await` does not resolve until the test releases it. That is
@@ -79,8 +86,14 @@ function boot({
   const makeEl = () => ({
     dataset: {}, style: {}, textContent: '', value: '', hidden: false, disabled: false,
     readOnly: false, tabIndex: 0, _html: '', _handlers: {},
-    classList: { add() {}, remove() {} },
-    setAttribute() {}, getAttribute() { return null; },
+    // task 1004087: attributes and classes are RECORDED rather than swallowed.
+    // The fold's two tells are an aria-expanded on the toggle and the rail class
+    // on the content wrapper, and a no-op stub agrees with every implementation
+    // including a broken one.
+    _attrs: {}, _classes: new Set(),
+    get classList() { const s = this._classes; return { add: (c) => s.add(c), remove: (c) => s.delete(c), contains: (c) => s.has(c) }; },
+    setAttribute(k, v) { this._attrs[String(k)] = String(v); },
+    getAttribute(k) { const v = this._attrs[String(k)]; return v === undefined ? null : v; },
     addEventListener(t, fn) { this._handlers[t] = fn; },
     querySelector() { return makeEl(); }, querySelectorAll() { return []; }, appendChild() {},
     set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
@@ -114,7 +127,10 @@ function boot({
 
   const client = {
     inbox: {
-      getInboxTemplate: async () => ({ status: 200, ok: true, data: { template: TEMPLATE } }),
+      // RECORDED (task 1004087): the fold's cost claim is 'the template is not
+      // read until someone asks, and is read once'. A fake that does not count
+      // its calls cannot tell either half from a page that reads it every time.
+      getInboxTemplate: async () => { calls.push(['template', null]); return templateOk ? { status: 200, ok: true, data: { template: TEMPLATE } } : { status: 500, ok: false, data: null }; },
       getInboxSparks: async () => { calls.push(['sparks', null]); return { status: 200, ok: true, data: { sparks, count: count == null ? sparks.length : count } }; },
       getInboxId: async (a) => { calls.push(['idea', a]); return { status: ideaOk ? 200 : 404, ok: ideaOk, data: ideaOk ? { idea } : null }; },
       postInboxScore: async (a) => { calls.push(['score', a]); return { status: 200, ok: true, data: { score: 60, fields: TEMPLATE.fields.map((f) => ({ key: f.key, substance: 24, floor: 40, ratio: 0.6 })) } }; },
@@ -186,7 +202,7 @@ function boot({
       setItem: (k, v) => { store[k] = String(v); },
       removeItem: (k) => { delete store[k]; },
     },
-    location: { hostname: 'builders.cloudbongos.com', pathname: '/ideas', search, assign() {} },
+    location: { hostname: 'builders.cloudbongos.com', pathname: '/ideas', search, hash, assign() {} },
     addEventListener() {},
   };
 
@@ -200,6 +216,10 @@ function boot({
     calls, toasts, store, el, deferred,
     queueHtml: () => el('fi-queue').innerHTML,
     fill: () => { for (const f of TEMPLATE.fields) el(`fi-f-${f.key}`).value = `an answer for ${f.key} long enough to count`; },
+    // task 1004087 (spec R04) — the one press that unfolds the Full Idea form.
+    // Every case below that reaches the five questions now goes through it,
+    // because a real builder does too.
+    openFull: async () => { el('fi-open')._handlers.click(); await settle(); await settle(); },
     submit: () => el('fi-form')._handlers.submit({ preventDefault() {} }),
     submitQuick: () => el('fq-form')._handlers.submit({ preventDefault() {} }),
   };
@@ -345,6 +365,10 @@ await test('the plain composer is unaffected — develop mode is never entered',
   // tests/idea_hall_composer.mjs pins over the HTML source; what matters at
   // runtime is that nothing reveals it, and the tell is that no idea was fetched.
   assert.ok(!r.calls.some((c) => c[0] === 'idea'), 'no idea is loaded without ?develop=');
+  // task 1004087 (spec R04): in plain mode the five questions are FOLDED, so a
+  // builder who wants them presses for them. That press is the whole cost of
+  // decision 18, and it is spent here rather than assumed away.
+  await r.openFull();
   assert.equal(r.el('fi-title').readOnly, false, 'the title stays editable');
   r.el('fi-title').value = 'a new idea';
   r.fill();
@@ -789,5 +813,172 @@ await test('a slow preview answering after a faster one never repaints the stale
 // page rather than pin it. That is a production bug to file, not a test to
 // write, and the harness is now able to reach it the day it is fixed.
 
+
+// --- the fold (task 1004087 / spec R04, decision 18) ----------------------
+//
+// Decision 18 put the five questions on the same surface as the one-line
+// composer and called it the riskiest decision in the spec, because a spark's
+// whole value is that it costs nothing to have. The cases below are what
+// "folded" has to mean for that to stay true, and each one is written as a
+// property of the FAST path, not of the form: a page that opened the five
+// questions eagerly would pass a test that only asked "is the form present".
+
+await test('the fast path costs nothing: no template read, no scorer, no rail', async () => {
+  const r = boot();
+  await settle(); await settle();
+  assert.ok(!r.calls.some((c) => c[0] === 'template'), 'the template is not read at all until someone asks for the questions');
+  assert.ok(!r.calls.some((c) => c[0] === 'score'), 'nothing is scored before anyone asks to write');
+  assert.ok(!r.el('fi-fields').innerHTML.includes(TEMPLATE.fields[0].label),
+    'and the five questions are not rendered — the template read has not happened at all');
+  assert.equal(r.el('fi-form').hidden, true, 'the five questions are folded away');
+  assert.equal(r.el('fi-meter').hidden, true, 'and so is their readout');
+  assert.equal(r.el('fi-content')._classes.has('app-content--railed'), false,
+    'the rail reserve is NOT held open — that reserve narrows the one-line form at every wide width');
+  assert.equal(r.el('fi-open').getAttribute('aria-expanded'), 'false');
+  // The quick composer is live at the same moment, so the fold costs the fast
+  // path nothing in readiness either.
+  assert.equal(typeof r.el('fq-form')._handlers.submit, 'function', 'the one-line path is already submittable');
+});
+
+await test('one press unfolds it, and only then does the page fetch the template', async () => {
+  const r = boot();
+  await settle(); await settle();
+  await r.openFull();
+  assert.equal(r.el('fi-form').hidden, false);
+  assert.equal(r.el('fi-meter').hidden, false, 'the meter arrives with the form it reads');
+  assert.equal(r.el('fi-content')._classes.has('app-content--railed'), true, 'and the rail reserve arrives with the meter');
+  assert.equal(r.el('fi-open').getAttribute('aria-expanded'), 'true');
+  assert.ok(r.el('fi-fields').innerHTML.includes(TEMPLATE.fields[0].label), 'the five questions rendered from the template read');
+});
+
+await test('putting them away hides them and KEEPS the draft — it is not a discard', async () => {
+  const r = boot();
+  await settle(); await settle();
+  await r.openFull();
+  r.el('fi-title').value = 'half a thought';
+  r.fill();
+  r.el(`fi-f-${TEMPLATE.fields[0].key}`)._handlers.input();
+  await new Promise((res) => setTimeout(res, 700));
+  const saved = JSON.stringify(r.store);
+  r.el('fi-open')._handlers.click();
+  await settle();
+  assert.equal(r.el('fi-form').hidden, true, 'the form folds away again');
+  assert.equal(r.el('fi-content')._classes.has('app-content--railed'), false, 'and hands the width back');
+  assert.equal(r.el('fi-meter').hidden, true);
+  assert.equal(JSON.stringify(r.store), saved, 'nothing written by the draft was thrown away');
+});
+
+await test('the template is read ONCE however many times it is folded', async () => {
+  const r = boot();
+  await settle(); await settle();
+  await r.openFull();
+  r.el('fi-open')._handlers.click(); await settle();
+  await r.openFull();
+  // The template fake does not push to `calls`, so the tell is the render: a
+  // second boot would replace the rendered fields with the loading line first.
+  assert.equal(r.calls.filter((c) => c[0] === 'template').length, 1,
+    'the template is fetched on the FIRST open and never again — a re-boot per open would also re-wire every listener');
+  assert.ok(r.el('fi-fields').innerHTML.includes(TEMPLATE.fields[0].label), 'and the form survives a fold and an unfold');
+});
+
+// --- the three things a shut form would strand ----------------------------
+
+await test('?develop= opens it without being asked — the whole request was "develop this"', async () => {
+  const r = boot({ search: '?develop=77' });
+  await settle(); await settle();
+  assert.equal(r.el('fi-form').hidden, false, 'a develop link that landed on a folded form would be a dead link');
+  assert.equal(r.el('fi-develop').hidden, false);
+  assert.equal(r.el('fi-open').getAttribute('aria-expanded'), 'true');
+});
+
+await test('the #full deep link opens it — /idea/:id sends people here by that name', async () => {
+  const r = boot({ hash: '#full' });
+  await settle(); await settle();
+  assert.equal(r.el('fi-form').hidden, false);
+  assert.equal(r.el('fi-content')._classes.has('app-content--railed'), true);
+});
+
+await test('a saved draft opens it — half-written work is never left behind a press', async () => {
+  const r = boot({ store: { 'hall-full-idea-draft': JSON.stringify({ title: 'a thought from yesterday', values: {} }) } });
+  await settle(); await settle();
+  assert.equal(r.el('fi-form').hidden, false, 'a draft nobody can see is a draft that was lost');
+  assert.equal(r.el('fi-title').value, 'a thought from yesterday', 'and it is restored, not merely revealed');
+});
+
+await test('an UNRELATED stored key does not open it — only a real draft does', async () => {
+  const r = boot({ store: { 'hall-full-idea-draft:develop:99': JSON.stringify({ title: 'someone else', values: {} }) } });
+  await settle(); await settle();
+  assert.equal(r.el('fi-form').hidden, true, 'a develop-scoped draft is not this page\'s draft');
+});
+
+// --- the markup half ------------------------------------------------------
+//
+// The stub DOM does not parse ideas.html, so every `hidden` above is the one
+// ideas.js set at runtime. These two read the real file, for the same reason
+// the receipts and gravity cases in this suite do: the runtime assertions
+// would all still pass against a page that shipped the form open.
+
+await test('ideas.html ships the form hidden and the fast path FIRST', async () => {
+  const html = fs.readFileSync(path.join(HALL, 'ideas.html'), 'utf8');
+  assert.match(html, /<form id="fi-form" novalidate hidden>/, 'the five questions ship folded');
+  assert.match(html, /id="fi-open"[^>]*aria-expanded="false"/, 'and the toggle ships saying so');
+  assert.ok(html.indexOf('id="fq-compose-scroll"') < html.indexOf('id="fi-compose-scroll"'),
+    'the one-line composer comes before the five questions in the DOM, not merely on screen');
+  assert.ok(html.indexOf('id="fq-compose-scroll"') < html.indexOf('id="fi-queue-scroll"'),
+    'and before the spark queue, which feeds the form rather than the fast path');
+  assert.doesNotMatch(html, /class="app-content app-content--railed"/,
+    'the rail reserve is no longer held open in the markup — ideas.js grants it with the meter');
+});
+
+await test('/idea/:id sends people to a form that will be open when they arrive', async () => {
+  const src = fs.readFileSync(path.join(HALL, 'idea.js'), 'utf8');
+  assert.match(src, /\/ideas\?develop=\$\{encodeURIComponent\(idea\.id\)\}/,
+    'the spark page develops THAT spark, rather than dropping someone on a bare composer');
+  assert.match(src, /\/ideas#full/, 'and the fallback action names the composer the fold answers to');
+  assert.doesNotMatch(src, /href="\$\{hallBase\(\)\}\/ideas"/,
+    'no link is left pointing at the page with no word about which half it meant');
+});
+
+
+
+// --- REOPENING, which is the case the first round of this task missed --------
+//
+// The fold's own interaction is open → close → open, and the first version of
+// it shipped a meter that never came back: `renderForm` was the only thing that
+// ever unhid the meter, `bootFullIdea` runs it at most once, so the second open
+// restored the form AND the rail reserve with the readout gone for good. Every
+// close case below passed, because none of them opened again.
+//
+// The lesson is the one in the harness's own header about the parked reads: a
+// probe that reds nothing is not proof the code is right, and neither is a case
+// that stops one step short of the interaction it is named after.
+
+await test('reopening brings the METER back, not just the form and the rail', async () => {
+  const r = boot();
+  await settle(); await settle();
+  await r.openFull();
+  assert.equal(r.el('fi-meter').hidden, false, 'shown on the first open');
+  r.el('fi-open')._handlers.click(); await settle();
+  assert.equal(r.el('fi-meter').hidden, true, 'away with the form');
+  await r.openFull();
+  assert.equal(r.el('fi-form').hidden, false, 'the form comes back');
+  assert.equal(r.el('fi-content')._classes.has('app-content--railed'), true, 'and so does the rail reserve');
+  assert.equal(r.el('fi-meter').hidden, false,
+    'and so does the meter — a rail held open for a panel that never returns is the anti-pattern the fold removes');
+});
+
+await test('a template that never loaded shows NO meter, however often it is folded', async () => {
+  const r = boot({ templateOk: false });
+  await settle(); await settle();
+  await r.openFull();
+  assert.equal(r.el('fi-meter').hidden, true, 'there is no form, so there is nothing to read out');
+  r.el('fi-open')._handlers.click(); await settle();
+  await r.openFull();
+  assert.equal(r.el('fi-meter').hidden, true,
+    'and reopening must not reveal an empty gauge — a readout showing nothing is a score of nothing');
+  assert.equal(r.el('fi-content')._classes.has('app-content--railed'), true,
+    'the rail still follows the OPEN state, so this is a real distinction and not both flags moving together');
+});
+
 console.log(`\nidea_spark_hall: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);

package/tests/ideator_one_line_path_proof.mjs

@@ -0,0 +1,338 @@
+// tests/ideator_one_line_path_proof.mjs — THE PROOF for spec decision 18
+// (task 1004101 / BV2.R22 of goal 1000095, spec R06a).
+//
+// THE DECISION THIS GUARDS. Spec decision 18 folded the Full Idea form onto the
+// same surface as the one-line composer and called itself "the decision with the
+// most risk in it", because a spark's whole value is that it costs nothing to
+// have. If the fast path picked up an extra step, a scroll or a decision, this
+// scope would have built something beautiful that people stop using — and they
+// would go back to firing one-liners into Discord.
+//
+// WHY THIS IS NOT MORE UNIT TESTS. tests/idea_spark_hall.mjs already asserts
+// that the folded page behaves correctly. What it cannot see is whether the
+// folded page is WORSE THAN THE ONE IT REPLACED, because it only ever boots the
+// current file. A regression in the fast path is not a broken assertion; it is
+// the same page, still working, costing more than it used to. The only way to
+// see that is to measure both.
+//
+// SO THE BASELINE IS THE REAL PRE-FOLD PAGE, not a description of it.
+// tests/fixtures/ideator-prefold/ holds byte copies of
+// modules/hall-ui/public/ideas.{html,js} at commit f375a1f9 — the commit
+// immediately before the fold landed (task 1004087) — carried as .baseline files
+// so the duplication ratchet does not read a frozen copy as copy/paste to collapse
+// (see that folder's README). Both pages are booted through the SAME stub, instrumented the same way, in the same process. A
+// hand-written "before" number would agree with the "after" because the author
+// made it agree; these two can only agree if the code does.
+//
+// WHAT THIS FILE CAN AND CANNOT MEASURE — read this before trusting it.
+// It measures the things that are DETERMINISTIC: how many gestures filing
+// takes, how much the page does before the fast path is usable, where the fast
+// path sits in the document, and what the fast path depends on. It does NOT
+// measure wall-clock, because a wall-clock assertion in CI is a flake and a
+// median over a stub DOM is not a number about the product. The real elapsed
+// time was measured in a browser and is recorded, with its method and its
+// error bars, in docs/governance/bongos-v2-ideator-one-line-path-proof.md.
+// A reader who wants the seconds should go there; what is enforced on every
+// push is below.
+//
+// Pure vm + file read. No DB, no network, no browser.
+//
+// Run:  node tests/ideator_one_line_path_proof.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules/hall-ui/public');
+const PREFOLD = path.join(ROOT, 'tests/fixtures/ideator-prefold');
+
+// The commit the baseline was taken at, so a reader can re-cut it and diff.
+const BASELINE_SHA = 'f375a1f9';
+
+const PAGES = {
+  before: {
+    label: `the page as it was (${BASELINE_SHA}, before the fold)`,
+    js: fs.readFileSync(path.join(PREFOLD, 'ideas.js.baseline'), 'utf8'),
+    html: fs.readFileSync(path.join(PREFOLD, 'ideas.html.baseline'), 'utf8'),
+  },
+  after: {
+    label: 'the page as it is now (folded)',
+    js: fs.readFileSync(path.join(HALL, 'ideas.js'), 'utf8'),
+    html: fs.readFileSync(path.join(HALL, 'ideas.html'), 'utf8'),
+  },
+};
+
+const { BASE_TEMPLATE } = require('../modules/ideas/templates.js');
+const TEMPLATE = {
+  key: BASE_TEMPLATE.key,
+  label: BASE_TEMPLATE.label,
+  fields: BASE_TEMPLATE.fields.map((f) => ({
+    key: f.key, label: f.label, required: !!f.required, substance_min: f.substanceMin || 0,
+  })),
+};
+
+const SPARKS = [
+  { id: '77', title: 'Let a builder mute one channel', status: 'open', grade: 'spark', captured_at: '2026-08-01T00:00:00Z', filed_by_login: 'thinker' },
+  { id: '78', title: 'A shared changelog', status: 'open', grade: 'spark', captured_at: '2026-07-30T00:00:00Z', filed_by_login: null },
+];
+const VERSIONS = [{ id: 'BV1', status: 'building' }];
+const GOALS = [{ id: '77', title: 'Goal Seventy Seven', version_id: 'BV1' }];
+
+// ---------------------------------------------------------------------------
+// the instrumented boot — identical for both pages
+// ---------------------------------------------------------------------------
+//
+// THE GESTURE COUNTER IS THE LOAD-BEARING PART. A "gesture" here is one
+// discrete thing a person does with the keyboard or the pointer: focusing a
+// control, changing its value, or pressing something. Typing a title is ONE
+// gesture (a person types a sentence, they do not perform N keystroke
+// decisions), which is the reading that makes the comparison fair — counting
+// keystrokes would let a shorter placeholder look like a faster path.
+//
+// It is counted by INSTRUMENTING THE STUB rather than by reading the source:
+// every value written to a control and every handler fired is recorded, so the
+// count is what the driver below actually had to do to reach a filed spark,
+// on whichever page it was driven against.
+
+function boot(which, { templateOk = true } = {}) {
+  const page = PAGES[which];
+  const els = new Map();
+  const gestures = [];
+  const calls = [];
+
+  const makeEl = (id) => ({
+    id,
+    dataset: {}, style: {}, textContent: '', hidden: false, disabled: false,
+    readOnly: false, tabIndex: 0, _html: '', _handlers: {},
+    _attrs: {}, _classes: new Set(),
+    _value: '',
+    get value() { return this._value; },
+    set value(v) { this._value = String(v == null ? '' : v); },
+    get classList() { const s = this._classes; return { add: (c) => s.add(c), remove: (c) => s.delete(c), contains: (c) => s.has(c) }; },
+    setAttribute(k, v) { this._attrs[String(k)] = String(v); },
+    getAttribute(k) { const v = this._attrs[String(k)]; return v === undefined ? null : v; },
+    addEventListener(t, fn) { this._handlers[t] = fn; },
+    querySelector() { return makeEl('anon'); }, querySelectorAll() { return []; }, appendChild() {},
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+  });
+
+  const documentObj = {
+    title: '', body: { dataset: { page: 'ideas' } },
+    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {} } },
+    getElementById(id) { if (!els.has(id)) els.set(id, makeEl(id)); return els.get(id); },
+    querySelector(sel) { return this.getElementById(String(sel).replace(/^#/, '')); },
+    querySelectorAll() { return []; },
+    createElement() { return makeEl('created'); },
+    addEventListener() {},
+  };
+
+  const client = {
+    inbox: {
+      getInboxTemplate: async () => { calls.push('template'); return templateOk ? { status: 200, ok: true, data: { template: TEMPLATE } } : { status: 500, ok: false, data: null }; },
+      getInboxSparks: async () => { calls.push('sparks'); return { status: 200, ok: true, data: { sparks: SPARKS, count: SPARKS.length } }; },
+      getInboxId: async () => { calls.push('idea'); return { status: 404, ok: false, data: null }; },
+      postInboxScore: async () => { calls.push('score'); return { status: 200, ok: true, data: { score: 60, fields: TEMPLATE.fields.map((f) => ({ key: f.key, substance: 24, floor: 40, ratio: 0.6 })) } }; },
+      postInbox: async (a) => { calls.push('capture'); return { status: 201, ok: true, data: { idea: { id: '910', routing: { routed: false, reason: 'no_goal' } } } }; },
+      postInboxIdDevelop: async () => { calls.push('develop'); return { status: 200, ok: true, data: { idea: {} } }; },
+      postInboxPreviewLanding: async () => { calls.push('preview'); return { status: 200, ok: true, data: { outcome: 'floats', reason: 'no_goal', status: null, goal: null, version_id: null, refusal: null } }; },
+    },
+    versions: { getVersions: async () => { calls.push('versions'); return { status: 200, ok: true, data: { versions: VERSIONS } }; } },
+    goals: {
+      getGoals: async () => { calls.push('goals'); return { status: 200, ok: true, data: { goals: GOALS } }; },
+      getGoalsSuggestions: async () => { calls.push('suggestions'); return { status: 200, ok: true, data: { suggestions: [] } }; },
+    },
+    me: { getMe: async () => { calls.push('me'); return { status: 200, ok: true, data: { task_kinds: ['bug', 'feature'] } }; } },
+  };
+
+  const windowObj = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => client },
+    OTB: {
+      escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
+      $: (sel) => documentObj.querySelector(sel),
+      toast: () => {},
+      fillKindFilter: () => {},
+      kindLabel: (k) => k,
+    },
+    localStorage: { getItem: () => null, setItem: () => {}, removeItem: () => {} },
+    location: { hostname: 'builders.cloudbongos.com', pathname: '/ideas', search: '', hash: '', assign() {} },
+    addEventListener() {},
+  };
+
+  const sandbox = { window: windowObj, document: documentObj, location: windowObj.location, console, setTimeout, clearTimeout, Date };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(page.js, sandbox, { filename: `ideas.js[${which}]` });
+
+  const el = (id) => documentObj.getElementById(id);
+  return {
+    which, label: page.label, html: page.html, calls, gestures, el,
+    // Every driver action below goes through these, so the gesture count is a
+    // record of what was actually done rather than a number someone typed.
+    type(id, text) { gestures.push(`type:${id}`); el(id).value = text; const h = el(id)._handlers.input; if (h) h(); },
+    choose(id, v) { gestures.push(`choose:${id}`); el(id).value = v; const h = el(id)._handlers.change; if (h) h(); },
+    press(id) { gestures.push(`press:${id}`); const h = el(id)._handlers.click; if (h) return h(); return undefined; },
+    async fileIt() {
+      gestures.push('press:fq-submit');
+      return el('fq-form')._handlers.submit({ preventDefault() {} });
+    },
+    submittable() { return typeof el('fq-form')._handlers.submit === 'function'; },
+  };
+}
+
+const settle = () => new Promise((r) => setTimeout(r, 0));
+const boots = async (which, opts) => { const r = boot(which, opts); await settle(); await settle(); await settle(); return r; };
+
+let passed = 0;
+let failed = 0;
+const findings = [];
+async function claim(name, fn) {
+  try { await fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (err) { failed++; findings.push(`${name}: ${err.message}`); console.error(`  FAIL  ${name}\n        ${err.message}`); }
+}
+
+console.log('\nTHE ONE-LINE PATH, BEFORE AND AFTER THE FOLD');
+console.log(`  before = ${PAGES.before.label}`);
+console.log(`  after  = ${PAGES.after.label}\n`);
+
+// ---------------------------------------------------------------------------
+// CLAIM 1 — the same gestures
+// ---------------------------------------------------------------------------
+
+await claim('filing one line takes the SAME gestures on both pages, and they are the same gestures', async () => {
+  const drive = async (which) => {
+    const r = await boots(which);
+    r.type('fq-title', 'the hall should remember what I filed');
+    await r.fileIt();
+    await settle();
+    return r;
+  };
+  const before = await drive('before');
+  const after = await drive('after');
+
+  assert.deepEqual(after.gestures, before.gestures,
+    `the gesture sequence changed:\n  before ${JSON.stringify(before.gestures)}\n  after  ${JSON.stringify(after.gestures)}`);
+  // Stated absolutely as well as relatively: two pages that both got WORSE in
+  // the same way would pass the comparison above and nothing else here.
+  assert.deepEqual(after.gestures, ['type:fq-title', 'press:fq-submit'],
+    'the fast path is a title and a press — anything else is a step this decision promised not to add');
+  assert.ok(before.calls.includes('capture') && after.calls.includes('capture'),
+    'and both actually filed — a path that files nothing is not a fast one');
+});
+
+await claim('neither page makes the filer touch the kind or the goal to file', async () => {
+  for (const which of ['before', 'after']) {
+    const r = await boots(which);
+    r.type('fq-title', 'one line');
+    await r.fileIt();
+    await settle();
+    const capture = r.calls.filter((c) => c === 'capture');
+    assert.equal(capture.length, 1, `${which}: filing with nothing but a title reaches the capture route`);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// CLAIM 2 — the fast path is usable no later than it was
+// ---------------------------------------------------------------------------
+
+await claim('the form is submittable before ANY read answers — on both pages', async () => {
+  // Deliberately NOT awaited: this is the state of the page in the instant
+  // after its script runs, before a single promise has settled.
+  for (const which of ['before', 'after']) {
+    const r = boot(which);
+    assert.equal(r.submittable(), true,
+      `${which}: the submit handler is attached synchronously, so a fast typist is never racing the network`);
+  }
+  // Honest reading: this was ALREADY true before the fold. It is recorded as a
+  // property preserved, not as an improvement won — see the governance record.
+});
+
+await claim('the folded page does LESS on arrival: no template read, no scoring, no meter', async () => {
+  const before = await boots('before');
+  const after = await boots('after');
+
+  assert.ok(before.calls.includes('template'),
+    'the old page fetched the five questions on arrival whether or not anyone wanted them');
+  assert.ok(!after.calls.includes('template'),
+    'the folded page does not');
+  assert.ok(!after.calls.includes('score'), 'and scores nothing');
+  assert.ok(after.calls.length < before.calls.length,
+    `the folded page issues fewer reads on arrival (before ${before.calls.length}: ${before.calls.join(',')} · after ${after.calls.length}: ${after.calls.join(',')})`);
+});
+
+// ---------------------------------------------------------------------------
+// CLAIM 3 — the fast path is not behind anything
+// ---------------------------------------------------------------------------
+
+await claim('the one-line composer moved ABOVE the two things that used to precede it', async () => {
+  const pos = (html, id) => html.indexOf(`id="${id}"`);
+  const b = PAGES.before.html;
+  const a = PAGES.after.html;
+
+  assert.ok(pos(b, 'fi-queue-scroll') < pos(b, 'fq-compose-scroll'),
+    'before: the spark queue came first — the baseline says so itself, so this is measured, not remembered');
+  assert.ok(pos(a, 'fq-compose-scroll') < pos(a, 'fi-queue-scroll'),
+    'after: the one-line composer is first');
+  assert.ok(pos(a, 'fq-compose-scroll') < pos(a, 'fi-compose-scroll'),
+    'and still ahead of the five questions');
+  // The rail is the other half of "how much room the fast path gets".
+  assert.match(b, /class="app-content app-content--railed"/,
+    'before: the column reserved the meter\'s room at every wide width, occupied or not');
+  assert.doesNotMatch(a, /class="[^"]*app-content--railed/,
+    'after: it does not, so the one-line form is drawn at the page\'s full width');
+});
+
+// ---------------------------------------------------------------------------
+// CLAIM 4 — the fast path does not depend on the slow one
+// ---------------------------------------------------------------------------
+
+await claim('a totally broken Full Idea half does not slow, block or shout over the fast path', async () => {
+  const before = await boots('before', { templateOk: false });
+  const after = await boots('after', { templateOk: false });
+
+  for (const [which, r] of [['before', before], ['after', after]]) {
+    r.type('fq-title', 'filing while the other half is down');
+    await r.fileIt();
+    await settle();
+    assert.ok(r.calls.includes('capture'), `${which}: the filing still goes through`);
+  }
+  // The difference is what the PAGE says about it. The old page wrote the
+  // template's failure into the page-head subtitle — a failure notice sitting
+  // over a form that was working perfectly well.
+  assert.match(before.el('fi-sub').textContent, /Could not load the idea template/,
+    'before: the page announced a broken half the filer had not asked for');
+  assert.doesNotMatch(after.el('fi-sub').textContent, /Could not load/,
+    'after: a folded half that failed to load says nothing, because nobody opened it');
+});
+
+// ---------------------------------------------------------------------------
+// CLAIM 5 — the guard on this proof
+// ---------------------------------------------------------------------------
+
+await claim('the baseline is the REAL previous page, not a paraphrase of it', async () => {
+  // If someone ever "tidies" the fixture into agreement with the current page,
+  // every comparison above becomes vacuous and still passes. These are the
+  // properties that made the before the before.
+  const b = PAGES.before.js;
+  assert.ok(b.includes('const r = await api.inbox.getInboxTemplate({});'),
+    'the baseline still fetches the template unconditionally in main()');
+  assert.ok(!b.includes('setDisclosure'), 'and knows nothing about a disclosure');
+  assert.ok(!PAGES.before.html.includes('fi-open'), 'and has no toggle in its markup');
+  assert.notEqual(PAGES.before.js, PAGES.after.js, 'the two pages are not the same file');
+});
+
+// ---------------------------------------------------------------------------
+
+console.log('');
+console.log(`ideator_one_line_path_proof: ${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  console.error('\nTHE FAST PATH GOT MORE EXPENSIVE. Spec decision 18 is the decision this scope');
+  console.error('flagged as riskiest, and these are its guard rails:');
+  for (const f of findings) console.error(`  - ${f}`);
+  process.exit(1);
+}