@bongos/core 1.19.300 → 1.19.301

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

@@ -26,6 +26,15 @@
 // here would be a second copy of a DIFFERENT rule — the exact mistake this file
 // is organised to avoid — so the gauge reports completeness and stops there.
 //
+// TWO MODES, ONE FORM (task 1002930 / R154). Opened plainly, the composer FILES a
+// new Full Idea. Opened as ?develop=<id> from the spark queue below, it DEVELOPS
+// an existing spark: the spark's own words are shown above the fields, its title
+// becomes a read-only fact rather than an editable input (developing an idea must
+// not quietly rename it out from under its author), and filing calls
+// POST /inbox/:id/develop instead of POST /inbox. The five fields, the meter, the
+// validation and the draft behaviour are identical — which is the point of reusing
+// this surface rather than building a second one that drifts from it.
+//
 // DRAFTS ARE LOCAL. "A partial draft is not lost on navigation" is a done-when,
 // and a half-written thought is not something to put in the database: it has no
 // title yet, no grade, and nothing downstream should be able to see it. It lives
@@ -38,9 +47,17 @@
   const api = window.BongosClient.createClient({ baseUrl: '', credentials: 'same-origin', throwOnError: false });
   const { escapeHtml, $, toast } = window.OTB;
 
-  // One key, this page only. Versioned by template key at save time so a project
-  // that changes its template (R156) cannot restore a draft shaped for the old one.
-  const DRAFT_KEY = 'hall-full-idea-draft';
+  // One key per THING BEING WRITTEN. A new idea and a spark being developed are
+  // different drafts, and sharing one key would let a half-written new idea
+  // overwrite someone's development work (or restore itself into it). Versioned by
+  // template key at save time too, so a project that changes its template (R156)
+  // cannot restore a draft shaped for the old one.
+  const developId = () => {
+    const m = /[?&]develop=(\d+)\b/.exec(location.search);
+    return m ? m[1] : null;
+  };
+  const DEVELOP_ID = developId();
+  const DRAFT_KEY = DEVELOP_ID ? `hall-full-idea-draft:develop:${DEVELOP_ID}` : 'hall-full-idea-draft';
   const SCORE_DEBOUNCE_MS = 300;
   const DRAFT_DEBOUNCE_MS = 500;
 
@@ -187,7 +204,9 @@
     // problem, not a capture error). Matching that exactly means the button never
     // promises an outcome the server will refuse, and never blocks one it accepts.
     const missingRequired = template.fields.some((f) => f.required && !fieldEl(f.key).value.trim());
-    $('#fi-submit').disabled = filing || missingRequired || !titleEl().value.trim();
+    // In develop mode the title is the existing idea's and is not editable, so it
+    // cannot be a reason to keep the button off.
+    $('#fi-submit').disabled = filing || missingRequired || (!DEVELOP_ID && !titleEl().value.trim());
   }
 
   async function scoreNow() {
@@ -209,7 +228,7 @@
     // round-trip: it depends only on what is typed.
     if (lastScore) renderScore(lastScore);
     else $('#fi-submit').disabled = filing
-      || !titleEl().value.trim()
+      || (!DEVELOP_ID && !titleEl().value.trim())
       || template.fields.some((f) => f.required && !fieldEl(f.key).value.trim());
   }
 
@@ -251,14 +270,22 @@
     showErr('');
     $('#fi-submit').disabled = true;
 
