@bongos/core 1.19.879 → 1.19.880

package/docs/module-api-changelog.md

@@ -2232,5 +2232,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.877 with no explicit bump. run 35439004814. (task 1002620)
   1.19.879 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.878 with no explicit bump. run 35439529685. (task 1002620)
+  1.19.880 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.879 with no explicit bump. run 35453118533. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/modules/hall-ui/public/dom-utils.js

@@ -146,7 +146,10 @@
     for (const k of list) {
       const opt = document.createElement('option');
       opt.value = k;
-      opt.textContent = label(k);
+      // The unset bucket is named for a reader on EVERY surface, filters included
+      // — `label` is the caller's choice for the real kinds, never for this one
+      // (task 1004038). roleOptions() names the role twin the same way.
+      opt.textContent = kindIsUnset(k) ? kindLabel(k) : label(k);
       sel.appendChild(opt);
     }
     // A refill must not drop the reader's pick; `selected` is the filing default.
@@ -154,10 +157,23 @@
     if (want) sel.value = want;
   }
 
+  // A task with no kind carries the DB default 'unclassified' — the twin of
+  // ROLE_UNSET one axis over (task 1004038, filed by task 1003936 which fixed the
+  // role axis and left this one). A word a column chose is not a word a person
+  // should read (docs/voice.md V2), so a picker shows "No kind yet" and a row tag
+  // renders NOTHING. kindIsUnset() is how a caller asks. The STORED value and the
+  // filter VALUE stay 'unclassified'; only what is read changes.
+  const KIND_UNSET = 'unclassified';
+  function kindIsUnset(k) { return !k || String(k) === KIND_UNSET; }
+
+  // NOT ESCAPE-SAFE: like roleLabel() below, this returns a transformed copy of
+  // its input, so a caller rendering it into markup must escapeHtml() the result.
+  // Every caller today assigns it to textContent, which escapes for them.
   // How a kind is named in a picker — 'blocker-resolution' → 'Blocker resolution'.
   // The same shape roleLabel takes below, and it reproduces every label the
   // hand-written <option> list in ideas.html carried, so no copy changes.
   function kindLabel(k) {
+    if (kindIsUnset(k)) return 'No kind yet';
     const s = String(k || '').replace(/-/g, ' ');
     return s ? s.charAt(0).toUpperCase() + s.slice(1) : '';
   }
@@ -407,7 +423,7 @@
     escapeHtml, $, fmtNum, num, fmtInt, fmtCompact, fmtDate, rankLabel, toast, moduleOn, disciplines,
     // task 1003936 — ONE word for the role axis, all six surfaces
     roleAxisLabel, roleLabel, roleOptions, roleIsUnset, ROLE_UNSET,
-    fillKindFilter, kindLabel, // task 1003453 — one Kind filler, all three surfaces
+    fillKindFilter, kindLabel, kindIsUnset, KIND_UNSET, // task 1003453 — one Kind filler, all three surfaces
     errCode, errMessage, errDetails, // task 1002462 — ADR 0116 envelope readers
     contributeSettingsPanel, settingsPanels,
     contributeHallWidget, hallWidgets, hallWidgetIds,

package/modules/hall-ui/public/goals-render.js

@@ -321,6 +321,11 @@
     const disciplineTag = window.OTB.roleIsUnset(t.discipline)
       ? ''
       : `<span class="task__tag">${escapeHtml(window.OTB.roleLabel(t.discipline))}</span>`;
+    // A kind nobody set is no tag at all, not the column's default word — the
+    // role tag above is the precedent this follows (task 1004038).
+    const kindTag = window.OTB.kindIsUnset(t.kind)
+      ? ''
+      : `<span class="task__tag">${escapeHtml(t.kind)}</span>`;
     const newcomerTag = t.newcomer_friendly ? '<span class="task__tag task__tag--newcomer">newcomer</span>' : '';
     const rankTag = rankTagHtml(t.requires_rank);
     const touches = Array.isArray(t.touches) ? t.touches : [];
