@bongos/core 1.19.299 → 1.19.300

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

@@ -0,0 +1,203 @@
+// modules/hall-ui/public/idea.js — the idea-detail PAGE (/idea/:id).
+// Task 1002929 / BV1.R153 of goal 1000062 (three grades of idea).
+//
+// A real page rather than a wider modal, following task 751: that task replaced
+// the #/task/N overlay with /task/:id so a record got a shareable URL and working
+// back/forward. A Full Idea is five prose answers — the thing an overlay is worst
+// at — so it earns the same treatment.
+//
+// THE OVERLAY IS NOT REPLACED. task-detail.js keeps owning #/idea/N, because ~320
+// of its ~650 lines are the Metic+ triage panel (promote → POST /tasks, merge,
+// discard, with goal hints and version pickers). Moving that machinery is its own
+// task; breaking a shipped triage flow to make a read prettier would be a bad
+// trade. So the overlay stays the fast peek and links here, and this page stays a
+// READ — the summary→detail relationship the hall already has between the Work
+// board and /task/:id.
+//
+// WHAT THE GRADE DECIDES. The grade is not decoration on this page, it selects
+// what the page contains:
+//   full  → the five answers, each under its own question, plus the score
+//   spark → the body, plus "someone is invited to develop this"
+//   quick → the body, and NOTHING about the five fields
+// The done-when names that last case explicitly: a quick idea must render with no
+// empty five-field skeleton. Five headings over five dashes is not an empty
+// state, it is a page telling a builder they did something wrong by filing a
+// quick idea — which is the opposite of what a quick idea is for.
+//
+// The five QUESTIONS come from GET /inbox/template, not from this file, for the
+// same reason the composer's do (R152): the labels live in the R141 declaration,
+// and a copy here would silently ignore a per-project template.
+
+(() => {
+  'use strict';
+
+  const API = '/api/gds';
+  const api = window.BongosClient.createClient({ baseUrl: '', credentials: 'same-origin', throwOnError: false });
+  const { escapeHtml, $, fmtDate } = window.OTB;
+
+  const ideaId = () => {
+    const m = /\/idea\/(\d+)/.exec(location.pathname);
+    return m ? m[1] : null;
+  };
+
+  const hallBase = () => (location.hostname.startsWith('builders.') ? '' : '/builders');
+
+  // ---------------------------------------------------------------------------
+  // pieces
+  // ---------------------------------------------------------------------------
+
+  // Colour AND word. A badge distinguished only by hue tells a colour-blind
+  // reader nothing, and this badge decides how to read the whole page.
+  const GRADE_WORD = { full: 'Full Idea', spark: 'Big Idea Spark', quick: 'Quick idea' };
+
+  function gradeBadge(grade) {
+    const g = GRADE_WORD[grade] ? grade : 'quick';
+    return `<span class="ig-grade ig-grade--${escapeHtml(g)}">${escapeHtml(GRADE_WORD[g])}</span>`;
+  }
+
+  function scoreRow(score) {
+    if (!Number.isInteger(score)) {
+      // A Full Idea with no score is a real state (R142 returns null for
+      // anything it cannot score, and that is stored as-is). Say so rather than
+      // drawing an empty bar that reads as zero.
+      return '<p class="ig-empty">Not scored.</p>';
+    }
+    const band = score >= 80 ? 'full' : score >= 40 ? 'part' : 'thin';
+    return `
+      <div class="ig-score">
+        <span class="ig-score__track"><span class="ig-score__fill" data-band="${band}" style="width:${score}%"></span></span>
+        <span class="ig-score__n">${score}/100 complete</span>
+      </div>`;
+  }
+
+  // Who had the thought, and who wrote it out. Two rows when they are two people
+  // — R146's whole point is that the author survives being developed by someone
+  // else, so this never collapses them into one line.
+  function credit(idea) {
+    const who = (login, id) => (login ? `@${escapeHtml(login)}` : (id ? `builder ${escapeHtml(String(id))}` : 'someone'));
+    const rows = [];
+    rows.push(`
+      <div class="ig-credit__row">
+        <span class="ig-credit__who">${who(idea.filed_by_login, idea.captured_by)}</span>
+        <span class="ig-credit__role">had the thought${idea.captured_at ? ` · ${escapeHtml(fmtDate(idea.captured_at))}` : ''}</span>
+      </div>`);
+    if (idea.developed_by) {
+      const same = String(idea.developed_by) === String(idea.captured_by);
+      rows.push(`
+        <div class="ig-credit__row">
+          <span class="ig-credit__who">${who(idea.developed_by_login, idea.developed_by)}</span>
+          <span class="ig-credit__role">${same ? 'developed it themselves' : 'developed it into a Full Idea'}${idea.developed_at ? ` · ${escapeHtml(fmtDate(idea.developed_at))}` : ''}</span>
+        </div>`);
+    }
+    return `<div class="ig-credit">${rows.join('')}</div>`;
+  }
+
+  function prose(text) {
+    const s = String(text == null ? '' : text).trim();
+    return s
+      ? `<p class="ig-body">${escapeHtml(s)}</p>`
+      : '<p class="ig-body" data-empty="1">No description.</p>';
+  }
+
+  // The five answers, in TEMPLATE order, each under its own question. Missing
+  // answers are marked rather than hidden: on a Full Idea a blank answer is
+  // information (it is why the score is what it is).
+  function answers(idea, template) {
+    const values = (idea.field_values && typeof idea.field_values === 'object') ? idea.field_values : {};
+    return `<div class="ig-answers">${template.fields.map((f) => {
+      const v = String(values[f.key] == null ? '' : values[f.key]).trim();
+      return `
+        <div class="ig-answer">
+          <p class="ig-answer__q">${escapeHtml(f.label)}</p>
+          <p class="ig-answer__a"${v ? '' : ' data-empty="1"'}>${v ? escapeHtml(v) : 'Not answered.'}</p>
+        </div>`;
+    }).join('')}</div>`;
+  }
+
+  function statusLine(idea) {
+    const bits = [];
+    bits.push(`<span><strong>${escapeHtml(idea.status || 'open')}</strong></span>`);
+    if (idea.kind) bits.push(`<span>${escapeHtml(idea.kind)}</span>`);
+    if (idea.promoted_to_task_id) {
+      bits.push(`<span>became <a href="${hallBase()}/task/${encodeURIComponent(idea.promoted_to_task_id)}">task ${escapeHtml(String(idea.promoted_to_task_id))}</a></span>`);
+    }
+    if (idea.merged_into_idea_id) {
+      bits.push(`<span>merged into <a href="${hallBase()}/idea/${encodeURIComponent(idea.merged_into_idea_id)}">idea ${escapeHtml(String(idea.merged_into_idea_id))}</a></span>`);
+    }
+    return `<p class="ig-meta">${bits.join('')}</p>`;
+  }
+
+  // ---------------------------------------------------------------------------
+  // render
+  // ---------------------------------------------------------------------------
+
+  function render(idea, template) {
+    const grade = GRADE_WORD[idea.grade] ? idea.grade : 'quick';
+    const parts = [];
+
+    parts.push(`<div class="ig-head">${gradeBadge(grade)}</div>`);
+    parts.push(`<h1 class="ig-title" id="idea-h">${escapeHtml(idea.title || `Idea ${idea.id}`)}</h1>`);
+    parts.push(statusLine(idea));
+    parts.push(credit(idea));
+
+    if (grade === 'full') {
+      parts.push(scoreRow(idea.completeness_score));
+      if (template) {
+        parts.push(answers(idea, template));
+      } else {
+        // The template read failed. Show the raw answers rather than nothing —
+        // but WITHOUT inventing an order, since jsonb key order is not the
+        // template's order and pretending otherwise would misreport the idea.
+        parts.push('<p class="ig-empty">Could not load the question labels; showing the answers as stored.</p>');
+        parts.push(`<div class="ig-answers">${Object.keys(idea.field_values || {}).map((k) =>
+          `<div class="ig-answer"><p class="ig-answer__q">${escapeHtml(k)}</p><p class="ig-answer__a">${escapeHtml(String(idea.field_values[k] || ''))}</p></div>`
+        ).join('')}</div>`);
+      }
+      // A Full Idea's body_md is the original quick-idea text it grew out of, when
+      // it had one. Shown after the answers, subordinate to them.
+      if (String(idea.body_md || '').trim()) {
+        parts.push(`<div class="ig-sub"><h2 class="ig-sub__h">As first filed</h2>${prose(idea.body_md)}</div>`);
+      }
+    } else {
+      // quick AND spark: the body, and NOT a five-field skeleton.
+      parts.push(prose(idea.body_md));
+      if (grade === 'spark') {
+        parts.push(`<p class="ig-note">Its author marked this as needing development — anyone can turn it into a Full Idea, and they keep the credit for having had it. <a href="${hallBase()}/ideas">Write one</a>.</p>`);
+      } else {
+        parts.push('<p class="ig-note">A quick idea is a thought filed fast. It is not an unfinished Full Idea — only its author can offer it up for development.</p>');
+      }
+    }
+
+    $('#idea-body').innerHTML = parts.join('');
+    $('#idea-sub').textContent = `Idea ${idea.id}`;
+    document.title = `${idea.title || `Idea ${idea.id}`} — idea ${idea.id}`;
+  }
+
+  function fail(msg) {
+    $('#idea-body').innerHTML = `<p class="deeplink-card__title" id="idea-h">${escapeHtml(msg)}</p>`;
+    $('#idea-sub').textContent = '';
+  }
+
+  async function main() {
+    const id = ideaId();
+    if (!id) return fail('No idea id in the address.');
+
+    const r = await api.inbox.getInboxId({ id });
+    if (r.status === 401) { window.location.assign(`${API}/auth/web/start`); return; }
+    if (r.status === 404) return fail(`No idea ${id}.`);
+    if (!r.ok || !r.data || !r.data.idea) return fail('Could not load this idea.');
+    const idea = r.data.idea;
+
+    // The labels are only needed for a Full Idea, so a quick idea costs one
+    // request, not two — and a template outage cannot stop a quick idea rendering.
+    let template = null;
+    if (idea.grade === 'full') {
+      const key = idea.template_key;
+      const t = await api.inbox.getInboxTemplate(key ? { query: { template_key: key } } : {});
+      if (t.ok && t.data && t.data.template) template = t.data.template;
+    }
+    render(idea, template);
+  }
+
+  main();
+})();

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

