@bongos/core 1.19.841 → 1.19.843

package/tests/task_discipline_required.mjs

@@ -0,0 +1,163 @@
+// tests/task_discipline_required.mjs — task 1002988: every task row carries a craft.
+//
+// The thing under test is mostly an ABSENCE: that 'unclassified' can no longer be
+// written, by any vector, and that the DB constraint no longer accepts it. A suite
+// that only proved the four valid values work would have passed before this task and
+// will pass again once the guard rots, so each block below pins the refusal.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const classifier = require(path.join(ROOT, 'modules', 'lifecycle', 'task-classifier.js'));
+const { resolveWriteDiscipline, WRITABLE_DISCIPLINES, VALID_DISCIPLINES } = classifier;
+
+// --- the writable set -------------------------------------------------------
+
+test('the writable set is the four crafts — ui included, unclassified excluded', () => {
+  // FOUR, not three. The task was written 2026-08-16 naming three; ADR 0272
+  // (2026-09-09) keeps `ui` as a module-contributed discipline and the owner
+  // reconfirmed it on 2026-09-17 when abandoning task 1002987. Narrowing to three
+  // would break live ui rows — the backfill found 3 of them by classification alone.
+  assert.deepEqual([...WRITABLE_DISCIPLINES].sort(), ['artist', 'engineer', 'ideator', 'ui']);
+  assert.ok(!WRITABLE_DISCIPLINES.has('unclassified'), 'unclassified is a triage state, not a craft');
+});
+
+test('the READ set still carries unclassified, so old rows and filters resolve', () => {
+  // The two sets are deliberately different. Collapsing them would break the
+  // ?discipline=unclassified query the backfill itself reads through.
+  assert.ok(VALID_DISCIPLINES.has('unclassified'));
+});
+
+// --- resolveWriteDiscipline -------------------------------------------------
+
+test('an explicit valid discipline is honoured verbatim', () => {
+  for (const d of WRITABLE_DISCIPLINES) {
+    assert.deepEqual(resolveWriteDiscipline({ discipline: d, title: 'anything' }), { discipline: d });
+  }
+});
+
+test('an omitted discipline is INFERRED, and reports that it was', () => {
+  const r = resolveWriteDiscipline({ title: 'Refactor the database migration script' });
+  assert.equal(r.discipline, 'engineer');
+  assert.equal(r.inferred, true, 'the caller must be able to tell a guess from a statement');
+  assert.ok(r.confidence >= 0.5);
+});
+
+test('an explicit "unclassified" is treated as no answer at all, not as a value', () => {
+  // modules/ideas/inbox.js sent this literal string on every promotion. If it were
+  // honoured as a value, the create path would still mint the rows this task removes.
+  const r = resolveWriteDiscipline({ discipline: 'unclassified', title: 'Refactor the database migration script' });
+  assert.equal(r.discipline, 'engineer');
+  assert.equal(r.inferred, true);
+});
+
+test('an unclassifiable task is REFUSED, not filed under a filler value', () => {
+  const r = resolveWriteDiscipline({ title: 'asdf' });
+  assert.equal(r.discipline, undefined);
+  assert.equal(r.error, 'bad_discipline');
+  assert.equal(r.unclassifiable, true, 'the caller must be able to say WHY, to write a useful message');
+});
+
+test('a bogus discipline is refused, and is NOT reported as unclassifiable', () => {
+  const r = resolveWriteDiscipline({ discipline: 'wizard', title: 'Refactor the database migration script' });
+  assert.equal(r.error, 'bad_discipline');
+  assert.ok(!r.unclassifiable, 'the text was fine — the caller named a craft that does not exist');
+});
+
+// --- createTask: the single chokepoint --------------------------------------
+// Every create vector passes through here, including the ones that never touch an
+// HTTP route (idea promotion, copy-desk, newcomer-restock, kickoff-seed, cascade).
+// Fixing only the routes would have left those minting role-less rows.
+
+function recordingPool(captured) {
+  return {
+    query: async (text, params) => {
+      if (/^\s*INSERT INTO tasks/i.test(text)) {
+        captured.push({ text, params });
+        return { rows: [{ id: 1, discipline: params[params.findIndex(() => false)] }] };
+      }
+      return { rows: [{ id: 1 }] };
+    },
+  };
+}
+
+test('createTask REFUSES a task whose craft it cannot infer', async () => {
+  process.env.NODE_ENV = 'test';
+  const { createTask } = require(path.join(ROOT, 'modules', 'lifecycle', 'db-tasks.js'));
+  const captured = [];
+  await assert.rejects(
+    () => createTask({ versionId: 'V1', title: 'asdf', goalId: 1 }, { pool: recordingPool(captured) }),
+    (e) => e.code === 'BAD_DISCIPLINE' && e.unclassifiable === true,
+    'an unclassifiable create must throw, not default',
+  );
+  assert.equal(captured.length, 0, 'nothing may be inserted when the craft is unknown');
+});
+
+test('createTask no longer has an "unclassified" default to fall back on', () => {
+  // The default was the whole mechanism: 1,189 rows accumulated because it was quiet.
+  // Pinned as source text because the behavioural test above can only prove the
+  // refusal, not that the default is gone rather than merely unreachable.
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'lifecycle', 'db-tasks.js'), 'utf8');
+  assert.ok(!/^\s*discipline = 'unclassified',\s*$/m.test(src),
+    "createTask must not default discipline to 'unclassified'");
+});
+
+// --- the migration: the absence is the thing under test ---------------------
+
+test('core_247 narrows the CHECK to the four crafts and REJECTS unclassified', () => {
+  const sql = fs.readFileSync(path.join(ROOT, 'migrations', 'core_247_discipline_required.sql'), 'utf8');
+  const m = sql.match(/CHECK \(discipline IN \(([^)]*)\)\)/);
+  assert.ok(m, 'the migration must re-add a discipline CHECK constraint');
+  const accepted = m[1].split(',').map((s) => s.trim().replace(/'/g, '')).sort();
+  assert.deepEqual(accepted, ['artist', 'engineer', 'ideator', 'ui'],
+    'the accepted set must match WRITABLE_DISCIPLINES exactly');
+  assert.ok(!accepted.includes('unclassified'), 'the whole point: the constraint rejects it');
+  // The net that makes the migration safe on a checkout where nobody ran the script.
+  assert.match(sql, /UPDATE tasks SET discipline = 'engineer'[\s\S]*?WHERE discipline = 'unclassified'/,
+    'the migration must resolve residual rows itself, not assume a script was run');
+});
+
+test('the migration constraint and the code agree on the accepted set', () => {
+  // Two places state the vocabulary; a drift between them is a 500 at write time
+  // (code accepts a value the DB rejects) or dead validation (the reverse).
+  const sql = fs.readFileSync(path.join(ROOT, 'migrations', 'core_247_discipline_required.sql'), 'utf8');
+  const accepted = sql.match(/CHECK \(discipline IN \(([^)]*)\)\)/)[1]
+    .split(',').map((s) => s.trim().replace(/'/g, '')).sort();
+  assert.deepEqual(accepted, [...WRITABLE_DISCIPLINES].sort());
+});
+
+// --- the create vectors that must keep working ------------------------------
+// Acceptance 6: prove it per path, not in aggregate.
+
+test('every direct createTask call site names a discipline or resolves one', () => {
+  const sites = [
+    ['modules/ideas/inbox.js', /discipline: \(lifecycle\.resolveWriteDiscipline/],
+    ['modules/copy-desk/routes/copy-desk.js', /discipline: 'artist'/],
+    ['modules/onboarding/newcomer-restock.js', /^\s*discipline,\s*$/m],
+    ['modules/lifecycle/kickoff-seed.js', /discipline: t\.discipline \|\| 'engineer'/],
+    ['modules/lifecycle/cascade.js', /discipline: rule\.discipline/],
+    ['scripts/gds/triage.js', /discipline: resolveWriteDiscipline\(/],
+  ];
+  for (const [rel, re] of sites) {
+    const src = fs.readFileSync(path.join(ROOT, rel), 'utf8');
+    assert.match(src, re, `${rel} must supply a discipline — createTask now throws without one`);
+  }
+});
+
+test('init.js no longer clobbers its own discipline default with undefined', () => {
+  // The spread ran AFTER `t.discipline || 'engineer'`, so `discipline: undefined` in
+  // the extras object reset it to nothing — which is why a freshly scaffolded
+  // instance was born with role-less starter tasks.
+  // Comment lines are stripped first: the fix's own explanation names the old
+  // expression, and a scan that cannot tell code from prose would either fail here
+  // forever or be "fixed" by deleting the explanation.
+  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'gds', 'init.js'), 'utf8')
+    .split('\n').filter((l) => !/^\s*(\/\/|\*|\/\*)/.test(l)).join('\n');
+  assert.ok(!/discipline: undefined/.test(src), 'a later spread must not undo the default');
+  assert.match(src, /discipline: t\.discipline \|\| 'engineer'/);
+});

package/tests/task_goal_required.mjs

@@ -47,13 +47,13 @@ const permissivePool = {
 
 test('a create with no goalId THROWS instead of quietly filing into a bucket', async () => {
   await assert.rejects(
-    () => createTask({ versionId: 'BONGOS-V1', title: 't' }, { pool: permissivePool }),
+    () => createTask({ versionId: 'BONGOS-V1', title: 't', discipline: 'engineer' }, { pool: permissivePool }),
     /goalId is required/,
     'the old behaviour was to succeed and say nothing');
 });
 
 test('the error tells the caller both ways out', async () => {
-  const err = await createTask({ versionId: 'BONGOS-V1', title: 't' }, { pool: permissivePool })
+  const err = await createTask({ versionId: 'BONGOS-V1', title: 't', discipline: 'engineer' }, { pool: permissivePool })
     .then(() => null, (e) => e);
   assert.ok(err, 'must reject');
   assert.match(err.message, /BV1\.R11/, 'names the rule, so the reason is findable');
@@ -63,7 +63,7 @@ test('the error tells the caller both ways out', async () => {
 test('only a literal true opts in — a truthy value still throws', async () => {
   for (const v of [1, 'yes', {}, 'true']) {
     await assert.rejects(
-      () => createTask({ versionId: 'BONGOS-V1', title: 't', allowCatchAll: v }, { pool: permissivePool }),
+      () => createTask({ versionId: 'BONGOS-V1', title: 't', discipline: 'engineer', allowCatchAll: v }, { pool: permissivePool }),
       /goalId is required/,
       `${JSON.stringify(v)} must not open the hatch`);
   }
@@ -73,7 +73,7 @@ test('naming a goal needs no flag at all', async () => {
   // The ordinary path must stay ordinary: a caller with a goal never learns this
   // parameter exists.
   await createTask(
-    { versionId: 'BONGOS-V1', title: 't', goalId: 77 },
+    { versionId: 'BONGOS-V1', title: 't', discipline: 'engineer', goalId: 77 },
     { pool: permissivePool, client: permissivePool },
   );
 });