@@ -361,7 +366,7 @@
           <p class="task__title"><a class="task__link" href="${escapeHtml(taskHref(id))}">${escapeHtml(t.title || '')}</a></p>
           <div class="task__meta">
             <span class="task__tag">${escapeHtml(t.version_id || '?')}</span>
-            <span class="task__tag">${escapeHtml(t.kind || 'unclassified')}</span>
+            ${kindTag}
             ${disciplineTag}
             ${newcomerTag}
             ${rankTag}
@@ -403,7 +408,7 @@
       <tr class="ledger__row--task" data-task-id="${escapeHtml(String(t.id))}" style="cursor:pointer" title="Open task #${escapeHtml(String(t.id))}">
         <td class="ledger__num">#${escapeHtml(String(t.id))}</td>
         <td>${escapeHtml(t.title || '')}</td>
-        <td>${escapeHtml(t.kind || '—')}</td>
+        <td>${window.OTB.kindIsUnset(t.kind) ? '—' : escapeHtml(t.kind)}</td>
         <td class="ledger__drachmae">${fmtNum(creditVal(t))}${taskSettled(t) ? '' : ' <span class="ledger__est" title="Estimate — credits settle when the task is confirmed">est.</span>'}</td>
         <td class="ledger__date">${fmtDate(t.shipped_at)}</td>
       </tr>`).join('');
@@ -502,7 +507,7 @@
     const sortBy = $('#f-goal-sort')?.value || 'cpm';
     let list = state.work.todo.filter((t) => {
       if (!matchesTodoSearch(t, sQuery)) return false;
-      if (kFilter && (t.kind || 'unclassified') !== kFilter) return false;
+      if (kFilter && (t.kind || window.OTB.KIND_UNSET) !== kFilter) return false;
       if (dFilter && (t.discipline || window.OTB.ROLE_UNSET) !== dFilter) return false;
       if (nFilter === 'yes' && !t.newcomer_friendly) return false;
       return true;

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

@@ -536,8 +536,12 @@
     // word is the thing the round's stat-tile reference exists to fix.
     const meta = [];
     if (t.version_id) meta.push(`<b>${escapeHtml(t.version_id)}</b>`);
-    if (t.kind) meta.push(escapeHtml(t.kind));
-    if (t.discipline && t.discipline !== 'unclassified') meta.push(escapeHtml(t.discipline));
+    // Neither axis says the word its column defaults to (task 1004038). `if
+    // (t.kind)` was never a guard for it: 'unclassified' is a truthy string, so
+    // the run read it out loud. The role line below asked the same question with
+    // a literal — it is right, but a copy of roleIsUnset() is free to drift.
+    if (!window.OTB.kindIsUnset(t.kind)) meta.push(escapeHtml(t.kind));
+    if (!window.OTB.roleIsUnset(t.discipline)) meta.push(escapeHtml(t.discipline));
     // rankText() answers "any rank" for an open task, which read as
     // "min rank any rank" once the label was prefixed. An open floor is not a
     // minimum, so it is said as the absence of one.

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

@@ -429,6 +429,8 @@
       const disciplineTag = window.OTB.roleIsUnset(t.discipline)
         ? ''
         : `<span class="task__tag">${escapeHtml(window.OTB.roleLabel(t.discipline))}</span>`;
+      // A kind nobody set is no tag at all, like the role above (task 1004038).
+      const kindTag = window.OTB.kindIsUnset(t.kind) ? '' : `<span class="task__tag">${escapeHtml(t.kind)}</span>`;
       const newcomerTag = t.newcomer_friendly
         ? '<span class="task__tag task__tag--newcomer">newcomer</span>'
         : '';
@@ -459,7 +461,7 @@
             <p class="task__title"><a class="task__link" href="${escapeHtml(taskHref(t.id))}">${escapeHtml(t.title)}</a></p>
             <div class="task__meta">
               <span class="task__tag">${escapeHtml(t.version_id || '?')}</span>
-              <span class="task__tag">${escapeHtml(t.kind || 'unclassified')}</span>
+              ${kindTag}
               ${disciplineTag}
               ${newcomerTag}
               ${rankTag}