@@ -285,7 +285,10 @@
     renderScore(null);
     note('');
     if (idea && idea.id) {
-      $('#fi-sub').innerHTML = `Filed <a href="/#/idea/${encodeURIComponent(idea.id)}">idea ${escapeHtml(String(idea.id))}</a>. Write another below.`;
+      // The detail PAGE (task 1002929 / R153), not the #/idea/N overlay: the
+      // thing just filed has five prose answers, which is what the page is for.
+      const base = location.hostname.startsWith('builders.') ? '' : '/builders';
+      $('#fi-sub').innerHTML = `Filed <a href="${base}/idea/${encodeURIComponent(idea.id)}">idea ${escapeHtml(String(idea.id))}</a>. Write another below.`;
     }
   }
 

package/modules/hall-ui/public/task-detail.js

@@ -118,6 +118,19 @@
     }
     if (r.shipped_at) nodes.push(h('p', 'deeplink-card__note', 'Shipped ' + fmtRel(r.shipped_at)));
 
+    // task 1002929 (R153): an idea now has a real page, and this card cannot show
+    // a Full Idea's five prose answers legibly — so it stops pretending to and
+    // points at the page instead. The overlay KEEPS the triage panel below (~320
+    // lines of promote/merge/discard); this is the summary→detail relationship the
+    // Work board already has with /task/:id, not a replacement.
+    if (kind === 'idea') {
+      var fv = h('p', 'deeplink-card__note');
+      var fl = h('a', 'deeplink-card__link', r.grade === 'full' ? 'Read the full idea →' : 'Open this idea →');
+      fl.href = hallBase() + '/idea/' + encodeURIComponent(r.id);
+      fv.appendChild(fl);
+      nodes.push(fv);
+    }
+
     // task 759 → task 1002447: Metic+ idea triage, right in the overlay (no
     // /idea-triage skill and no LLM in the loop). 759 shipped Discard alone;
     // 1002447 adds the other two verbs so the whole verdict set is reachable

