@bongos/core 1.19.906 → 1.19.908

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

@@ -53,9 +53,17 @@
   // exact timestamp stays on the title, where a reader who wants the date can
   // still reach it — which is also why the separate date line that used to sit
   // under this pill is gone: the same fact twice is one fact too many.
-  function ageChip(req, nowMs) {
+  //
+  // `baseline` is the block's own room condition (L.roomBaseline), and it is the
+  // second half of the same verdict: where the label stops fourteen old rows
+  // reading as fourteen copies of one alarm, the baseline stops them WEARING
+  // fourteen copies of one alarm. A row at or below its room's baseline is the
+  // rule, not the exception, so it drops the ring and the danger ink and keeps
+  // only its words — the head says the room's condition once instead.
+  function ageChip(req, nowMs, baseline) {
     const band = L.ageBand(req.created_at, nowMs);
-    return `<span class="fact-pill cb-age cb-age--${band.id}" title="Asked ${escapeHtml(String(req.created_at || ''))}">${escapeHtml(L.ageLabel(req.created_at, nowMs))}</span>`;
+    const quiet = L.isRoomQuiet(band, baseline) ? ' cb-age--quiet' : '';
+    return `<span class="fact-pill cb-age cb-age--${band.id}${quiet}" title="Asked ${escapeHtml(String(req.created_at || ''))}">${escapeHtml(L.ageLabel(req.created_at, nowMs))}</span>`;
   }
 
   // A DOM id per row that is stable, unique and safe to put in an attribute. The
@@ -175,14 +183,14 @@
   // chat mirror). What the page owes a helper is the request, its age, its
   // context, and who to answer — and their face. A by-name ask is the personal
   // call on this reader, so its row is the LIT one (.cb-row--live).
-  function forMeRow(req, nowMs, extra, key) {
+  function forMeRow(req, nowMs, extra, key, baseline) {
     const live = req.needs_builder_id != null ? ' cb-row--live' : '';
     return `<li class="ov-row ov-row--lead cb-row${live}" data-id="${escapeHtml(String(req.id))}"${extra ? ' data-extra hidden' : ''}>
       ${faceHtml(L.faceOf(req, 'in'))}
       <div class="ov-row__main">${askHtml(req, key)}
         <div class="ov-row__facts">${directionFact(req, 'in')}${contextChip(req)}</div>
       </div>
-      <div class="ov-row__right">${ageChip(req, nowMs)}</div>
+      <div class="ov-row__right">${ageChip(req, nowMs, baseline)}</div>
     </li>`;
   }
 
@@ -198,12 +206,12 @@
   // which is precisely the distinction a reader could no longer make. Moving the
   // pill down to the facts line puts the warning with the other facts about the
   // ask and leaves the right column as what it is here: the place you act.
-  function mineRow(req, nowMs, extra, key) {
+  function mineRow(req, nowMs, extra, key, baseline) {
     const id = escapeHtml(String(req.id));
     return `<li class="ov-row ov-row--lead cb-row" data-id="${id}"${extra ? ' data-extra hidden' : ''}>
       ${faceHtml(L.faceOf(req, 'out'))}
       <div class="ov-row__main">${askHtml(req, key)}
-        <div class="ov-row__facts">${directionFact(req, 'out')}${contextChip(req)}${ageChip(req, nowMs)}</div>
+        <div class="ov-row__facts">${directionFact(req, 'out')}${contextChip(req)}${ageChip(req, nowMs, baseline)}</div>
       </div>
       <div class="ov-row__right">
         <div class="ov-row__actions">
@@ -216,13 +224,13 @@
 
   // A row on the board of everyone's asks: the asker's face, the third-person
   // line, no actions — settling is the asker's, in their own block.
-  function allRow(req, nowMs, extra, key) {
+  function allRow(req, nowMs, extra, key, baseline) {
     return `<li class="ov-row ov-row--lead cb-row" data-id="${escapeHtml(String(req.id))}"${extra ? ' data-extra hidden' : ''}>
       ${faceHtml(L.faceOf(req, 'in'))}
       <div class="ov-row__main">${askHtml(req, key)}
         <div class="ov-row__facts">${boardFact(req)}${contextChip(req)}</div>
       </div>
-      <div class="ov-row__right">${ageChip(req, nowMs)}</div>
+      <div class="ov-row__right">${ageChip(req, nowMs, baseline)}</div>
     </li>`;
   }
 
@@ -235,13 +243,27 @@
   function paintBlock(key, rows, rowFn, nowMs, faces) {
     const list = rows.slice().sort(L.byNewestFirst);
     const { shown, hidden } = L.splitShown(list, SHOWN);
+    // Over the WHOLE list, not the shown three: the door hides rows, it does not
+    // change what the room is, and a baseline that flipped when someone pressed
+    // "Show all" would re-alarm the rows it had just quieted.
+    const baseline = L.roomBaseline(list, nowMs);
     const host = $(`#cb-${key}`);
     if (host) {
-      host.innerHTML = shown.map((r) => rowFn(r, nowMs, false, key)).join('')
-        + hidden.map((r) => rowFn(r, nowMs, true, key)).join('');
+      host.innerHTML = shown.map((r) => rowFn(r, nowMs, false, key, baseline)).join('')
+        + hidden.map((r) => rowFn(r, nowMs, true, key, baseline)).join('');
     }
     const n = $(`#cb-${key}-n`);
     if (n) n.textContent = list.length ? String(list.length) : '';
+    // The room's condition, said once, beside the count that scopes it.
+    const age = $(`#cb-${key}-age`);
+    if (age) {
+      const line = L.roomAgeLine(baseline);
+      age.textContent = line;
+      age.hidden = !line;
+      age.className = line
+        ? `cb-block__age cb-block__age--${baseline.band.id}`
+        : 'cb-block__age';
+    }
     const empty = $(`#cb-${key}-empty`);
     if (empty) empty.hidden = list.length > 0;
     const facesEl = $(`#cb-${key}-faces`);

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

@@ -79,6 +79,19 @@
 .fi-result { margin: var(--sp-sm) 0 0; max-width: var(--measure); font-size: 14px; line-height: 1.5; color: var(--ink-soft); }
 .fi-result a { display: inline-block; min-height: 24px; padding: 3px 0; line-height: 18px; box-sizing: border-box; color: inherit; }
 
+/* The durable receipts list (task 1004082 / spec R01). Deliberately quieter than
+   .fi-result: that line is the answer to "did it land?", this is the answer to
+   "what happened to the last few?" — reference, not confirmation. Same 24px row
+   recipe on its links as every other list in the world. */
+.fi-receipts { margin: var(--sp-md) 0 0; max-width: var(--measure); }
+.fi-receipts__h { margin: 0; font-size: 12.5px; font-weight: 600; color: var(--ink-faint); }
+.fi-receipts__list { margin: 6px 0 0; padding: 0; list-style: none; }
+.fi-receipts__item { font-size: 13.5px; line-height: 1.5; color: var(--ink-soft); }
+.fi-receipts__item + .fi-receipts__item { margin-top: 4px; }
+.fi-receipts__item a { display: inline-block; min-height: 24px; padding: 3px 0; line-height: 18px; box-sizing: border-box; color: inherit; }
+.fi-receipts__what { color: var(--ink-faint); }
+.fi-receipts__note { margin: 6px 0 0; font-size: 12.5px; color: var(--ink-faint); }
+
 .fi-actions { display: flex; flex-wrap: wrap; gap: 10px 12px; align-items: center; margin-top: var(--sp-md); }
 .fi-draft { font-size: 12.5px; color: var(--ink-faint); }
 

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

@@ -92,6 +92,17 @@
             <p class="fi-err" id="fq-err" role="alert"></p>
             <p class="fi-result" id="fq-result" role="status" aria-live="polite"></p>
 
+            <!-- The receipt that outlives the confirmation above (task 1004082 /
+                 spec R01). #fq-result is the live announcement for the filing
+                 just made and dies with the page; this list is the durable
+                 record of the last few, read back from localStorage on load so
+                 a thought filed before a reload is still traceable here. -->
+            <section class="fi-receipts" id="fq-receipts" aria-labelledby="fq-receipts-h" hidden>
+              <h3 class="fi-receipts__h" id="fq-receipts-h">Recent filings</h3>
+              <ol class="fi-receipts__list" id="fq-receipts-list"></ol>
+              <p class="fi-receipts__note" id="fq-receipts-note" hidden></p>
+            </section>
+
             <div class="fi-actions">
               <button type="submit" class="btn" id="fq-submit">File it</button>
             </div>

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

@@ -127,6 +127,91 @@
     try { window.localStorage.removeItem(DRAFT_KEY); } catch (_) { /* nothing to clear */ }
   }
 
+  // ---------------------------------------------------------------------------
+  // filing receipts (task 1004082 / spec R01 — "the receipt persists")
+  // ---------------------------------------------------------------------------
+
+  // WHAT WAS ACTUALLY BROKEN. Not the keystroke clearing the line — nothing does
+  // that, and the task text was amended at build time to say so. The gaps were
+  // that only ONE outcome ever existed (the next filing overwrote it), and that
+  // it was DOM-only, so a reload lost it. So this is not a guard added to
+  // #fq-result; it is the record #fq-result never was.
+  //
+  // WHY LOCAL, and why that is honest here. A receipt is "what I was told when I
+  // filed", which is per-person and per-browser by nature — and the durable
+  // record of the ideas themselves already exists server-side on the profile
+  // trail. Re-reading the trail here would be a second copy of a read this page
+  // does not own (the same reasoning that keeps the scorer out of this file).
+  // Guarded exactly like the draft above: storage that throws must never take
+  // the composer down, and must never be reported as having saved.
+  const RECEIPTS_KEY = 'hall-filing-receipts';
+  const RECEIPTS_MAX = 5;
+  let receiptsStorageRefused = false;
+
+  function readReceipts() {
+    try {
+      const raw = window.localStorage.getItem(RECEIPTS_KEY);
+      if (!raw) return [];
+      const list = JSON.parse(raw);
+      if (!Array.isArray(list)) return [];
+      // Shape-check every row rather than trusting the key: a stale or
+      // hand-edited value must degrade to "no receipts", never to a thrown
+      // render that takes the filing form with it.
+      return list.filter((r) => r && typeof r === 'object' && typeof r.title === 'string')
+        .slice(0, RECEIPTS_MAX);
+    } catch (_) { return []; }
+  }
+
+  function pushReceipt(receipt) {
+    const next = [receipt].concat(readReceipts()).slice(0, RECEIPTS_MAX);
+    try {
+      window.localStorage.setItem(RECEIPTS_KEY, JSON.stringify(next));
+      receiptsStorageRefused = false;
+    } catch (_) {
+      // Same discipline as writeDraft: say it is not being kept rather than
+      // letting someone believe a receipt will be there after a reload.
+      receiptsStorageRefused = true;
+    }
+    return next;
+  }
+
+  function receiptLine(r) {
+    const when = r.at ? `<time datetime="${escapeHtml(String(r.at))}">${escapeHtml(formatReceiptTime(r.at))}</time> · ` : '';
+    const what = `<span class="fi-receipts__what">${escapeHtml(r.title)}</span>`;
+    if (r.task_id && r.href) {
+      const goal = r.goal_name ? ` under ${escapeHtml(r.goal_name)}` : '';
+      return `${when}${what} — filed as <a href="${escapeHtml(r.href)}">task ${escapeHtml(String(r.task_id))}</a>${goal}.`;
+    }
+    return `${when}${what} — filed to the inbox.`;
+  }
+
+  function formatReceiptTime(iso) {
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime())) return '';
+    try {
+      return d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    } catch (_) { return ''; }
+  }
+
+  function renderReceipts(list) {
+    const wrap = $('#fq-receipts');
+    const ol = $('#fq-receipts-list');
+    const noteEl = $('#fq-receipts-note');
+    if (!wrap || !ol) return;
+    const receipts = Array.isArray(list) ? list : readReceipts();
+    if (!receipts.length) { wrap.hidden = true; ol.innerHTML = ''; return; }
+    wrap.hidden = false;
+    ol.innerHTML = receipts
+      .map((r) => `<li class="fi-receipts__item">${receiptLine(r)}</li>`)
+      .join('');
+    if (noteEl) {
+      noteEl.hidden = !receiptsStorageRefused;
+      noteEl.textContent = receiptsStorageRefused
+        ? 'This browser is not keeping receipts — they will go when the tab does.'
+        : '';
+    }
+  }
+
   function note(msg) {
     const el = $('#fi-draft');
     if (el) el.textContent = msg;
@@ -474,8 +559,10 @@
       const goal = allGoalsById.get(String(routing.goal_id));
       const goalName = goal ? goal.title : `goal ${routing.goal_id}`;
       $('#fq-result').innerHTML = `Filed as <a href="${href}">task ${escapeHtml(String(routedTask.id))}</a> under ${escapeHtml(goalName)}.`;
+      renderReceipts(pushReceipt({ title, task_id: routedTask.id, goal_name: goalName, href, at: new Date().toISOString() }));
     } else {
       $('#fq-result').textContent = 'Filed to the inbox.';
+      renderReceipts(pushReceipt({ title, task_id: null, goal_name: null, href: null, at: new Date().toISOString() }));
     }
 
     fqTitleEl().value = '';
@@ -493,6 +580,10 @@
     fqGoalEl().addEventListener('change', () => { goalTouchedByUser = true; });
     $('#fq-form').addEventListener('submit', fileQuick);
 
+    // Before any network call: the receipts are local, so a builder who reloads
+    // sees what became of earlier thoughts even if every read below fails.
+    renderReceipts();
+
     try {
       const [versionsRes, goalsRes] = await Promise.all([
         api.versions.getVersions({}),

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.906",
+  "version": "1.19.908",
   "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.906'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.908'; // 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/collab_page.mjs

@@ -136,6 +136,98 @@ test('the two calm bands are not chips, and the date is not said twice', () => {
   assert.match(js, /title="Asked \$\{escapeHtml\(String\(req\.created_at/, 'the exact date is still reachable');
 });
 
+// ---- THE ROOM'S OWN CONDITION (task 1004067, from idea 1001065) -----------
+//
+// The report: fourteen of fourteen rows wore the "waiting over a week" pill, so
+// the loudest thing on the page carried no information. Task 1004041 made the
+// WORDS differ, which is why these tests are about the TREATMENT — fourteen
+// differently-worded rows in identical danger ink and identical rings still read
+// as a wall. Each case below is run through the lib, not grepped, so a rule that
+// is wrong fails here rather than looking plausible in a diff.
+const room = (...ages) => ages.map((d) => ({ created_at: daysAgo(d) }));
+
+test('a uniformly old room states its condition once instead of on every row', () => {
+  const L = lib();
+  // The reported board, reproduced: fourteen rows, every one past a week.
+  const rows = room(8, 9, 11, 13, 15, 16, 18, 21, 24, 27, 30, 34, 38, 41);
+  const baseline = L.roomBaseline(rows, NOW);
+  assert.ok(baseline, 'fourteen of fourteen is a room condition, not fourteen warnings');
+  assert.equal(baseline.band.id, 'stale');
+  assert.equal(L.roomAgeLine(baseline), 'all 14 waiting over a week');
+  const loud = rows.filter((r) => !L.isRoomQuiet(L.ageBand(r.created_at, NOW), baseline));
+  assert.equal(loud.length, 0, 'no row is worse than a room where every row is the same');
+  // And nothing is silently dead: each row still says its own real age.
+  const words = new Set(rows.map((r) => L.ageLabel(r.created_at, NOW)));
+  assert.ok(words.size > 1, 'the per-row words still carry the differing ages');
+});
+
+test('the pill is kept for the row that is worse than its room', () => {
+  const L = lib();
+  // Six of eight sitting a few days, two genuinely old. The two are the whole
+  // point of the column, and before this they were indistinguishable from the six.
+  const rows = room(4, 4, 5, 5, 5, 6, 21, 30);
+  const baseline = L.roomBaseline(rows, NOW);
+  assert.equal(baseline.band.id, 'aging');
+  assert.equal(L.roomAgeLine(baseline), '6 of 8 waiting a few days');
+  const loud = rows
+    .filter((r) => !L.isRoomQuiet(L.ageBand(r.created_at, NOW), baseline))
+    .map((r) => L.ageLabel(r.created_at, NOW));
+  assert.deepEqual(loud, ['waiting 3 weeks', 'waiting 4 weeks'], 'only the exceptions keep a chip');
+});
+
+test('a mixed room is left exactly as it was', () => {
+  const L = lib();
+  // No band is dominant here, so nothing is quieted and nothing is announced —
+  // which is what keeps this inert on the board as it usually looks.
+  const rows = room(0.2, 0.5, 1, 2, 4, 5, 9, 21);
+  assert.equal(L.roomBaseline(rows, NOW), null);
+  assert.equal(L.roomAgeLine(null), '');
+  for (const r of rows) {
+    assert.equal(L.isRoomQuiet(L.ageBand(r.created_at, NOW), null), false, 'no baseline quiets nothing');
+  }
+});
+
+test('a short list keeps every pill, and a calm room announces nothing', () => {
+  const L = lib();
+  // Three chips can be read one at a time; a wall needs a crowd.
+  assert.equal(L.roomBaseline(room(30, 30, 30), NOW), null, 'under the minimum, every row keeps its own');
+  assert.equal(L.BASELINE_MIN_ROWS, 4);
+  // A room that is uniformly calm has no alarm to move to the head. Announcing
+  // one there would invent the noise this removes.
+  assert.equal(L.roomBaseline(room(0.1, 0.2, 0.3, 0.4, 0.5), NOW), null, 'all fresh says nothing');
+  assert.equal(L.roomBaseline(room(1, 1, 2, 2, 2), NOW), null, 'all waiting-a-day says nothing either');
+});
+
+test('the room line and the rows cannot describe the threshold two ways', () => {
+  const L = lib();
+  // The head's words come from the band's own label, so there is one vocabulary.
+  for (const b of L.BANDS) {
+    const line = L.roomAgeLine({ band: b, count: 9, total: 12 });
+    assert.equal(line, `9 of 12 ${b.label}`, `${b.id} reads in its own words`);
+  }
+});
+
+test('the quiet treatment is wired through the render, not just defined', () => {
+  const js = read('modules', 'hall-ui', 'public', 'collab.js');
+  assert.match(js, /function ageChip\(req, nowMs, baseline\)/, 'the chip is told about its room');
+  assert.match(js, /L\.isRoomQuiet\(band, baseline\)/, 'through the lib, so the rule is the tested one');
+  assert.match(js, /cb-age--quiet/, 'and the class reaches the markup');
+  // Over the WHOLE list: a baseline computed on the shown three would flip when
+  // a reader pressed "Show all" and re-alarm the rows it had just quieted.
+  assert.match(js, /const baseline = L\.roomBaseline\(list, nowMs\)/, 'the room is the whole block');
+  const html = read('modules', 'hall-ui', 'public', 'collab.html');
+  for (const key of ['for-me', 'mine', 'all']) {
+    assert.ok(html.includes(`id="cb-${key}-age"`), `the ${key} head has somewhere to say it`);
+  }
+  const css = read('modules', 'hall-ui', 'public', 'collab.css');
+  assert.match(
+    css,
+    /\.cb-age\.cb-age--quiet\s*\{[^}]*border-color: transparent/,
+    'the quieted row drops its ring',
+  );
+  assert.match(css, /\.cb-age\.cb-age--quiet\s*\{[^}]*color: var\(--ink-soft\)/, 'and the danger ink with it');
+});
+
 test('the alarm does not sit beside the accent control', () => {
   // DESIGN.md spends the accent only on what is pressable or live. On "Your
   // asks" the age pill (danger ink) used to share the right column with the

package/tests/hall_collab_world.mjs

@@ -230,7 +230,11 @@ test('the door and the copy control are on the row, and the copy control is reac
   // One request can appear in three blocks at once, so the id is block-scoped.
   assert.match(js, /function askId\(key, id\)/);
   assert.match(js, /cb-ask-\$\{key\}-/);
-  assert.match(js, /rowFn\(r, nowMs, false, key\)/, 'and paintBlock hands the key down');
+  // A bracket class, not a closing paren: paintBlock also hands the row its
+  // block's age baseline (task 1004067), and pinning the exact arity would red
+  // this on an argument the invariant — that the KEY reaches the row — does not
+  // care about.
+  assert.match(js, /rowFn\(r, nowMs, false, key[,)]/, 'and paintBlock hands the key down');
 
   const css = read('collab.css');
   for (const cls of ['.cb-ask ', '.cb-ask__door', '.cb-ask__copy', '.cb-ask__full']) {
@@ -262,8 +266,12 @@ test('the age is a state pill in the row\'s right column, and every band has its
   assert.match(css, /\.cb-age--stale\s*\{[^}]*var\(--danger\)/, 'stale is the danger ink');
   assert.match(css, /\.cb-age--aging\s*\{[^}]*var\(--warn\)/, 'aging is the warn ink');
   const js = read('collab.js');
-  assert.match(js, /class="fact-pill cb-age cb-age--\$\{band\.id\}"/, 'the pill is the shell\'s fact-pill');
-  assert.match(js, /<div class="ov-row__right">\$\{ageChip\(req, nowMs\)\}/, 'in the right column, so a glance down the list reads the ages');
+  // Both pins stop short of the closing character, because the band's class is
+  // now followed by the room's quiet modifier and ageChip by the baseline that
+  // decides it (task 1004067). What they assert is unchanged: the shell's pill,
+  // in the right column.
+  assert.match(js, /class="fact-pill cb-age cb-age--\$\{band\.id\}/, 'the pill is the shell\'s fact-pill');
+  assert.match(js, /<div class="ov-row__right">\$\{ageChip\(req, nowMs[,)]/, 'in the right column, so a glance down the list reads the ages');
 });
 
 // ---- the copy desk: quieter, and no fact lost ----------------------------------

package/tests/idea_spark_hall.mjs

@@ -400,5 +400,120 @@ await test('the kind control travels with the filing', async () => {
   assert.equal(call[1].body.kind, 'refactor');
 });
 
+// ---------------------------------------------------------------------------
+// task 1004082 / spec R01 — the receipt persists
+//
+// The task as written blamed a keystroke for clearing #fq-result. It does not;
+// the description was amended at build time. What was actually missing: only
+// ONE outcome ever existed (the next filing overwrote it) and it was DOM-only,
+// so a reload lost it. These cases pin the record, not the confirmation line.
+//
+// READ THIS BEFORE TRUSTING THE ONES BELOW: this file's DOM stub MANUFACTURES an
+// element for any id it is handed (getElementById sets on miss), so a test that
+// merely asserts on #fq-receipts-list would stay green if ideas.html never
+// declared it. The markup pin is therefore the load-bearing case here.
+// ---------------------------------------------------------------------------
+
+await test('ideas.html actually declares the receipts markup (the stub would fake it otherwise)', async () => {
+  const html = fs.readFileSync(path.join(HALL, 'ideas.html'), 'utf8');
+  assert.match(html, /id="fq-receipts"/, 'the receipts container is in the real markup');
+  assert.match(html, /id="fq-receipts-list"/, 'and the list the items render into');
+  assert.match(html, /id="fq-result"/, 'the live confirmation line is untouched beside it');
+});
+
+await test('a routed filing writes a receipt that outlives the confirmation line', async () => {
+  const r = boot();
+  await settle(); await settle();
+  r.el('fq-title').value = 'the widget is broken';
+  r.el('fq-goal').value = '77';
+  r.el('fq-goal')._handlers.change();
+  await r.submitQuick();
+  await settle();
+  const stored = JSON.parse(r.store['hall-filing-receipts']);
+  assert.equal(stored.length, 1);
+  assert.equal(stored[0].task_id, '5555');
+  assert.equal(stored[0].title, 'the widget is broken');
+  assert.equal(stored[0].goal_name, 'Goal Seventy Seven');
+  const rendered = r.el('fq-receipts-list').innerHTML;
+  assert.match(rendered, /task 5555/);
+  assert.match(rendered, /Goal Seventy Seven/);
+  assert.equal(r.el('fq-receipts').hidden, false, 'and the section is shown');
+});
+
+await test('a SECOND filing does not overwrite the first — the bug this task exists for', async () => {
+  const r = boot();
+  await settle(); await settle();
+  r.el('fq-title').value = 'the first thought';
+  await r.submitQuick();
+  await settle();
+  r.el('fq-title').value = 'the second thought';
+  await r.submitQuick();
+  await settle();
+  const stored = JSON.parse(r.store['hall-filing-receipts']);
+  assert.equal(stored.length, 2, 'both are kept');
+  assert.equal(stored[0].title, 'the second thought', 'newest first');
+  assert.equal(stored[1].title, 'the first thought', 'and the earlier one survived');
+  const rendered = r.el('fq-receipts-list').innerHTML;
+  assert.match(rendered, /the first thought/, 'the earlier filing is still reachable on the surface');
+});
+
+await test('receipts are read back on load — a filing survives a reload', async () => {
+  const earlier = [{ title: 'filed before the reload', task_id: '4242', goal_name: 'Goal Seventy Seven', href: '/task/4242', at: '2026-09-20T09:00:00Z' }];
+  const r = boot({ store: { 'hall-filing-receipts': JSON.stringify(earlier) } });
+  await settle(); await settle();
+  const rendered = r.el('fq-receipts-list').innerHTML;
+  assert.match(rendered, /filed before the reload/, 'rendered from storage with no filing this session');
+  assert.match(rendered, /task 4242/);
+  assert.equal(r.el('fq-result').textContent, '', 'and the live line is correctly empty — it is not the record');
+});
+
+await test('an unrouted filing is receipted too — "filed to the inbox" is an outcome', async () => {
+  const r = boot();
+  await settle(); await settle();
+  r.el('fq-title').value = 'a homeless thought';
+  await r.submitQuick();
+  await settle();
+  const stored = JSON.parse(r.store['hall-filing-receipts']);
+  assert.equal(stored[0].task_id, null);
+  assert.match(r.el('fq-receipts-list').innerHTML, /filed to the inbox/);
+});
+
+await test('the list is capped at five, keeping the newest', async () => {
+  const old = Array.from({ length: 5 }, (_, i) => ({ title: `old ${i}`, task_id: null, at: '2026-09-20T09:00:00Z' }));
+  const r = boot({ store: { 'hall-filing-receipts': JSON.stringify(old) } });
+  await settle(); await settle();
+  r.el('fq-title').value = 'the newest thought';
+  await r.submitQuick();
+  await settle();
+  const stored = JSON.parse(r.store['hall-filing-receipts']);
+  assert.equal(stored.length, 5, 'still five');
+  assert.equal(stored[0].title, 'the newest thought');
+  assert.ok(!stored.some((x) => x.title === 'old 4'), 'the oldest fell off');
+});
+
+await test('storage that refuses never takes the composer down, and says it is not keeping them', async () => {
+  // The failure a private window / blocked site data actually produces: the
+  // write throws. The filing itself must still complete, and the page must not
+  // claim a receipt it did not keep.
+  const blocked = boot({ store: new Proxy({}, { set() { throw new Error('blocked'); } }) });
+  await settle(); await settle();
+  blocked.el('fq-title').value = 'a thought in a private window';
+  await blocked.submitQuick();
+  await settle();
+  assert.equal(blocked.el('fq-result').textContent, 'Filed to the inbox.', 'the filing still completed');
+  assert.match(blocked.el('fq-receipts-note').textContent, /not keeping receipts/, 'and it says so rather than pretending');
+});
+
+// Every guard was reverted and each redded its named case (run, not assumed):
+//   drop pushReceipt from the routed branch          -> 1 red (the routed case)
+//   write instead of prepend (overwrite the list)    -> 2 red (second-filing + the cap)
+//   drop renderReceipts() from bootQuickComposer     -> 1 red (the reload case)
+//   rename the id in ideas.html                      -> 1 red (the markup pin ONLY)
+//
+// That last line is the one worth reading twice: every DOM-asserting case above
+// stayed GREEN while the real markup was broken, because the stub manufactured
+// the element. Without the markup pin this file would have certified a page
+// that renders nothing.
+
 console.log(`\nidea_spark_hall: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);