@@ -1142,7 +1144,7 @@
         <div class="history__row" data-task-id="${escapeHtml(String(t.id))}" title="Open task #${escapeHtml(String(t.id))}">
           <span class="history__id">#${escapeHtml(String(t.id))}</span>
           <span class="history__title">${escapeHtml(t.title || '(untitled)')} ${ver} ${disciplineTag} ${rankTagHtml(t.requires_rank)}<br>${goalTag}</span>
-          <span class="history__when">${escapeHtml(t.kind || '')}</span>
+          <span class="history__when">${window.OTB.kindIsUnset(t.kind) ? '' : escapeHtml(t.kind)}</span>
         </div>`;
     }).join('');
   }

package/package-lock.json

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

package/package.json

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

package/src/module-api.js

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

package/tests/hall_record_world.mjs

@@ -354,6 +354,11 @@ function renderTask(task, { lastClaim = null, viewer = null, goal = null, goalsL
       roleOptions: () => [{ value: '', label: '— any —' }, { value: 'engineer', label: 'Engineer' }, { value: 'artist', label: 'Artist' }],
       roleIsUnset: (d) => !d || d === 'unclassified',
       ROLE_UNSET: 'unclassified',
+      // task 1004038 — the kind axis asks the same question. Stubbed for the
+      // reason the comment above gives: an undefined helper throws mid-render,
+      // and the page then renders its "feed unavailable" card instead.
+      kindIsUnset: (k) => !k || k === 'unclassified',
+      KIND_UNSET: 'unclassified',
       escapeHtml,
       $: (sel) => documentObj.querySelector(sel),
       fmtDate: (iso) => String(iso).slice(0, 10),

package/tests/kind_axis_unset.mjs

@@ -0,0 +1,195 @@
+// tests/kind_axis_unset.mjs — the KIND axis never reads its column default to a
+// person (task 1004038, goal 1000095).
+//
+// The twin of the role axis task 1003936 fixed. `tasks.kind` defaults to
+// 'unclassified'; docs/voice.md V2 says a value that exists because a column
+// needed a default is not a word a person should read. Before this, the word
+// reached a reader on four surfaces: the Goals page row tag, the Tasks board row
+// tag, the backlog history row, and every Kind filter's option list.
+//
+// The line this holds — the same one 1003936 drew: the STORED value and the
+// FILTER VALUE stay 'unclassified'. Only what is READ changes. A test that let
+// the value change would be pinning the wrong half.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
+
+// The real dom-utils.js, booted the way the pages boot it, so these are the
+// functions that ship and not a restatement of them.
+function loadOTB() {
+  const mkEl = () => ({
+    value: '', textContent: '', length: 0, children: [],
+    appendChild(c) { this.children.push(c); this.length = this.children.length; },
+    setAttribute() {}, addEventListener() {},
+  });
+  const sandbox = {
+    window: { __BRANDING__: {}, __MODULES__: { enabled: {} }, addEventListener() {} },
+    document: { createElement: mkEl, getElementById: () => null, querySelector: () => null,
+      querySelectorAll: () => [], addEventListener() {} },
+    console,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(read('dom-utils.js'), sandbox, { filename: 'dom-utils.js' });
+  return { OTB: sandbox.window.OTB };
+}
+
+test('the unset kind is asked about, not spelled, and the stored value is untouched', () => {
+  const { OTB } = loadOTB();
+  assert.equal(OTB.KIND_UNSET, 'unclassified',
+    'the STORED value is still the column default — this fix changes reading, not writing');
+  assert.equal(OTB.kindIsUnset('unclassified'), true);
+  assert.equal(OTB.kindIsUnset(''), true, 'a missing kind is unset too');
+  assert.equal(OTB.kindIsUnset(null), true);
+  assert.equal(OTB.kindIsUnset(undefined), true);
+  assert.equal(OTB.kindIsUnset('bug'), false, 'a real kind is never unset');
+  assert.equal(OTB.kindIsUnset('verify'), false);
+});
+
+test('a kind is named for a reader, and the unset one is named a phrase a person would say', () => {
+  const { OTB } = loadOTB();
+  assert.equal(OTB.kindLabel('unclassified'), 'No kind yet',
+    "the column's word never reaches a reader");
+  assert.doesNotMatch(OTB.kindLabel('unclassified'), /unclassified/i);
+  // The labels task 1003453 shipped are unchanged — this fix adds a case, it
+  // does not restyle the vocabulary.
+  assert.equal(OTB.kindLabel('bug'), 'Bug');
+  assert.equal(OTB.kindLabel('blocker-resolution'), 'Blocker resolution');
+  assert.equal(OTB.kindLabel('learning-capture'), 'Learning capture');
+});
+
+test('EVERY Kind picker names the unset bucket, filters included — and keeps its value', () => {
+  const { OTB } = loadOTB();
+  const sel = { value: '', length: 1, options: [],
+    appendChild(o) { this.options.push(o); this.length = this.options.length + 1; } };
+  // A FILTER: `label` is identity, as work.js and goals-page.js pass it. Before
+  // this fix that identity function is exactly what leaked the column's word.
+  OTB.fillKindFilter(sel, ['bug', 'verify', 'unclassified'], { keepFirst: 1 });
+  const unset = sel.options.find((o) => o.value === 'unclassified');
+  assert.ok(unset, 'the unset bucket is still SELECTABLE — a filter you cannot apply is a lost lens');
+  assert.equal(unset.value, 'unclassified', 'and it still filters on the stored value');
+  assert.equal(unset.textContent, 'No kind yet', 'but it READS as a phrase');
+  // The real kinds still honour the caller's label choice.
+  assert.equal(sel.options.find((o) => o.value === 'bug').textContent, 'bug',
+    "a filter's raw-value labelling for real kinds is unchanged");
+});
+
+// ---- the render sites ------------------------------------------------------
+// Source pins, the idiom tests/hall_board_world.mjs uses for the role twin: a
+// row tag is built in a template literal that no unit test can reach without
+// booting the whole page.
+
+const goalsRender = read('goals-render.js');
+const workJs = read('work.js');
+const taskJs = read('task.js');
+
+// Every `t.kind` USE in the two files is accounted for — the structural form,
+// not a pattern match. task 1004038's first round asserted the literal
+// `t.kind || 'unclassified'` was gone, which was true and still missed
+// taskRowsDone()'s `t.kind || '—'`: a different spelling of the same bug, in a
+// file the diff was already editing. `||` cannot guard this axis AT ALL, because
+// the default is the truthy string 'unclassified' — so the test has to enumerate
+// every use and demand each one either guards or is a declared non-render.
+// Each scanned file split ONCE at module load — the scan below reads these, so
+// adding a case costs no re-read (the per-test split was the round-2 note).
+const scanned = (src) => {
+  const all = src.split('\n');
+  return { raw: src, all, hits: all.map((l, i) => [l, i]).filter(([l]) => l.includes('t.kind')) };
+};
+
+const USES = {
+  'goals-render.js': {
+    src: scanned(goalsRender),
+    // A use that never reaches a reader, each with the reason it is exempt.
+    nonRender: {
+      "case 'kind': return String(t.kind || '').toLowerCase();": 'a SORT key — compared, never displayed',
+      "if (kFilter && (t.kind || window.OTB.KIND_UNSET) !== kFilter) return false;": 'the filter PREDICATE — must use the stored value',
+    },
+  },
+  'work.js': {
+    src: scanned(workJs),
+    nonRender: {
+      'if (f.kind && t.kind !== f.kind) return false;': 'the board filter PREDICATE — stored value again',
+    },
+  },
+  // Round 2 found the RECORD page reading the word too, via `if (t.kind)` — which
+  // is not a guard, because the default is truthy. Enumerating the file here is
+  // what stops the next one being found by a grader instead of by this test.
+  'task.js': {
+    src: scanned(taskJs),
+    nonRender: {
+      "if (t.kind === 'verify' && !window.confirm(": 'a BRANCH on the value — gates a confirm prompt, renders nothing',
+      "const body = t.kind === 'verify' ? { verified: true } : {};": 'a REQUEST body — sent to the route, never displayed',
+    },
+  },
+};
+
+test('every t.kind use either goes through kindIsUnset or is a declared non-render', () => {
+  for (const [name, { src, nonRender }] of Object.entries(USES)) {
+    const { all, hits } = src;
+    assert.ok(hits.length, `${name} has t.kind uses to check`);
+    for (const [raw, i] of hits) {
+      const line = raw.trim();
+      if (line.startsWith('//') || line.startsWith('*')) continue; // prose about the axis
+      if (Object.keys(nonRender).some((k) => line.includes(k.trim()))) continue;
+      // The guard may be a multi-line ternary whose `?`/`:` arms sit on their own
+      // lines (goals-render.js writes it that way), so the window is the
+      // statement, not the line — two lines back is enough for every form here.
+      const stmt = all.slice(Math.max(0, i - 2), i + 1).join('\n');
+      assert.match(stmt, /kindIsUnset/,
+        `${name}: this t.kind use neither guards nor is declared a non-render — `
+        + `if it renders, the column's word reaches a reader:\n    ${line}`);
+    }
+  }
+});
+
+test('the column default is TRUTHY, so `||` can never be the guard', () => {
+  // The fact that makes the finding above a bug rather than a style note, and
+  // the reason no render site may fall back with `||`. Pinned so a future reader
+  // does not "simplify" a kindIsUnset() call back into a falsy check.
+  const { OTB } = loadOTB();
+  assert.ok(OTB.KIND_UNSET, 'the default is a non-empty string');
+  assert.equal(!!(OTB.KIND_UNSET || '—'), true, '`t.kind || fallback` keeps the default, never the fallback');
+  assert.equal(OTB.KIND_UNSET || '—', 'unclassified', 'which is exactly the word that must not be read');
+  for (const [name, { src }] of Object.entries(USES)) {
+    assert.doesNotMatch(src.raw, /escapeHtml\(t\.kind \|\|/,
+      `${name} never renders a \`||\` fallback for the kind axis — it cannot fire`);
+  }
+});
+
+test('a kind nobody set renders NO tag, exactly as an unset role does', () => {
+  for (const [name, src] of [['goals-render.js', goalsRender], ['work.js', workJs]]) {
+    assert.match(src, /window\.OTB\.kindIsUnset\(t\.kind\)/,
+      `${name} asks the vocabulary whether the kind is set`);
+    assert.match(src, /kindTag/, `${name} renders through the guarded tag`);
+  }
+  // The backlog history row is the third surface and the easiest to miss — it
+  // rendered `t.kind || ''`, which is empty-safe but says 'unclassified' out loud.
+  const history = workJs.slice(workJs.indexOf('class="history__row"'));
+  assert.match(history, /kindIsUnset\(t\.kind\) \? '' : escapeHtml\(t\.kind\)/,
+    'the backlog history row is guarded too');
+});
+
+test("a TABLE cell keeps its placeholder — 'no tag' is not 'no cell'", () => {
+  // taskRowsDone()'s Completed ledger is a table: a vanished <td> would shift
+  // every following column. It guards like the rest but falls back to the
+  // em-dash the ledger already used for an empty cell.
+  const done = goalsRender.slice(goalsRender.indexOf('function taskRowsDone'));
+  assert.match(done.slice(0, done.indexOf('function ', 10)), /kindIsUnset\(t\.kind\) \? '—' : escapeHtml\(t\.kind\)/,
+    'the ledger cell is guarded and still renders a placeholder');
+});
+
+test('the filter PREDICATE still compares against the stored value', () => {
+  // If this ever reads the label instead, every Kind filter silently matches
+  // nothing and the board looks empty rather than broken.
+  assert.match(goalsRender, /t\.kind \|\| window\.OTB\.KIND_UNSET/,
+    'the goals-page predicate defaults to the stored value, through the constant');
+});