package/modules/ideas/inbox.js

@@ -507,11 +507,24 @@ async function listOpenIdeas({ kind = null, limit = 50, viewerRank = null } = {}
   return rows;
 }
 
+// The by-id read. It carries the two people's LOGINS as well as their ids
+// (task 1002929 / R153): an idea's attribution is a claim about humans, and
+// "captured_by: 41" is not attribution to anyone reading it. Named to match the
+// R145 spark queue's `filed_by_login` so the two idea surfaces agree.
+//
+// Both joins are LEFT: a builder row can be missing (an FK that went
+// ON DELETE SET NULL), and an idea nobody developed has no developer at all —
+// which is the common case, not an error. A plain JOIN here would drop most of
+// the inbox, the same trap the grade join documents above.
 async function getIdea(id) {
   const { rows } = await pool.query(
-    `SELECT ${IDEA_COLS_Q}, ${GRADE_COLS_Q}
+    `SELECT ${IDEA_COLS_Q}, ${GRADE_COLS_Q},
+            ba.github_login AS filed_by_login,
+            bd.github_login AS developed_by_login
        FROM idea_inbox i
        ${IDEA_JOIN_GRADE}
+       LEFT JOIN builders ba ON ba.id = i.captured_by
+       LEFT JOIN builders bd ON bd.id = g.developed_by
       WHERE i.id = $1`,
     [id]
   );

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.299",
+  "version": "1.19.300",
   "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/bongos/serve-internal.js

@@ -881,9 +881,15 @@ function mountInternalSurfaces(app) {
   // needs its own two-segment match ahead of the single-segment resolution
   // below. Same gate tier as Work/Roadmap/Goals (SIGNEDIN_BUILDERS_PAGE_RE).
   const TASK_DETAIL_PAGE_RE = /^\/builders\/task\/(\d+)\/?$/;
+  // task 1002929 (R153 of goal 1000062): the idea-detail page is the SECOND
+  // two-segment hall page — /builders/idea/:id — for the same reason task 751 gave
+  // the task one: a record with real prose in it deserves a shareable URL and
+  // working back/forward, not a modal. Same gate tier as the task page.
+  const IDEA_DETAIL_PAGE_RE = /^\/builders\/idea\/(\d+)\/?$/;
   function buildersHtmlName(reqPath) {
     if (reqPath === '/builders' || reqPath === '/builders/') return 'index.html';
     if (TASK_DETAIL_PAGE_RE.test(reqPath)) return buildersHtml['task.html'] ? 'task.html' : null;
+    if (IDEA_DETAIL_PAGE_RE.test(reqPath)) return buildersHtml['idea.html'] ? 'idea.html' : null;
     // e.g. /builders/ranks or /builders/ranks.html → ranks.html
     const m = reqPath.match(BUILDERS_PAGE_RE);
     if (m) {
@@ -956,7 +962,7 @@ function mountInternalSurfaces(app) {
     // behind the proxy's path normalization.
     const norm = path.posix.normalize(req.path);
     if (SIGNEDIN_BUILDERS_PAGE_RE.test(norm) || SIGNEDIN_BUILDERS_PREFIX_RE.test(norm)
-      || TASK_DETAIL_PAGE_RE.test(norm)) {
+      || TASK_DETAIL_PAGE_RE.test(norm) || IDEA_DETAIL_PAGE_RE.test(norm)) {
       return gdsAuth.requireBuilderPage(req, res, next);
     }
     next();

package/src/module-api.js

@@ -1025,8 +1025,10 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         landed since 1.19.297 with no explicit bump. run 32597859474. (task 1002620)
 //   1.19.299 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
 //         landed since 1.19.298 with no explicit bump. run 32600322268. (task 1002620)
+//   1.19.300 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.299 with no explicit bump. run 32601521458. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.299'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.300'; // CI auto-patch carrier (ADR 0161); see changelog above
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/idea_detail_page.mjs

@@ -0,0 +1,271 @@
+// tests/idea_detail_page.mjs
+//
+// task 1002929 (BV1.R153, goal 1000062) — the idea-detail page (/idea/:id).
+//
+// The done-when, as assertions:
+//   1. a Full Idea is legible end to end — every question and every answer, in
+//      TEMPLATE order, plus the score;
+//   2. a QUICK idea renders on the same page with NO empty five-field skeleton —
+//      five headings over five dashes is not an empty state, it is a page telling
+//      a builder they were wrong to file a quick idea;
+//   3. spark AND developer attribution are both visible — R146's whole point is
+//      that the author survives being developed by someone else, so a developed
+//      idea must name two people.
+//
+// The page renders by string-building into #idea-body, so this executes the real
+// render path in a minimal DOM stub (the hall_nav.mjs / hall_signout.mjs pattern)
+// and asserts over the HTML a viewer would actually get. Pure vm + file read.
+//
+// Run:  node tests/idea_detail_page.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 SRC = fs.readFileSync(path.join(HALL, 'idea.js'), 'utf8');
+
+const { BASE_TEMPLATE } = require('../modules/ideas/templates.js');
+
+// The template as GET /inbox/template projects it (R152's shape).
+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 })),
+};
+
+// Boot idea.js against a stub DOM + a stub client that answers with `idea`, and
+// return the HTML it wrote into #idea-body.
+function render(idea, { template = TEMPLATE, templateFails = false, ideaStatus = 200 } = {}) {
+  const els = new Map();
+  const makeEl = () => ({
+    dataset: {}, style: {}, textContent: '', hidden: false, _html: '',
+    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+    setAttribute() {}, getAttribute() { return null; }, addEventListener() {},
+    querySelector() { return makeEl(); }, querySelectorAll() { return []; }, appendChild() {},
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+  });
+
+  const documentObj = {
+    title: '',
+    body: { dataset: { page: 'idea' } },
+    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {} } },
+    getElementById(id) { if (!els.has(id)) els.set(id, makeEl()); return els.get(id); },
+    querySelector(sel) { return this.getElementById(String(sel).replace(/^#/, '')); },
+    querySelectorAll() { return []; },
+    createElement() { return makeEl(); },
+    addEventListener() {},
+  };
+
+  const calls = [];
+  const client = {
+    inbox: {
+      getInboxId: async (args) => { calls.push(['idea', args]); return { status: ideaStatus, ok: ideaStatus === 200, data: { idea } }; },
+      getInboxTemplate: async (args) => {
+        calls.push(['template', args]);
+        if (templateFails) return { status: 500, ok: false, data: null };
+        return { status: 200, ok: true, data: { template } };
+      },
+    },
+  };
+
+  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),
+      fmtDate: (iso) => String(iso).slice(0, 10),
+      toast() {},
+    },
+    location: { hostname: 'builders.cloudbongos.com', pathname: `/idea/${idea && idea.id ? idea.id : '1'}`, assign() {} },
+    addEventListener() {},
+  };
+
+  const sandbox = { window: windowObj, document: documentObj, location: windowObj.location, console, setTimeout, clearTimeout };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(SRC, sandbox, { filename: 'idea.js' });
+
+  return { html: () => documentObj.getElementById('idea-body').innerHTML, calls, documentObj };
+}
+
+// The render is async (two awaits at most), so let the microtask queue drain.
+const settle = () => new Promise((r) => setTimeout(r, 0));
+
+const FULL_VALUES = Object.fromEntries(BASE_TEMPLATE.fields.map((f, i) => [f.key, `Answer number ${i + 1}, with enough words in it to read like a real answer.`]));
+
+const fullIdea = {
+  id: '812', title: 'A shared changelog', status: 'open', kind: 'feature',
+  body_md: 'the original quick thought', captured_by: '9', captured_at: '2026-08-01T00:00:00Z',
+  grade: 'full', template_key: 'base-v1', field_values: FULL_VALUES, completeness_score: 88,
+  filed_by_login: 'thinker', developed_by: '42', developed_at: '2026-08-20T00:00:00Z', developed_by_login: 'someone',
+};
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// --- done-when 1: a Full Idea is legible end to end ---------------------
+
+await test('a Full Idea shows every question and every answer, in template order', async () => {
+  const r = render(fullIdea);
+  await settle();
+  const html = r.html();
+  let cursor = -1;
+  for (const f of TEMPLATE.fields) {
+    const qAt = html.indexOf(f.label);
+    assert.ok(qAt > -1, `the question "${f.label}" is on the page`);
+    assert.ok(qAt > cursor, 'questions appear in TEMPLATE order, not jsonb key order');
+    cursor = qAt;
+    assert.ok(html.includes(FULL_VALUES[f.key]), `the answer for ${f.key} is on the page`);
+  }
+});
+
+await test('the score is shown as a number and a bar', async () => {
+  const r = render(fullIdea);
+  await settle();
+  assert.match(r.html(), /88\/100 complete/);
+  assert.match(r.html(), /width:88%/);
+});
+
+await test('a Full Idea with no score says so instead of drawing a zero', async () => {
+  const r = render({ ...fullIdea, completeness_score: null });
+  await settle();
+  assert.match(r.html(), /Not scored/);
+  assert.doesNotMatch(r.html(), /0\/100/);
+});
+
+await test('a blank answer on a Full Idea is marked, not hidden', async () => {
+  const { fit, ...four } = FULL_VALUES;
+  const r = render({ ...fullIdea, field_values: four });
+  await settle();
+  // It is information: it is WHY the score is what it is.
+  assert.ok(r.html().includes('Not answered'));
+  const label = TEMPLATE.fields.find((f) => f.key === 'fit').label;
+  assert.ok(r.html().includes(label), 'the unanswered question is still shown');
+});
+
+// --- done-when 2: a quick idea gets NO five-field skeleton --------------
+
+await test('a QUICK idea shows its body and NOT one of the five questions', async () => {
+  const r = render({
+    id: '5', title: 'a quick thought', status: 'open', body_md: 'just the thought',
+    captured_by: '9', captured_at: '2026-08-01T00:00:00Z', grade: 'quick',
+    template_key: null, field_values: null, completeness_score: null,
+    filed_by_login: 'thinker', developed_by: null, developed_at: null, developed_by_login: null,
+  });
+  await settle();
+  const html = r.html();
+  assert.ok(html.includes('just the thought'));
+  for (const f of TEMPLATE.fields) {
+    assert.ok(!html.includes(f.label), `a quick idea must not show the question "${f.label}"`);
+  }
+  assert.doesNotMatch(html, /Not answered/, 'and no empty answer rows either');
+  assert.doesNotMatch(html, /\/100 complete/, 'nor a completeness bar it has no score for');
+});
+
+await test('a quick idea costs ONE request — the labels are only needed for a full one', async () => {
+  const r = render({ id: '5', title: 't', status: 'open', body_md: 'b', grade: 'quick', captured_by: '9' });
+  await settle();
+  assert.deepEqual(r.calls.map((c) => c[0]), ['idea'], 'no template fetch for a quick idea');
+});
+
+await test('a SPARK shows its body, no skeleton, and says it is open for development', async () => {
+  const r = render({
+    id: '7', title: 'a spark', status: 'open', body_md: 'the seed', grade: 'spark',
+    captured_by: '9', captured_at: '2026-08-01T00:00:00Z', filed_by_login: 'thinker',
+  });
+  await settle();
+  const html = r.html();
+  assert.ok(html.includes('the seed'));
+  assert.match(html, /Big Idea Spark/);
+  assert.match(html, /needing development/);
+  for (const f of TEMPLATE.fields) assert.ok(!html.includes(f.label), 'a spark has no five-field skeleton either');
+});
+
+// --- done-when 3: both attributions visible ----------------------------
+
+await test('a developed idea names TWO people, in their two roles', async () => {
+  const r = render(fullIdea);
+  await settle();
+  const html = r.html();
+  assert.match(html, /@thinker/);
+  assert.match(html, /had the thought/);
+  assert.match(html, /@someone/);
+  assert.match(html, /developed it into a Full Idea/);
+  // The author must come first: the thought precedes the development, and R146
+  // exists so being developed does not displace the person who had it.
+  assert.ok(html.indexOf('@thinker') < html.indexOf('@someone'));
+});
+
+await test('an UNdeveloped idea names one person and invents no developer', async () => {
+  const r = render({ ...fullIdea, developed_by: null, developed_at: null, developed_by_login: null });
+  await settle();
+  const html = r.html();
+  assert.match(html, /had the thought/);
+  assert.doesNotMatch(html, /developed it/);
+});
+
+await test('self-development reads as one person doing both, not a handoff', async () => {
+  const r = render({ ...fullIdea, developed_by: '9', developed_by_login: 'thinker' });
+  await settle();
+  assert.match(r.html(), /developed it themselves/);
+});
+
+await test('a missing login degrades to the builder id, never "@undefined"', async () => {
+  const r = render({ ...fullIdea, filed_by_login: null, developed_by_login: null });
+  await settle();
+  const html = r.html();
+  assert.match(html, /builder 9/);
+  assert.match(html, /builder 42/);
+  assert.doesNotMatch(html, /@undefined|@null|undefined/);
+});
+
+// --- grade badge + plumbing --------------------------------------------
+
+await test('the grade is named in WORDS, not only in colour', async () => {
+  for (const [grade, word] of [['full', 'Full Idea'], ['spark', 'Big Idea Spark'], ['quick', 'Quick idea']]) {
+    const r = render({ ...fullIdea, grade, ...(grade === 'full' ? {} : { field_values: null }) });
+    await settle();
+    assert.ok(r.html().includes(word), `${grade} is spelled "${word}"`);
+  }
+});
+
+await test('an unknown grade falls back to quick rather than rendering nothing', async () => {
+  const r = render({ id: '1', title: 't', body_md: 'b', grade: 'something-new', captured_by: '9' });
+  await settle();
+  assert.match(r.html(), /Quick idea/);
+  assert.ok(r.html().includes('b'));
+});
+
+await test('a template outage still renders the answers, without inventing an order', async () => {
+  const r = render(fullIdea, { templateFails: true });
+  await settle();
+  const html = r.html();
+  assert.match(html, /Could not load the question labels/);
+  for (const v of Object.values(FULL_VALUES)) assert.ok(html.includes(v), 'the answers are still readable');
+});
+
+await test('a promoted idea links to the task it became', async () => {
+  const r = render({ ...fullIdea, status: 'promoted', promoted_to_task_id: '1234' });
+  await settle();
+  assert.match(r.html(), /\/task\/1234/);
+});
+
+await test('a 404 says which idea is missing rather than failing blank', async () => {
+  const r = render({ id: '99' }, { ideaStatus: 404 });
+  await settle();
+  assert.match(r.html(), /No idea 99/);
+});
+
+console.log(`\nidea_detail_page: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);