@bongos/core 1.19.1008 → 1.19.1009

package/tests/fixtures/ideator-prefold/ideas.js.baseline

@@ -0,0 +1,962 @@
+// modules/hall-ui/public/ideas.js — the hall "Ideas" tab (/builders/ideas).
+// Task 1002928 / BV1.R152 of goal 1000062 (three grades of idea).
+//
+// WHY THE HALL AT ALL (the owner's principle, recorded on the goal): anything
+// fundamentally simple, that does not need the Claude terminal, should be doable
+// inside the builders hall. Writing down a thought is exactly that — so a Full
+// Idea can be authored and filed here without a terminal, which is this task's
+// first done-when.
+//
+// THE ONE RULE THIS FILE OBEYS: IT CONTAINS NO RULES.
+// Not the five questions, not their character floors, not the scoring
+// arithmetic. The done-when says the meter must reflect the REAL scorer, "not a
+// second copy of the rules", and the cheapest way to violate that is not a
+// re-implemented formula — it is five hand-written <textarea> elements, which
+// quietly fork the template one step before any scoring happens. So:
+//
+//   the FORM   is rendered from GET  /inbox/template   (the R141 declaration)
+//   the METER  is filled   from POST /inbox/score      (the R142 scorer itself)
+//
+// Both are pure server calls with no DB behind them, which is what makes a
+// debounced call per keystroke reasonable.
+//
+// WHAT THE METER DELIBERATELY DOES NOT SAY: whether this will PASS. The pass bar
+// lives in the economy module with the credit it gates (and the board applies its
+// own), and the ideas scorer is documented as bar-AGNOSTIC. Printing a threshold
+// 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
+// in localStorage under one key, is restored on load, and is cleared only when
+// the idea is actually filed.
+
+(() => {
+  'use strict';
+
+  // NO baseUrl OVERRIDE — this page calls the GENERATED namespaced methods
+  // (api.inbox.*, api.me.*), whose path templates are API-RELATIVE ('/inbox/template').
+  // baseUrl:'' means "these paths are already absolute" and passes them through
+  // unchanged, which sent every request to the SITE ROOT and 404'd — this page was
+  // dead in production from the day it shipped. Letting it default resolves them
+  // against '/api/bongos/v1' (api-prefix.js VERSIONED_API_PREFIX), where the router
+  // actually mounts. A page that DOES pass baseUrl:'' must build full paths itself
+  // via api.request('GET', `${API}/...`) as work.js/copy-desk.js do — never mix the two.
+  const api = window.BongosClient.createClient({ credentials: 'same-origin', throwOnError: false });
+  const { escapeHtml, $, toast } = window.OTB;
+
+  // 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;
+
+  let template = null;      // { key, label, fields: [{key,label,required,substance_min}] }
+  let lastScore = null;
+  let scoreTimer = null;
+  let draftTimer = null;
+  let filing = false;
+
+  // QUICK FILING (task 1003069 / R08, goal 1000071 "Idea routing"). A second,
+  // independent capture path on this page: title + kind + optional body + a
+  // goal picker fed by the R07 suggester (GET /goals/suggestions). It lives
+  // beside the Full Idea form above rather than inside it — a routed capture
+  // must never carry grade='full' (routing.js NEVER_ROUTE_GRADE), so the two
+  // cannot share one submit. Quick-mode only: hidden while developing a spark.
+  const QUICK_SUGGEST_DEBOUNCE_MS = 300;
+  let buildingVersionIds = [];   // fetched once — the suggester is scoped per version
+  let allOpenGoals = [];         // the picker's "browse everything" half
+  let allGoalsById = new Map();  // for naming the goal a routed capture landed in
+  let goalTouchedByUser = false; // once the builder picks, stop clobbering it with fresh suggestions
+  let quickSuggestTimer = null;
+  let quickFiling = false;
+  // GRAVITY (task 1004083 / spec R02). The landing verdict for the draft as it
+  // currently stands, read from POST /inbox/preview-landing. A monotonic token
+  // guards against the out-of-order arrival a debounced-but-concurrent read
+  // invites: two previews in flight can land in either order, and the older one
+  // winning would leave the line describing a draft that no longer exists.
+  let gravitySeq = 0;
+
+  // ---------------------------------------------------------------------------
+  // draft persistence
+  // ---------------------------------------------------------------------------
+
+  // Every localStorage access is wrapped: a private window, cleared site data or
+  // a browser set to block storage all THROW on read, and losing the draft
+  // feature must never take the composer down with it (the shell.js NAV_COLLAPSE
+  // precedent, which guards the same way).
+  function readDraft() {
+    try {
+      const raw = window.localStorage.getItem(DRAFT_KEY);
+      if (!raw) return null;
+      const d = JSON.parse(raw);
+      return (d && typeof d === 'object') ? d : null;
+    } catch (_) { return null; }
+  }
+
+  function writeDraft() {
+    if (!template) return;
+    try {
+      window.localStorage.setItem(DRAFT_KEY, JSON.stringify({
+        template_key: template.key,
+        title: titleEl().value,
+        field_values: collect(),
+        // BV2.R13: a half-written thought includes the scope its author has in
+        // mind for it; losing that on navigation is the same loss as losing a
+        // paragraph.
+        recommendation: collectRecommendation(),
+        at: new Date().toISOString(),
+      }));
+      note('Draft saved in this browser.');
+    } catch (_) {
+      // Storage refused. Say so once rather than pretending it saved — a builder
+      // who believes a draft is safe and navigates away loses the thought.
+      note('This browser is not storing drafts — keep the tab open.');
+    }
+  }
+
+  function clearDraft() {
+    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;
+  }
+
+  // ---------------------------------------------------------------------------
+  // the form, rendered from the template declaration
+  // ---------------------------------------------------------------------------
+
+  const titleEl = () => $('#fi-title');
+  const fieldEl = (key) => document.getElementById(`fi-f-${key}`);
+
+  function renderForm(draft) {
+    const host = $('#fi-fields');
+    host.innerHTML = template.fields.map((f) => `
+      <div class="fi-field" data-key="${escapeHtml(f.key)}">
+        <label class="fi-label" for="fi-f-${escapeHtml(f.key)}">
+          ${escapeHtml(f.label)}${f.required ? '' : ' <span class="fi-hint">(optional)</span>'}
+        </label>
+        <textarea id="fi-f-${escapeHtml(f.key)}" class="fi-text" rows="4"
+                  data-key="${escapeHtml(f.key)}"
+                  placeholder="…"></textarea>
+        <p class="fi-fieldnote" id="fi-n-${escapeHtml(f.key)}"></p>
+      </div>
+    `).join('');
+
+    // Restore BEFORE wiring listeners, so restoring does not itself fire a save.
+    if (draft && draft.field_values) {
+      for (const f of template.fields) {
+        const v = draft.field_values[f.key];
+        if (typeof v === 'string') fieldEl(f.key).value = v;
+      }
+    }
+    if (draft && typeof draft.title === 'string') titleEl().value = draft.title;
+
+    for (const f of template.fields) {
+      fieldEl(f.key).addEventListener('input', onEdit);
+    }
+    titleEl().addEventListener('input', onEdit);
+
+    renderRecommendation(draft);
+
+    $('#fi-meter').hidden = false;
+    renderMeterSkeleton();
+  }
+
+  function collect() {
+    const out = {};
+    for (const f of template.fields) out[f.key] = fieldEl(f.key).value;
+    return out;
+  }
+
+  // ---------------------------------------------------------------------------
+  // the scope recommendation (task 1004092 / BV2.R13, spec R22)
+  // ---------------------------------------------------------------------------
+  //
+  // NOT A SIXTH TEXTAREA, and deliberately not collected into `field_values`:
+  // the five answers are prose the scorer measures, and this is a two-value
+  // choice nothing scores. It travels as its own body field, so the meter
+  // above never moves when it is picked.
+  //
+  // THE OPTIONS COME FROM THE SERVER, like the fields. The vocabulary is a
+  // database CHECK constraint; hard-coding the pair here would be the "second
+  // copy of the rules" defect this whole file is organised against, and would
+  // silently omit any value a later migration admits.
+  //
+  // REQUIRED HERE, OPTIONAL AT THE API — which is not a contradiction. The
+  // hall is where the question is actually put to a person, so filing from it
+  // without answering would be filing an unanswered question. The route stays
+  // permissive because hundreds of already-filed Full Ideas carry no
+  // recommendation and a terse CLI filing may carry none either; every reader
+  // therefore has to render the absence honestly regardless, and a required
+  // body field would 400 every already-shipped client.
+
+  function recSpec() {
+    return (template && template.recommendation) || null;
+  }
+
+  function renderRecommendation(draft) {
+    const host = $('#fi-rec');
+    if (!host) return;
+    const spec = recSpec();
+    // An instance whose template read predates this question simply has no
+    // control — the composer keeps working and files without one.
+    if (!spec || !Array.isArray(spec.options) || !spec.options.length) {
+      host.innerHTML = '';
+      return;
+    }
+    const picked = draft && typeof draft.recommendation === 'string' ? draft.recommendation : '';
+    host.innerHTML = `
+      <fieldset class="fi-rec__set">
+        <legend class="fi-label">${escapeHtml(spec.label || 'What do you think this is')}</legend>
+        ${spec.hint ? `<p class="fi-hint fi-rec__hint">${escapeHtml(spec.hint)}</p>` : ''}
+        ${spec.options.map((o) => `
+          <label class="fi-rec__opt">
+            <input type="radio" name="fi-rec-choice" value="${escapeHtml(o.value)}"${o.value === picked ? ' checked' : ''}>
+            <span>${escapeHtml(o.label || o.value)}</span>
+          </label>`).join('')}
+      </fieldset>`;
+    // onEdit, not a bespoke handler: picking an option has to save the draft
+    // and re-evaluate the file button exactly as typing does. It cannot change
+    // the score, and scoreNow is a no-op for it beyond one wasted call — which
+    // the debounce already collapses.
+    for (const el of host.querySelectorAll('input[name="fi-rec-choice"]')) {
+      el.addEventListener('change', onEdit);
+    }
+  }
+
+  function collectRecommendation() {
+    const host = $('#fi-rec');
+    const picked = host && host.querySelector('input[name="fi-rec-choice"]:checked');
+    return picked ? picked.value : '';
+  }
+
+  function clearRecommendation() {
+    const host = $('#fi-rec');
+    if (!host) return;
+    for (const el of host.querySelectorAll('input[name="fi-rec-choice"]')) el.checked = false;
+  }
+
+  // Whether the composer may file. Only true when the server actually offered
+  // the choice — an instance that serves no `recommendation` spec must not have
+  // its file button held hostage by a control that was never rendered.
+  function recommendationMissing() {
+    const spec = recSpec();
+    if (!spec || !Array.isArray(spec.options) || !spec.options.length) return false;
+    return !collectRecommendation();
+  }
+
+  // ---------------------------------------------------------------------------
+  // the meter — every number in it came from the server
+  // ---------------------------------------------------------------------------
+
+  function renderMeterSkeleton() {
+    $('#fi-meter-list').innerHTML = template.fields.map((f) => `
+      <li class="fi-mrow" id="fi-m-${escapeHtml(f.key)}">
+        <span class="fi-mrow__l">${escapeHtml(f.label)}</span>
+        <span class="fi-mrow__bar"><span class="fi-mrow__fill" style="width:0%"></span></span>
+      </li>
+    `).join('');
+  }
+
+  function renderScore(payload) {
+    lastScore = payload;
+    const score = payload && Number.isInteger(payload.score) ? payload.score : null;
+    const fill = $('#fi-gauge-fill');
+    const num = $('#fi-gauge-n');
+    fill.style.width = `${score == null ? 0 : score}%`;
+    // Three bands, and they describe the TEXT rather than a verdict: this number
+    // is not a pass mark (see the header note), so the words must not imply one.
+    fill.dataset.band = score == null ? 'none' : (score >= 80 ? 'full' : score >= 40 ? 'part' : 'thin');
+    num.textContent = score == null ? '—' : `${score}/100`;
+
+    const byKey = new Map((payload && payload.fields ? payload.fields : []).map((f) => [f.key, f]));
+    for (const f of template.fields) {
+      const row = document.getElementById(`fi-m-${f.key}`);
+      const s = byKey.get(f.key);
+      const pct = s ? Math.round(s.ratio * 100) : 0;
+      if (row) row.querySelector('.fi-mrow__fill').style.width = `${pct}%`;
+      // Per-field prose under the textarea: how much more text this answer wants
+      // before it stops costing the total. `floor` and `substance` are the
+      // server's numbers — this only subtracts them.
+      const n = document.getElementById(`fi-n-${f.key}`);
+      if (!n) continue;
+      if (!s || s.substance === 0) { n.textContent = ''; continue; }
+      const missing = Math.max(0, s.floor - s.substance);
+      n.textContent = missing > 0
+        ? `about ${missing} more characters before this answer counts in full`
+        : 'counts in full';
+      n.dataset.ok = missing > 0 ? '0' : '1';
+    }
+
+    // The file button turns on when every REQUIRED field has something in it —
+    // capture validation's actual rule (R143 refuses a missing required field and
+    // does NOT enforce the substance floor, because a thin answer is a scoring
+    // 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.
+    //
+    // THE SCOPE RECOMMENDATION IS THE ONE PLACE THIS BUTTON IS STRICTER THAN
+    // THE ROUTE (BV2.R13). The route accepts a Full Idea without one, because
+    // the historical rows have none; the hall does not, because the hall is
+    // where the question was actually asked. See renderRecommendation.
+    const missingRequired = template.fields.some((f) => f.required && !fieldEl(f.key).value.trim())
+      || recommendationMissing();
+    // 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() {
+    const body = { field_values: collect() };
+    if (template.key) body.template_key = template.key;
+    const r = await api.inbox.postInboxScore({ body });
+    // A scoring hiccup must not stop someone writing. The gauge simply stops
+    // updating; the composer keeps working and filing still validates server-side.
+    if (!r.ok) { note('Could not reach the scorer just now — you can still file.'); return; }
+    renderScore(r.data);
+  }
+
+  function onEdit() {
+    clearTimeout(scoreTimer);
+    clearTimeout(draftTimer);
+    scoreTimer = setTimeout(() => { scoreNow(); }, SCORE_DEBOUNCE_MS);
+    draftTimer = setTimeout(writeDraft, DRAFT_DEBOUNCE_MS);
+    // Re-evaluate the button on the keystroke rather than waiting for the score
+    // round-trip: it depends only on what is typed.
+    if (lastScore) renderScore(lastScore);
+    else $('#fi-submit').disabled = filing
+      || (!DEVELOP_ID && !titleEl().value.trim())
+      || template.fields.some((f) => f.required && !fieldEl(f.key).value.trim())
+      || recommendationMissing();
+  }
+
+  // ---------------------------------------------------------------------------
+  // filing
+  // ---------------------------------------------------------------------------
+
+  function showErr(msg) {
+    const el = $('#fi-err');
+    el.textContent = msg || '';
+    el.dataset.visible = msg ? '1' : '0';
+  }
+
+  // The server names the field it refused (R143's done-when). Render that rather
+  // than a generic failure, and point at the field so it can be found.
+  function explainFiling(status, data) {
+    const err = data && data.error;
+    const code = err && typeof err === 'object' ? err.code : err;
+    const details = (err && typeof err === 'object' && err.details) || {};
+    if (code === 'invalid_field_values') {
+      const errors = Array.isArray(details) ? details : (details.errors || []);
+      const labelOf = (k) => {
+        const f = template.fields.find((x) => x.key === k);
+        return f ? f.label : (k || 'the idea');
+      };
+      return errors.length
+        ? `Not filed — ${errors.map((e) => `${labelOf(e.field)}: ${String(e.reason || '').replace(/_/g, ' ')}`).join('; ')}`
+        : 'Not filed — the five answers were refused.';
+    }
+    if (code === 'validation_failed') return 'Not filed — the title is required and must be under 200 characters.';
+    if (status === 401 || status === 403) return 'Not filed — your session may have expired. Reload and try again.';
+    return `Not filed (${status}). Nothing was saved; your draft is still here.`;
+  }
+
+  async function file(ev) {
+    ev.preventDefault();
+    if (filing) return;
+    filing = true;
+    showErr('');
+    $('#fi-submit').disabled = true;
+
+    // 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.
+    // BV2.R13: the recommendation travels on BOTH paths, and only when one was
+    // actually picked — sending '' would be asserting an opinion nobody gave.
+    const rec = collectRecommendation();
+    const r = DEVELOP_ID
+      ? await api.inbox.postInboxIdDevelop({
+        id: DEVELOP_ID,
+        body: { field_values: collect(), template_key: template.key, ...(rec ? { recommendation: rec } : {}) },
+      })
+      : await api.inbox.postInbox({
+        body: {
+          title: titleEl().value.trim(),
+          grade: 'full',
+          template_key: template.key,
+          field_values: collect(),
+          ...(rec ? { recommendation: rec } : {}),
+        },
+      });
+
+    filing = false;
+    if (!r.ok) {
+      showErr(explainFiling(r.status, r.data));
+      renderScore(lastScore);
+      return;
+    }
+
+    // Filed. NOW the draft goes — not before, so a failed POST never costs the text.
+    clearDraft();
+    const idea = r.data && r.data.idea;
+    const score = idea && Number.isInteger(idea.completeness_score) ? idea.completeness_score : null;
+    // The capture path is fail-open on grading (R143): the idea lands even if the
+    // 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';
+    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.');
+    }
+
+    if (!DEVELOP_ID) titleEl().value = '';
+    for (const f of template.fields) fieldEl(f.key).value = '';
+    clearRecommendation();
+    lastScore = null;
+    renderScore(null);
+    note('');
+    if (idea && idea.id) {
+      // 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.`;
+    }
+  }
+
+  function discard() {
+    if (!template) return;
+    clearDraft();
+    titleEl().value = '';
+    for (const f of template.fields) fieldEl(f.key).value = '';
+    clearRecommendation();
+    lastScore = null;
+    renderScore(null);
+    showErr('');
+    note('Draft discarded.');
+    toast('Draft discarded.');
+  }
+
+  // ---------------------------------------------------------------------------
+  // quick filing — kind + goal picker (task 1003069 / R08)
+  // ---------------------------------------------------------------------------
+
+  const fqTitleEl = () => $('#fq-title');
+  const fqKindEl = () => $('#fq-kind');
+  const fqBodyEl = () => $('#fq-body');
+  const fqGoalEl = () => $('#fq-goal');
+
+  // The picker's options: "no goal" first (the default — a filer never has to
+  // know the goal map, C5), then whatever the suggester found, then every open
+  // goal it didn't. Suggested ids are excluded from the second list rather than
+  // shown twice.
+  function renderGoalOptions(suggested) {
+    const sel = fqGoalEl();
+    const suggestedIds = new Set((suggested || []).map((g) => String(g.id)));
+    const rest = allOpenGoals.filter((g) => !suggestedIds.has(String(g.id)));
+    const optionHtml = (g, why) => `<option value="${escapeHtml(String(g.id))}">${escapeHtml(g.title || `goal ${g.id}`)}${why ? ` — matched: ${escapeHtml(why)}` : ''}</option>`;
+    let html = `<option value="" selected>No goal (homeless)</option>`;
+    if (suggested && suggested.length) {
+      html += `<optgroup label="Suggested">${suggested.map((g) => optionHtml(g, (g.matched_terms || []).join(', '))).join('')}</optgroup>`;
+    }
+    html += `<optgroup label="All open goals">${rest.map((g) => optionHtml(g)).join('')}</optgroup>`;
+    sel.innerHTML = html;
+  }
+
+  // The suggester is ranked per version (GET /goals/suggestions requires one),
+  // so a filer whose instance has more than one version building gets both
+  // consulted and merged by score. An outage — or no building version at all —
+  // degrades to "no suggestions"; the homeless option and the full goal list
+  // are still there either way (goal-suggest.js's own fail-open contract).
+  async function refreshGoalSuggestions() {
+    if (goalTouchedByUser) return; // never yank a manual pick out from under someone
+    const title = fqTitleEl().value.trim();
+    if (!title || !buildingVersionIds.length) { renderGoalOptions([]); return; }
+    const kind = fqKindEl().value;
+    try {
+      const results = await Promise.all(buildingVersionIds.map((versionId) => api.goals.getGoalsSuggestions({
+        query: { version: versionId, title, kind, limit: 5 },
+      })));
+      const byId = new Map();
+      for (const r of results) {
+        if (!r.ok || !r.data || !Array.isArray(r.data.suggestions)) continue;
+        for (const g of r.data.suggestions) {
+          const prev = byId.get(String(g.id));
+          if (!prev || g.score > prev.score) byId.set(String(g.id), g);
+        }
+      }
+      const merged = Array.from(byId.values()).sort((a, b) => b.score - a.score).slice(0, 5);
+      renderGoalOptions(merged);
+    } catch (_) {
+      renderGoalOptions([]);
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // gravity — which goal will catch this thought, said before it is released
+  // (task 1004083 / spec R02)
+  // ---------------------------------------------------------------------------
+
+  const fqGravityEl = () => $('#fq-gravity');
+
+  // THE SENTENCES, AND NOTHING ELSE. Every branch below READS a field of the
+  // server's verdict; not one of them decides a landing. That split is the whole
+  // point of the endpoint: modules/ideas/routing.js `decideLanding` stays the one
+  // place the matrix lives, and a second copy of it in this file is precisely the
+  // failure the #fq-kind comment above already records ("this markup used to
+  // spell the whole vocabulary and had gone stale ... a third copy nobody was
+  // watching"). If a sentence here ever needs an `if` over kind or rank, the
+  // verdict is missing a field and the fix belongs on the server.
+  //
+  // Returns null for "say nothing" — an unscorable draft, or a read that failed.
+  // Silence is the honest degraded state: it leaves the filer exactly where they
+  // were before this feature, rather than replacing a quiet lie with a loud one.
+  function gravitySentence(v) {
+    if (!v || !v.outcome) return null;
+    const goalName = v.goal ? (v.goal.title || `goal ${v.goal.id}`) : null;
+    const claimable = v.status === 'ready';
+
+    if (v.outcome === 'refused') {
+      // The protected-scope wall. The server wrote the reason for a human; it is
+      // the one branch that already reads as a sentence, so it is passed through.
+      return { tone: 'refused', text: v.refusal && v.refusal.reason ? v.refusal.reason : `${goalName} will not take this filing.` };
+    }
+    if (v.outcome === 'routed') {
+      return {
+        tone: 'lands',
+        text: claimable
+          ? `This lands in ${goalName} as a task anyone can claim.`
+          : `This lands in ${goalName}, waiting for a nod before anyone can claim it.`,
+      };
+    }
+    if (v.outcome === 'routed_home') {
+      // The label on the picker says "homeless"; since ADR 0262 that is not true
+      // of a bug, and this line is the correction. Naming the version rather than
+      // the goal is deliberate — the maintenance goal is created by the capture,
+      // so the preview has no row to name without making one (landing-preview.js).
+      return {
+        tone: 'lands',
+        text: claimable
+          ? `A bug always lands. With no goal picked this goes to ${v.version_id}'s maintenance goal, claimable straight away.`
+          : `A bug always lands. With no goal picked this goes to ${v.version_id}'s maintenance goal, waiting for a nod.`,
+      };
+    }
+    // outcome === 'floats' — the inbox. Two ways to get here, and they are
+    // different facts: nobody named a goal, or a goal was named and the matrix
+    // declined it. The second is the one the picker currently lies about.
+    if (v.reason === 'judgment_kind') {
+      return { tone: 'floats', text: `${goalName} will not catch this — this kind is judged, not queued. It waits in the inbox for triage.` };
+    }
+    if (v.reason === 'full_idea_never_routes') {
+      return { tone: 'floats', text: 'A Full Idea is ratified by the board rather than routed. It waits in the inbox.' };
+    }
+    return { tone: 'floats', text: 'This floats in the inbox until someone triages it.' };
+  }
+
+  function renderGravity(v) {
+    const el = fqGravityEl();
+    if (!el) return;
+    const said = gravitySentence(v);
+    // dataset, not setAttribute: it writes the same data-tone the sheet selects
+    // on, and it is the half of the element a DOM the page is rendered into and
+    // a test stub both really carry.
+    if (!said) { el.hidden = true; el.textContent = ''; el.dataset.tone = ''; return; }
+    el.textContent = said.text;
+    el.dataset.tone = said.tone;
+    el.hidden = false;
+  }
+
+  // The read. Shares the suggester's debounce rather than adding a second clock:
+  // the two answer the same question at the same moment ("given what is typed so
+  // far, where does this go?"), and spec decision 12 — filing never gets slower —
+  // is a reason not to grow the number of things a keystroke sets running.
+  //
+  // A draft with no title is not previewed: it cannot be filed either, so there
+  // is no outcome to state.
+  async function refreshGravity() {
+    const seq = ++gravitySeq;
+    const title = fqTitleEl().value.trim();
+    if (!title) { renderGravity(null); return; }
+    const goalId = fqGoalEl().value;
+    const body = { kind: fqKindEl().value };
+    if (goalId) body.goal_id = Number(goalId);
+    let r;
+    try {
+      r = await api.inbox.postInboxPreviewLanding({ body });
+    } catch (_) {
+      r = null;
+    }
+    // A stale answer never paints. See gravitySeq above.
+    if (seq !== gravitySeq) return;
+    renderGravity(r && r.ok ? r.data : null);
+  }
+
+  function onQuickTitleEdit() {
+    clearTimeout(quickSuggestTimer);
+    quickSuggestTimer = setTimeout(() => { refreshGoalSuggestions(); refreshGravity(); }, QUICK_SUGGEST_DEBOUNCE_MS);
+  }
+
+  function showQuickErr(msg) {
+    $('#fq-err').textContent = msg || '';
+  }
+
+  // The server names why a routed capture was refused (task 1003066's landing
+  // gate) or names the refusal code when it doesn't — read it, never re-derive
+  // the landing matrix here (routing.js stays the one place that decides).
+  function explainQuickFiling(status, data) {
+    const err = data && data.error;
+    const code = err && (typeof err === 'object' ? err.code : err);
+    const details = (err && typeof err === 'object' && err.details) || {};
+    if (details.reason) return `Not filed — ${details.reason}`;
+    if (code) return `Not filed — ${code}.`;
+    if (status === 401 || status === 403) return 'Not filed — your session may have expired. Reload and try again.';
+    return `Not filed (${status}). Nothing was saved — try again.`;
+  }
+
+  async function fileQuick(ev) {
+    ev.preventDefault();
+    if (quickFiling) return;
+    const title = fqTitleEl().value.trim();
+    showQuickErr('');
+    $('#fq-result').innerHTML = '';
+    if (!title) { showQuickErr('Not filed — a title is required.'); return; }
+    quickFiling = true;
+    $('#fq-submit').disabled = true;
+
+    const goalId = fqGoalEl().value;
+    const body = { title, body_md: fqBodyEl().value, kind: fqKindEl().value };
+    if (goalId) body.goal_id = Number(goalId);
+
+    const r = await api.inbox.postInbox({ body });
+    quickFiling = false;
+    $('#fq-submit').disabled = false;
+
+    if (!r.ok) {
+      showQuickErr(explainQuickFiling(r.status, r.data));
+      return;
+    }
+
+    // The routing verdict travels on idea.routing; a routed capture also
+    // carries the task it became at the top level (routed_task) — see
+    // routes/inbox.js. Not routed (no goal picked, or the matrix declined
+    // one) is exactly today's inbox behaviour.
+    const routedTask = r.data && r.data.routed_task;
+    const routing = r.data && r.data.idea && r.data.idea.routing;
+    if (routedTask && routedTask.id && routing && routing.routed) {
+      const href = window.OTBTaskDetail && typeof window.OTBTaskDetail.href === 'function'
+        ? window.OTBTaskDetail.href(routedTask.id)
+        : `/task/${encodeURIComponent(routedTask.id)}`;
+      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 = '';
+    fqBodyEl().value = '';
+    fqKindEl().value = 'bug';
+    goalTouchedByUser = false;
+    renderGoalOptions([]);
+    // The form is empty again, so the line has nothing to describe. The RECEIPT
+    // above is what survives the filing (task 1004082); gravity is a statement
+    // about a draft, and this draft is gone.
+    renderGravity(null);
+  }
+
+  async function bootQuickComposer() {
+    fqKindEl().value = 'bug';
+    renderGoalOptions([]);
+    fqTitleEl().addEventListener('input', onQuickTitleEdit);
+    fqKindEl().addEventListener('change', onQuickTitleEdit);
+    // Changing the goal is the one edit that changes gravity WITHOUT changing
+    // what the suggester would return, so it redraws the line directly rather
+    // than going through onQuickTitleEdit. Deliberately undebounced: a select is a
+    // deliberate single act, not a stream of keystrokes.
+    fqGoalEl().addEventListener('change', () => { goalTouchedByUser = true; refreshGravity(); });
+    $('#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({}),
+        api.goals.getGoals({ query: { status: 'open' } }),
+      ]);
+      buildingVersionIds = (versionsRes.ok && versionsRes.data && Array.isArray(versionsRes.data.versions))
+        ? versionsRes.data.versions.filter((v) => v.status === 'building').map((v) => v.id)
+        : [];
+      allOpenGoals = (goalsRes.ok && goalsRes.data && Array.isArray(goalsRes.data.goals)) ? goalsRes.data.goals : [];
+      allGoalsById = new Map(allOpenGoals.map((g) => [String(g.id), g]));
+      renderGoalOptions([]);
+    } catch (_) {
+      // The picker degrades to "homeless only" — filing itself never depends
+      // on this read succeeding.
+    }
+
+    // task 1003453 — the kind vocabulary, so this select is not a third hardcoded
+    // copy. Its OWN try, deliberately not folded into the Promise.all above: the
+    // goal picker is what this form is FOR and the kind list is cosmetic, so a
+    // vocabulary read must never be able to take the picker down with it. (It can:
+    // put it in that Promise.all and one rejection strands buildingVersionIds and
+    // allOpenGoals in the shared catch — two suites caught exactly that.)
+    // keepFirst 0 clears the markup's fallback and rebuilds with the served list,
+    // keeping 'bug' as the default this form has always opened on.
+    try {
+      const meRes = await api.me.getMe({});
+      window.OTB.fillKindFilter?.(fqKindEl(), meRes.ok && meRes.data && meRes.data.task_kinds, {
+        keepFirst: 0, label: window.OTB.kindLabel, selected: 'bug',
+      });
+    } catch (_) { /* the markup's Bug option stands — a report can still be filed */ }
+  }
+
+  // ---------------------------------------------------------------------------
+  // 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() {
+    // 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 r = await api.inbox.getInboxTemplate({});
+    if (!r.ok || !r.data || !r.data.template) {
+      $('#fi-sub').textContent = 'Could not load the idea template. Reload, or file from the terminal with capture.js.';
+      return;
+    }
+    template = r.data.template;
+
+    const draft = readDraft();
+    // A draft written against a different template is not restorable — the keys
+    // may not exist any more. Drop it rather than half-restoring it.
+    const usable = draft && (!draft.template_key || draft.template_key === template.key) ? draft : null;
+
+    $('#fi-sub').textContent = 'Five questions, and a score that counts how much of each you actually answered.';
+    renderForm(usable);
+    $('#fi-form').addEventListener('submit', file);
+    $('#fi-clear').addEventListener('click', discard);
+
+    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();
+    } else {
+      renderScore(null);
+    }
+  }
+
+  main();
+})();