@bongos/core 1.19.1006 → 1.19.1008

package/modules/hall-ui/public/ideas.js

@@ -264,7 +264,11 @@
 
     renderRecommendation(draft);
 
-    $('#fi-meter').hidden = false;
+    formRendered = true;
+    // The meter is unhidden through the disclosure, which owns the rule for both
+    // directions; setting it here as well would be a second source of truth for
+    // the same visibility and is what let the reopen case rot unnoticed.
+    setDisclosure(fullOpen);
     renderMeterSkeleton();
   }
 
@@ -902,24 +906,78 @@
     return true;
   }
 
-  async function main() {
-    // THE QUEUE IS LOADED FIRST, AND UNCONDITIONALLY. The composer and the spark
-    // queue are independent surfaces that happen to share a page: the queue needs
-    // no template. Loading it after the template check meant one failed fetch took
-    // BOTH down — the reported symptom was "Could not load the idea template" AND a
-    // queue stuck on "Loading…" forever, which read as two bugs and was one.
-    // A surface that does not depend on the failure must not be hostage to it.
-    loadQueue();
+  // ---------------------------------------------------------------------------
+  // the disclosure (task 1004087 / spec R04, decision 18)
+  // ---------------------------------------------------------------------------
+  //
+  // THE FULL IDEA FORM IS CLOSED UNTIL SOMEONE ASKS FOR IT, and this is the
+  // whole point of the fold. Decision 18 put the five questions on the same
+  // surface as the one-line composer and named that the riskiest call in the
+  // spec: a spark's value is that it costs nothing to have, and a five-field
+  // form standing permanently open under the fast path is exactly how a page
+  // starts feeling like something to be filled in.
+  //
+  // So "on the same surface" is spent on ONE press, and nothing else. While the
+  // form is shut this page does not fetch the template, does not wire the
+  // per-keystroke scorer, and does not hold the rail reserve open — the one-line
+  // path is the first thing under the heading at full width, and it is ready
+  // before any of the Full Idea machinery has run.
+  //
+  // Closing again HIDES, it does not discard: the draft lives in localStorage
+  // exactly as it did before, so the toggle is reversible in both directions and
+  // the button can say so without lying.
+
+  let fullBooted = false;   // the template read was STARTED once
+  let formRendered = false; // ...and actually produced a form (and so a meter)
+  let fullOpen = false;
+
+  // The rail reserve belongs to the meter, so it arrives and leaves with it.
+  // style.css reserves `--rail-right-w` from `.app-content--railed > main` at the
+  // wide breakpoint whether or not anything is in the rail, which is why this is
+  // a class toggle and not simply `#fi-meter.hidden`.
+  function setRail(on) {
+    const c = document.getElementById('fi-content');
+    if (!c || !c.classList) return;
+    if (on) c.classList.add('app-content--railed');
+    else c.classList.remove('app-content--railed');
+  }
 
-    // Quick filing (R08) is a THIRD independent surface on this page, offered
-    // only outside develop mode — developing a spark always produces a Full
-    // Idea, never a fresh quick report (see the section's own header comment).
-    if (DEVELOP_ID) {
-      const scroll = $('#fq-compose-scroll');
-      if (scroll) scroll.hidden = true;
-    } else {
-      bootQuickComposer();
+  function setDisclosure(open) {
+    fullOpen = open;
+    const form = $('#fi-form');
+    const btn = $('#fi-open');
+    const note = $('#fi-disclose-note');
+    if (form) form.hidden = !open;
+    if (btn) {
+      btn.setAttribute('aria-expanded', open ? 'true' : 'false');
+      btn.textContent = open ? 'Put the five questions away' : 'Answer the five questions';
+    }
+    if (note) {
+      note.textContent = open
+        ? 'Putting them away keeps your draft — it is saved as you type.'
+        : 'Nothing you have typed above is lost by opening this.';
     }
+    // The meter is the form's readout, so it follows the form BOTH WAYS — and the
+    // condition is written as one expression rather than a hide-only branch
+    // because the hide-only version was a real bug: `renderForm` is the only
+    // thing that ever unhid the meter, `bootFullIdea` runs it at most once, so
+    // opening, closing and opening again brought the form and the rail back with
+    // the readout gone for good — the rail reserve held open for a panel that
+    // was no longer there, which is the exact anti-pattern the fold removes.
+    //
+    // `formRendered`, not `fullBooted`: the boot flag is set BEFORE the template
+    // read, so it is true even when that read failed and there is no meter to
+    // show. An empty meter is a readout claiming a score of nothing.
+    const meter = $('#fi-meter');
+    if (meter) meter.hidden = !(open && formRendered);
+    setRail(open);
+  }
+
+  // Everything the Full Idea half needs, run at most once and never on the fast
+  // path. Returns nothing: its failures are stated on the page, as before.
+  async function bootFullIdea() {
+    if (fullBooted) return;
+    fullBooted = true;
 
     const r = await api.inbox.getInboxTemplate({});
     if (!r.ok || !r.data || !r.data.template) {
@@ -958,5 +1016,58 @@
     }
   }
 
+  async function openFullIdea() {
+    setDisclosure(true);
+    await bootFullIdea();
+  }
+
+  async function toggleFullIdea() {
+    if (fullOpen) { setDisclosure(false); return; }
+    await openFullIdea();
+  }
+
+  async function main() {
+    // THE QUEUE IS LOADED FIRST, AND UNCONDITIONALLY. The composer and the spark
+    // queue are independent surfaces that happen to share a page: the queue needs
+    // no template. Loading it after the template check meant one failed fetch took
+    // BOTH down — the reported symptom was "Could not load the idea template" AND a
+    // queue stuck on "Loading…" forever, which read as two bugs and was one.
+    // A surface that does not depend on the failure must not be hostage to it.
+    loadQueue();
+
+    // Quick filing (R08) is a THIRD independent surface on this page, offered
+    // only outside develop mode — developing a spark always produces a Full
+    // Idea, never a fresh quick report (see the section's own header comment).
+    if (DEVELOP_ID) {
+      const scroll = $('#fq-compose-scroll');
+      if (scroll) scroll.hidden = true;
+    } else {
+      bootQuickComposer();
+    }
+
+    const openBtn = $('#fi-open');
+    if (openBtn) openBtn.addEventListener('click', toggleFullIdea);
+    setDisclosure(false);
+
+    // THE THREE CASES A SHUT FORM WOULD STRAND (task 1004087 / spec R04). The
+    // done-when is "no dead links", and a link that lands on a page whose
+    // relevant half is folded away is dead in the only sense that matters to
+    // whoever followed it:
+    //
+    //   ?develop=<id>  the spark queue's own rows, and /idea/:id — the whole
+    //                  request is "develop this", so arriving at a shut form
+    //                  would be the page ignoring it.
+    //   #full          the deep link anything else uses to mean "the composer",
+    //                  including /idea/:id's fallback action.
+    //   a saved draft  half-written work already in localStorage. Leaving it
+    //                  behind a press nobody knows to make is how "a partial
+    //                  draft is not lost on navigation" (R152) quietly stops
+    //                  being true — the draft would still be there and no one
+    //                  would ever see it again.
+    if (DEVELOP_ID || location.hash === '#full' || readDraft()) {
+      await openFullIdea();
+    }
+  }
+
   main();
 })();

