@bongos/core 1.19.879 → 1.19.881

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');
+});

package/tests/provision.mjs

@@ -59,16 +59,21 @@ t('dbCreateCmd / migrateCmd use the slug db + GDS-only migrate', () => {
   assert.match(P.migrateCmd(coTenant), /PGDATABASE=mercury MEDUSA_GDS_ONLY=1 \.\/scripts\/migrate\.sh/);
 });
 
-t('seedFirstVersionCmd: idempotent (only-if-empty) V1 seed against the slug db, track explicit, one criterion — the fix for the empty-versions bug (task 2119)', () => {
+t('seedFirstVersionCmd: idempotent (only-if-empty) V1 seed against the slug db, no track, one criterion — the fix for the empty-versions bug (task 2119)', () => {
   const cmd = P.seedFirstVersionCmd(coTenant);
   // targets the instance's OWN db, matching createdb/migrate
   assert.match(cmd, /psql .*-d mercury /, 'seeds the instance db');
   assert.match(cmd, /ON_ERROR_STOP=1/, 'aborts on any error (atomic, no half-seed)');
   // the version the greenfield init spec defines — ONE source of truth
   const v = P.instanceInitSpec(coTenant).version;
-  assert.match(cmd, /INSERT INTO versions \(id, name, track, status, done_when\)/);
+  assert.match(cmd, /INSERT INTO versions \(id, name, status, done_when\)/);
   assert.match(cmd, new RegExp(`\\$v\\$${reEsc(v.id)}\\$v\\$`), 'seeds the spec version id (V1)');
-  assert.match(cmd, /\$v\$product\$v\$/, 'track is set EXPLICITLY (versions.track is NOT NULL, no default since mig 112)');
+  // task 1003665 retired the two-track model. The seed names no track: it runs on
+  // a freshly-MIGRATED database, so core_205's DEFAULT 'product' fills the still-
+  // NOT NULL column. If that default is ever dropped, THIS seed 500s first and a
+  // new instance cannot stand up — which is why the assertion is stated that way.
+  assert.doesNotMatch(cmd, /\btrack\b/, 'the seed names no track column');
+  assert.doesNotMatch(cmd, /\$v\$product\$v\$/, 'nor smuggles its value in positionally');
   assert.match(cmd, /\$v\$building\$v\$/, 'status building, mirroring seedViaApi');
   assert.ok(cmd.includes(v.done_when), 'carries the spec done_when verbatim (incl. the → arrows)');
   // the IDEMPOTENT guard — only seeds when there is NO version yet, so it never disturbs an existing project

package/tests/version_first_goal.mjs

@@ -57,7 +57,9 @@ function fakeDb({ goalRow = { id: 77, title: 'Foundations' } } = {}) {
     query: async (sql, params) => {
       log.push({ sql, params });
       if (/^\s*(BEGIN|COMMIT|ROLLBACK)/i.test(sql)) return { rows: [] };
-      if (/INSERT INTO versions/i.test(sql)) return { rows: [{ id: params[0], name: params[1], status: params[2], track: params[3] }] };
+      // params are positional: (id, name, status, scope_doc_path, done_when).
+      // `track` sat at index 3 until task 1003665 removed it from the INSERT.
+      if (/INSERT INTO versions/i.test(sql)) return { rows: [{ id: params[0], name: params[1], status: params[2] }] };
       if (/INSERT INTO goals/i.test(sql)) return { rows: [goalRow] };
       if (/INSERT INTO done_when_criteria/i.test(sql)) {
         return { rows: [{ id: log.length, version_id: params[0], criterion_id: params[1], criterion_md: params[2], sort_order: params[3], goal_id: params[4], satisfied: false }] };
@@ -83,7 +85,7 @@ const CRITERIA = [
 console.log('createVersion — the version, its first goal, and its criteria:');
 
 const out = await createVersion({
-  id: 'V1', name: 'Foundations', status: 'building', track: 'product',
+  id: 'V1', name: 'Foundations', status: 'building',
   doneWhen: 'The loop closes.', criteria: CRITERIA, createdBy: 7,
 }, { pool: db.pool });
 

package/tests/versions_route.mjs

@@ -10,6 +10,7 @@
 
 import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
+import fs from 'node:fs';
 
 const require = createRequire(import.meta.url);
 const { validate } = require('../src/bongos/routes/_helpers.js');
@@ -23,12 +24,14 @@ function test(name, fn) {
 }
 
 // The EXACT schema declared in versions.js → POST /versions validateOrRespond().
-// Keep in sync if the route's schema changes.
+// Keep in sync if the route's schema changes — and note that "keep in sync" is a
+// promise a copy cannot keep on its own, so the track case below reads the
+// ROUTE SOURCE rather than this object. A copy that still declared `track` would
+// happily prove the old contract forever.
 const VERSIONS_POST_SCHEMA = {
   id: { required: true, type: 'string', maxLength: 64, minLength: 1 },
   name: { required: true, type: 'string', maxLength: 200, minLength: 1 },
   status: { type: 'string', maxLength: 32 },
-  track: { type: 'string', maxLength: 16 },
   done_when: { type: 'string', maxLength: 8000 },
   scope_doc_path: { type: 'string', maxLength: 256 },
   criteria: { type: 'array', maxItems: 100 },
@@ -75,18 +78,40 @@ test('INIT: unknown extra fields pass through (forward-compat)', () => {
   assert.equal(validate({ id: 'V1', name: 'x', future_field: 42 }, VERSIONS_POST_SCHEMA), null);
 });
 
-// versions.track is NOT NULL with no DB default (migration 003) — the create
-// path must accept it so callers can choose, and default it so omitting it can
-// never again 500 the route (the @bongos/core 1.18.18 `bongos init` blocker).
-test('INIT: explicit track passes the schema guard (both tracks)', () => {
-  assert.equal(validate({ id: 'V1', name: 'x', track: 'product' }, VERSIONS_POST_SCHEMA), null);
-  assert.equal(validate({ id: 'GDS-V5', name: 'x', track: 'internal' }, VERSIONS_POST_SCHEMA), null);
+// The two-track (product/internal) model was retired by task 1002006 and its code
+// unwound by task 1003665: role/discipline is the sole work-type axis. These read
+// the ROUTE'S OWN SOURCE, not the copied schema above — the point is that the
+// concept is gone from the file that enforces it.
+//
+// What made the removal safe, and what would make it unsafe again: versions.track
+// is still NOT NULL, so an INSERT omitting it is legal ONLY because core_205 gave
+// the column DEFAULT 'product'. Drop that default and every create 500s. The
+// comments this task deleted asserted the opposite ("no DB default") and were
+// stale from core_205 onward — which is precisely why five insert paths went on
+// supplying a value nothing read.
+const routeSrc = fs.readFileSync(
+  new URL('../modules/lifecycle/routes/versions.js', import.meta.url), 'utf8');
+
+test('the route no longer knows what a track is', () => {
+  for (const gone of ['VALID_VERSION_TRACKS', 'bad_track']) {
+    assert.ok(!routeSrc.includes(gone), `${gone} is gone from POST /versions`);
+  }
+  assert.ok(!/\btrack\b/.test(routeSrc.replace(/tracked|tracking/g, '')),
+    'no track identifier survives in the versions route');
 });
 
-test('BAD: non-string track → structured 400 shape, not a DB 500', () => {
-  const r = validate({ id: 'V1', name: 'x', track: 42 }, VERSIONS_POST_SCHEMA);
-  assert.ok(r);
-  assert.ok(r.details.some((d) => d.field === 'track'));
+test('a version is created WITHOUT a track, and that is the whole contract', () => {
+  // The create shape `bongos init` and provision-repo.js now send.
+  assert.equal(validate({ id: 'V1', name: 'x' }, VERSIONS_POST_SCHEMA), null);
+  assert.equal(validate({ id: 'GDS-V5', name: 'x', status: 'planning' }, VERSIONS_POST_SCHEMA), null);
+});
+
+test('the INSERT does not name the column either', () => {
+  const dbSrc = fs.readFileSync(
+    new URL('../modules/lifecycle/db-versions.js', import.meta.url), 'utf8');
+  const insert = dbSrc.slice(dbSrc.indexOf('INSERT INTO versions'));
+  assert.ok(!/^[^`]*\btrack\b/.test(insert.slice(0, insert.indexOf('`'))),
+    'INSERT INTO versions names no track column — the DB default supplies it');
 });
 
 // ---- BAD shapes must return a structured 400, never throw / 500 ----