-    const r = await api.inbox.postInbox({
-      body: {
-        title: titleEl().value.trim(),
-        grade: 'full',
-        template_key: template.key,
-        field_values: collect(),
-      },
-    });
+    // The one behavioural fork between the two modes. Developing is an act on an
+    // EXISTING idea, so it carries no title and no grade: the row already has
+    // both, and R146 preserves them along with its author.
+    const r = DEVELOP_ID
+      ? await api.inbox.postInboxIdDevelop({
+        id: DEVELOP_ID,
+        body: { field_values: collect(), template_key: template.key },
+      })
+      : await api.inbox.postInbox({
+        body: {
+          title: titleEl().value.trim(),
+          grade: 'full',
+          template_key: template.key,
+          field_values: collect(),
+        },
+      });
 
     filing = false;
     if (!r.ok) {
@@ -275,11 +302,19 @@
     // grade write did not, and says so. Repeat that here instead of claiming a
     // Full Idea was stored when the response says otherwise.
     const landedFull = idea && idea.grade === 'full';
-    toast(landedFull
-      ? `Filed as a Full Idea${score == null ? '' : ` — ${score}/100`}.`
-      : 'Filed, but stored as a quick idea — the grade could not be written.');
+    if (DEVELOP_ID) {
+      // The split is the developer's business: they earned a share of it and the
+      // author kept theirs, and saying so is how the handoff stops feeling like
+      // giving work away (R147 / ADR 0185).
+      const credited = r.data && r.data.idea && r.data.idea.ideator_credit;
+      toast(`Developed${score == null ? '' : ` — ${score}/100`}${credited ? `. ${credited} credits split with its author.` : '.'}`);
+    } else {
+      toast(landedFull
+        ? `Filed as a Full Idea${score == null ? '' : ` — ${score}/100`}.`
+        : 'Filed, but stored as a quick idea — the grade could not be written.');
+    }
 
-    titleEl().value = '';
+    if (!DEVELOP_ID) titleEl().value = '';
     for (const f of template.fields) fieldEl(f.key).value = '';
     lastScore = null;
     renderScore(null);
@@ -308,6 +343,79 @@
   // boot
   // ---------------------------------------------------------------------------
 
+  // ---------------------------------------------------------------------------
+  // the spark queue (task 1002930 / R154)
+  // ---------------------------------------------------------------------------
+
+  const hallBase = () => (location.hostname.startsWith('builders.') ? '' : '/builders');
+
+  function renderQueue(sparks, count) {
+    const host = $('#fi-queue');
+    if (!sparks || sparks.length === 0) {
+      // An answer, not a blank space — and it says how one gets here, since the
+      // only way to fill this queue is for an author to offer something up.
+      host.innerHTML = '<p class="fi-queue-empty">Nothing is waiting. A spark appears here when its author offers a quick idea up for development.</p>';
+      return;
+    }
+    const total = Number.isInteger(count) ? count : sparks.length;
+    const more = total > sparks.length ? `<p class="fi-note">Showing ${sparks.length} of ${total}.</p>` : '';
+    host.innerHTML = `<div class="fi-queue">${sparks.map((sp) => {
+      const who = sp.filed_by_login ? `@${escapeHtml(sp.filed_by_login)}` : 'an unnamed builder';
+      const when = sp.captured_at ? ` · ${escapeHtml(String(sp.captured_at).slice(0, 10))}` : '';
+      return `
+        <div class="fi-spark">
+          <p class="fi-spark__title"><a href="${hallBase()}/idea/${encodeURIComponent(sp.id)}">${escapeHtml(sp.title || `Idea ${sp.id}`)}</a></p>
+          <span class="fi-spark__who">had by ${who}${when}</span>
+          <a class="fi-spark__go btn btn--ghost" href="?develop=${encodeURIComponent(sp.id)}">Develop this →</a>
+        </div>`;
+    }).join('')}</div>${more}`;
+  }
+
+  async function loadQueue() {
+    const r = await api.inbox.getInboxSparks({});
+    // The queue is secondary to the composer: an outage here must not stop
+    // someone writing, so it degrades to a line rather than an error state.
+    if (!r.ok || !r.data) {
+      $('#fi-queue').innerHTML = '<p class="fi-queue-empty">Could not load the queue just now.</p>';
+      return;
+    }
+    renderQueue(r.data.sparks, r.data.count);
+  }
+
+  // ---------------------------------------------------------------------------
+  // develop mode
+  // ---------------------------------------------------------------------------
+
+  // Show the spark's own words above the fields, and make the title a FACT rather
+  // than an input. Returns false when the idea cannot be developed, so boot can
+  // say why instead of presenting a form that will 409.
+  function enterDevelopMode(idea) {
+    if (idea.grade !== 'spark') {
+      $('#fi-sub').textContent = idea.grade === 'full'
+        ? `Idea ${idea.id} has already been developed into a Full Idea.`
+        : `Idea ${idea.id} is not a Big Idea Spark — only its author can offer it up for development.`;
+      $('#fi-form').hidden = true;
+      return false;
+    }
+    $('#fi-develop').hidden = false;
+    $('#fi-develop-title').textContent = idea.title || `Idea ${idea.id}`;
+    $('#fi-develop-body').textContent = String(idea.body_md || '').trim();
+    $('#fi-develop-who').textContent = idea.filed_by_login
+      ? `had by @${idea.filed_by_login}${idea.captured_at ? ` · ${String(idea.captured_at).slice(0, 10)}` : ''} — they keep the credit for the thought`
+      : 'they keep the credit for the thought';
+    // The title is the existing idea's. Shown, not editable: developing an idea
+    // must not quietly rename it out from under its author.
+    const t = titleEl();
+    t.value = idea.title || '';
+    t.readOnly = true;
+    t.tabIndex = -1;
+    $('#fi-title-label').hidden = true;
+    t.hidden = true;
+    $('#fi-submit').textContent = 'Develop this idea';
+    $('#fi-sub').textContent = 'Answer the five questions and this spark becomes a Full Idea.';
+    return true;
+  }
+
   async function main() {
     const r = await api.inbox.getInboxTemplate({});
     if (!r.ok || !r.data || !r.data.template) {
@@ -326,6 +434,22 @@
     $('#fi-form').addEventListener('submit', file);
     $('#fi-clear').addEventListener('click', discard);
 
+    // The queue loads on every visit, develop mode or not: having just picked one
+    // up, seeing what else is waiting is the natural next thing.
+    loadQueue();
+
+    if (DEVELOP_ID) {
+      const d = await api.inbox.getInboxId({ id: DEVELOP_ID });
+      if (!d.ok || !d.data || !d.data.idea) {
+        $('#fi-sub').textContent = `Could not load idea ${DEVELOP_ID}.`;
+        $('#fi-form').hidden = true;
+        return;
+      }
+      if (!enterDevelopMode(d.data.idea)) return;
+      // Re-run the button rule now that the title requirement is lifted.
+      onEdit();
+    }
+
     if (usable) {
       note('Draft restored.');
       scoreNow();

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.300",
+  "version": "1.19.301",
   "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

@@ -1027,8 +1027,10 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         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)
+//   1.19.301 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.300 with no explicit bump. run 32602146266. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.300'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.301'; // 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

@@ -41,12 +41,14 @@ const TEMPLATE = {
 
 // 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 } = {}) {
+function render(idea, { template = TEMPLATE, templateFails = false, ideaStatus = 200, viewer = null, sparkResult = null } = {}) {
   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() {},
+    setAttribute() {}, getAttribute() { return null; },
+    _handlers: {},
+    addEventListener(type, fn) { this._handlers[type] = fn; },
     querySelector() { return makeEl(); }, querySelectorAll() { return []; }, appendChild() {},
     set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
   });
@@ -71,7 +73,18 @@ function render(idea, { template = TEMPLATE, templateFails = false, ideaStatus =
         if (templateFails) return { status: 500, ok: false, data: null };
         return { status: 200, ok: true, data: { template } };
       },
+      // R154's mark control. `sparkResult` lets a test drive the failure path.
+      postInboxIdSpark: async (args) => {
+        calls.push(['spark', args]);
+        return sparkResult || { status: 200, ok: true, data: { idea: { ...idea, grade: 'spark' }, sparked: true } };
+      },
+      deleteInboxIdSpark: async (args) => {
+        calls.push(['unspark', args]);
+        return sparkResult || { status: 200, ok: true, data: { idea: { ...idea, grade: 'quick' }, sparked: false } };
+      },
     },
+    // The page reads /me for the author-only control (R154).
+    me: { getMe: async () => { calls.push(['me', null]); return { status: 200, ok: true, data: { builder: viewer } }; } },
   };
 
   const windowObj = {
@@ -92,7 +105,19 @@ function render(idea, { template = TEMPLATE, templateFails = false, ideaStatus =
   vm.createContext(sandbox);
   vm.runInContext(SRC, sandbox, { filename: 'idea.js' });
 
-  return { html: () => documentObj.getElementById('idea-body').innerHTML, calls, documentObj };
+  return {
+    html: () => documentObj.getElementById('idea-body').innerHTML,
+    calls,
+    documentObj,
+    // The mark button is written via innerHTML, so the stub DOM has no real
+    // element for it — idea.js looks it up with $('#ig-mark-btn'), which resolves
+    // to the memoised stub, so its captured click handler is the click.
+    clickMark: () => {
+      const btn = documentObj.getElementById('ig-mark-btn');
+      return btn._handlers.click ? btn._handlers.click() : null;
+    },
+    markBtn: () => documentObj.getElementById('ig-mark-btn'),
+  };
 }
 
 // The render is async (two awaits at most), so let the microtask queue drain.
@@ -176,7 +201,13 @@ await test('a QUICK idea shows its body and NOT one of the five questions', asyn
 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');
+  // Asserted as "no TEMPLATE call", not "exactly one call": R154 added a /me read
+  // for the author-only mark control, which is a legitimate second request. The
+  // invariant was always about the template — the expensive one a quick idea has
+  // no use for — so it is asserted directly rather than via a total count.
+  const kinds = r.calls.map((c) => c[0]);
+  assert.ok(!kinds.includes('template'), 'no template fetch for a quick idea');
+  assert.ok(kinds.includes('idea'), 'the idea itself is read');
 });
 
 await test('a SPARK shows its body, no skeleton, and says it is open for development', async () => {
@@ -267,5 +298,100 @@ await test('a 404 says which idea is missing rather than failing blank', async (
   assert.match(r.html(), /No idea 99/);
 });
 
+// --- R154: the mark control is AUTHOR-ONLY ------------------------------
+
+const AUTHOR = { id: '9', github_login: 'thinker' };
+const OTHER = { id: '77', github_login: 'someone-else' };
+const quick = {
+  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',
+  filed_by_login: 'thinker',
+};
+
+await test('the AUTHOR of an open quick idea is offered the mark', async () => {
+  const r = render(quick, { viewer: AUTHOR });
+  await settle();
+  assert.match(r.html(), /Mark as a Big Idea Spark/);
+});
+
+await test('a NON-author is not — the wall is the route, this is the cosmetic half', async () => {
+  const r = render(quick, { viewer: OTHER });
+  await settle();
+  assert.doesNotMatch(r.html(), /Mark as a Big Idea Spark/);
+  assert.doesNotMatch(r.html(), /Withdraw the spark/);
+});
+
+await test('a signed-out or unknown viewer is offered nothing', async () => {
+  const r = render(quick, { viewer: null });
+  await settle();
+  assert.doesNotMatch(r.html(), /Mark as a Big Idea Spark/);
+});
+
+await test('an author looking at their own SPARK is offered the withdrawal', async () => {
+  const r = render({ ...quick, grade: 'spark' }, { viewer: AUTHOR });
+  await settle();
+  assert.match(r.html(), /Withdraw the spark mark/);
+  assert.doesNotMatch(r.html(), /Mark as a Big Idea Spark/);
+});
+
+await test('no control on a FULL idea — R144 refuses it, so offering it teaches the rule wrong', async () => {
+  const r = render({ ...fullIdea, captured_by: '9' }, { viewer: AUTHOR });
+  await settle();
+  assert.doesNotMatch(r.html(), /Big Idea Spark<\/button>|Mark as a Big Idea Spark/);
+});
+
+await test('no control on a CLOSED idea — marking requires status=open', async () => {
+  for (const status of ['promoted', 'discarded', 'merged']) {
+    const r = render({ ...quick, status }, { viewer: AUTHOR });
+    await settle();
+    assert.doesNotMatch(r.html(), /Mark as a Big Idea Spark/, `status=${status}`);
+  }
+});
+
+await test('marking calls the spark route and re-renders from the SERVER response', async () => {
+  const r = render(quick, { viewer: AUTHOR });
+  await settle();
+  await r.clickMark();
+  await settle();
+  assert.ok(r.calls.some((c) => c[0] === 'spark'), 'POST /inbox/:id/spark was called');
+  // Re-rendered from what came back, not from a locally flipped flag.
+  assert.match(r.html(), /Big Idea Spark/);
+  assert.match(r.html(), /Withdraw the spark mark/);
+});
+
+await test('withdrawing calls the DELETE side', async () => {
+  const r = render({ ...quick, grade: 'spark' }, { viewer: AUTHOR });
+  await settle();
+  await r.clickMark();
+  await settle();
+  assert.ok(r.calls.some((c) => c[0] === 'unspark'));
+  assert.match(r.html(), /Quick idea/);
+});
+
+await test('a refusal shows the server\'s reason, in the author\'s terms', async () => {
+  const { envelope } = require('../src/bongos/api-errors.js');
+  const cases = [
+    ['not_your_idea', /Only the builder who filed this idea/],
+    ['not_a_quick_idea', /already a Full Idea/],
+    ['idea_not_open', /no longer open/],
+  ];
+  for (const [code, expect] of cases) {
+    const r = render(quick, { viewer: AUTHOR, sparkResult: { status: 409, ok: false, data: envelope(code) } });
+    await settle();
+    await r.clickMark();
+    await settle();
+    assert.match(r.documentObj.getElementById('ig-mark-err').textContent, expect, code);
+  }
+});
+
+await test('a failed mark re-enables the button rather than dead-ending', async () => {
+  const { envelope } = require('../src/bongos/api-errors.js');
+  const r = render(quick, { viewer: AUTHOR, sparkResult: { status: 500, ok: false, data: envelope('boom') } });
+  await settle();
+  await r.clickMark();
+  await settle();
+  assert.equal(r.markBtn().disabled, false);
+});
+
 console.log(`\nidea_detail_page: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);

package/tests/idea_hall_composer.mjs

@@ -242,5 +242,56 @@ await test('neither read touches the database', async () => {
   assert.equal(touched, 0, 'both are pure — which is what makes a call per keystroke reasonable');
 });
 
+// --- R154: the spark queue + develop mode, as source invariants ----------
+//
+// The composer's runtime is exercised through the page's own DOM in
+// tests/idea_spark_hall.mjs; these are the invariants that are cheapest and most
+// durable to assert over the source, because each one is a rule about WHICH
+// endpoint gets called and a mistake in it silently does the wrong write.
+
+await test('develop mode files through the DEVELOP route, not a new capture', () => {
+  assert.match(IDEAS_JS, /postInboxIdDevelop/, 'developing calls POST /inbox/:id/develop');
+  assert.match(IDEAS_JS, /postInbox\b/, 'and filing a new idea still calls POST /inbox');
+  // The fork must be on the develop id, not on anything guessable from the form.
+  assert.match(IDEAS_JS, /DEVELOP_ID\s*\n?\s*\?\s*await api\.inbox\.postInboxIdDevelop/, 'the fork keys off the develop id');
+});
+
+await test('a develop POST carries no title and no grade', () => {
+  // The row already has both, and R146 preserves them along with its author —
+  // sending either would be this surface asserting authority over someone else's
+  // idea. Scoped to the develop branch so the new-capture body is unaffected.
+  const from = IDEAS_JS.indexOf('postInboxIdDevelop');
+  const body = IDEAS_JS.slice(from, IDEAS_JS.indexOf('})', from));
+  assert.ok(!/title:/.test(body), 'no title in the develop body');
+  assert.ok(!/grade:/.test(body), 'no grade in the develop body');
+  assert.match(body, /field_values/);
+});
+
+await test('the develop draft is keyed per idea, so it cannot collide with a new one', () => {
+  // Sharing one key would let a half-written new idea overwrite development work.
+  assert.match(IDEAS_JS, /develop:\$\{DEVELOP_ID\}/);
+});
+
+await test('the queue is read from the R145 endpoint, not rebuilt from the inbox', () => {
+  assert.match(IDEAS_JS, /getInboxSparks/);
+  // And it links each row at the R153 page rather than the overlay.
+  assert.match(IDEAS_JS, /\/idea\/\$\{encodeURIComponent\(sp\.id\)\}/);
+});
+
+await test('the develop block ships HIDDEN — plain mode must not flash it', () => {
+  // The runtime test cannot see this (its stub DOM does not parse markup), so the
+  // attribute is pinned here, over the HTML itself.
+  assert.match(IDEAS_HTML, /id="fi-develop"[^>]*\shidden/, '#fi-develop carries the hidden attribute');
+});
+
+await test('the queue never blocks the composer', () => {
+  // The composer is the page's job; the queue is context. An outage in the
+  // secondary read must not take the primary surface down with it.
+  const from = IDEAS_JS.indexOf('async function loadQueue');
+  const fn = IDEAS_JS.slice(from, IDEAS_JS.indexOf('\n  }', from));
+  assert.match(fn, /if \(!r\.ok/, 'it handles its own failure');
+  assert.ok(!/throw/.test(fn), 'and never throws into boot');
+});
+
 console.log(`\nidea_hall_composer: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);