package/modules/hall-ui/public/ideas.states.json

@@ -1,5 +1,5 @@
 {
-  "_": "The hall's IDEA COMPOSER through modules/ui-design/kit/render.js (task 1003305). The five questions are rendered from GET /inbox/template and the spark queue from GET /inbox/sparks, so the populated form needs the hall-preview harness; the kit's own stub answers neither and renders the honest `could not load the idea template` line instead, which is the `no-template` state below.\n\n  node scripts/hall-preview/server.js --port 4612 --fixture-me\n  node modules/ui-design/kit/render.js --states modules/hall-ui/public/ideas.states.json --base-in http://builders.localhost:4612 --base-out http://builders.localhost:4612\n\nThe right rail is the shell's `.app-content--railed` reserve, so the 62rem breakpoint is exercised at 1440 and stacked at 390/320 — which is the whole reason all three widths are rendered.",
+  "_": "The hall's IDEA COMPOSER through modules/ui-design/kit/render.js (task 1003305). The five questions are rendered from GET /inbox/template and the spark queue from GET /inbox/sparks, so the populated form needs the hall-preview harness; the kit's own stub answers neither and renders the honest `could not load the idea template` line instead, which is the `no-template` state below.\n\n  node scripts/hall-preview/server.js --port 4612 --fixture-me\n  node modules/ui-design/kit/render.js --states modules/hall-ui/public/ideas.states.json --base-in http://builders.localhost:4612 --base-out http://builders.localhost:4612\n\nTHE FOLD (task 1004087 / spec R04) is why there are now three states rather than two. `compose` is what a builder actually lands on — the one-line composer at the top, the Full Idea form folded away behind one press, and NO rail reserve, which is the whole reason that state is rendered at 1440 as well as at 390/320. `full` is the same page one press later: the five questions, the meter, and the rail. Rendering only one of them would measure half the page, and the half that is measured on every arrival is the first.",
   "page": "/ideas",
   "surface": "hall-ui",
   "stub": { "prefix": "/builders/" },
@@ -8,7 +8,8 @@
   "_console": "The 501 is the harness, not the page: the meter re-scores through POST /inbox/score on every keystroke and scripts/hall-preview/server.js answers every write with preview_readonly by design. Declared rather than hidden.",
   "ignoreConsole": ["/api/(gds|bongos)/", "\\b401\\b", "\\b404\\b", "\\b501\\b", "Unauthorized", "Not Found", "Not Implemented", "load failed"],
   "states": {
-    "compose": { "auth": true, "actions": [["wait", 700]], "expect": { "visible": ["#fi-form", "#fi-fields", "#fi-queue"] } },
+    "compose": { "auth": true, "actions": [["wait", 700]], "expect": { "visible": ["#fq-form", "#fi-queue", "#fi-open"] } },
+    "full": { "auth": true, "actions": [["wait", 700], ["click", "#fi-open"], ["wait", 700]], "expect": { "visible": ["#fi-form", "#fi-fields", "#fi-meter"] } },
     "develop": { "auth": true, "url": "/ideas?develop=1000884", "actions": [["wait", 700]], "expect": { "visible": ["#fi-develop"] } }
   },
   "reducedMotion": { "auth": true, "actions": [["wait", 700]] }

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.1006",
+  "version": "1.19.1008",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.1006",
+      "version": "1.19.1008",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.1006",
+  "version": "1.19.1008",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.1006'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.1008'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

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);