@bongos/core 1.19.842 → 1.19.844

package/tests/hall_states_regex_escapes.mjs

@@ -0,0 +1,98 @@
+// tests/hall_states_regex_escapes.mjs — a states file's ignore lists are REGEX
+// SOURCES, so a JSON escape that produces a control character is a silently dead
+// pattern (task 1003638).
+//
+// THE DEFECT. `modules/ui-design/kit/lib.js` does:
+//
+//     const con = ignoreConsole.map((s) => new RegExp(s));
+//
+// so every entry is a regex source. In JSON, `"\b"` is the escape for BACKSPACE
+// (U+0008) — not the two characters a regex needs for a word boundary. Eight states
+// files wrote `"\b401\b"` where they meant `"\\b401\\b"`, compiling a pattern that
+// matches a literal backspace beside "401". Console text never contains one, so the
+// declared noise suppression did nothing and nothing ever said so.
+//
+// MEASURED across modules/hall-ui/public/*.states.json on 2026-09-17: 8 files, 17
+// entries — goals, idea, ideas, index, pair, settings, task, work. (The row that
+// filed this named only `work`, and listed `task`, `idea` and `ideas` among the
+// HEALTHY files; all three were broken. The fix followed the computed list.)
+//
+// Run:  node --test tests/hall_states_regex_escapes.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const DIR = path.join(REPO_ROOT, 'modules/hall-ui/public');
+const REGEX_LISTS = ['ignoreConsole', 'ignoreRequests', 'ignoreControls'];
+const CONTROL = /[\x00-\x1f]/;
+
+const files = readdirSync(DIR).filter((n) => n.endsWith('.states.json'));
+
+test('there are states files to check — an empty sweep must not read as a pass', () => {
+  assert.ok(files.length > 10, `expected the hall states files, found ${files.length}`);
+});
+
+test('no ignore-list entry contains a control character', () => {
+  const offenders = [];
+  for (const name of files) {
+    const json = JSON.parse(readFileSync(path.join(DIR, name), 'utf8'));
+    for (const key of REGEX_LISTS) {
+      if (!Array.isArray(json[key])) continue;
+      for (const entry of json[key]) {
+        if (CONTROL.test(entry)) {
+          const codes = [...entry].map((c) => c.charCodeAt(0)).filter((n) => n < 32)
+            .map((n) => `U+${n.toString(16).padStart(4, '0')}`).join(',');
+          offenders.push(`${name} ${key}: ${JSON.stringify(entry)} (${codes})`);
+        }
+      }
+    }
+  }
+  assert.deepEqual(offenders, [],
+    `a JSON escape produced a control character in a regex source — almost certainly \\b meant as a word boundary:\n  ${offenders.join('\n  ')}`);
+});
+
+test('every ignore-list entry compiles as a regex', () => {
+  // lib.js calls new RegExp(s) with no try/catch, so an uncompilable entry is a
+  // crash in the walk rather than a dead pattern.
+  const bad = [];
+  for (const name of files) {
+    const json = JSON.parse(readFileSync(path.join(DIR, name), 'utf8'));
+    for (const key of REGEX_LISTS) {
+      if (!Array.isArray(json[key])) continue;
+      for (const entry of json[key]) {
+        try { new RegExp(entry); } catch (e) { bad.push(`${name} ${key}: ${JSON.stringify(entry)} — ${e.message}`); }
+      }
+    }
+  }
+  assert.deepEqual(bad, [], `uncompilable regex source:\n  ${bad.join('\n  ')}`);
+});
+
+test('the word-boundary patterns actually match a real console line', () => {
+  // The behavioural half: shape alone would still pass if someone "fixed" the control
+  // character by deleting it (leaving "401", which over-matches, e.g. "1401ms").
+  const line = 'Failed to load resource: the server responded with a status of 404 (Not Found)';
+  const work = JSON.parse(readFileSync(path.join(DIR, 'work.states.json'), 'utf8'));
+  const matched = work.ignoreConsole.some((s) => new RegExp(s).test(line));
+  assert.equal(matched, true, 'the declared 404 suppression must match a real 404 console line');
+
+  // And the boundary must still be a boundary — not a bare number.
+  const boundary = work.ignoreConsole.find((s) => s.includes('404'));
+  assert.ok(boundary, 'a 404 entry must exist');
+  assert.equal(new RegExp(boundary).test('elapsed 1404ms'), false,
+    'the pattern must not match a 404 embedded in a longer number — that is what the word boundary is for');
+});
+
+test('the broken form is genuinely inert — this is what the bug cost', () => {
+  // Pins WHY it was invisible: the old value silently matched nothing rather than
+  // erroring, so every gate stayed green while the suppression did nothing.
+  const broken = '\x08404\x08';
+  const line = 'Failed to load resource: the server responded with a status of 404 (Not Found)';
+  assert.equal(new RegExp(broken).test(line), false,
+    'the backspace form matches nothing — silent, which is why it survived');
+  assert.doesNotThrow(() => new RegExp(broken),
+    'and it compiles, so nothing ever complained');
+});

package/tests/knip_ratchet_ambient.mjs

@@ -0,0 +1,101 @@
+// tests/knip_ratchet_ambient.mjs — the knip ratchet refuses to score through an
+// ambient knip, instead of failing CLOSED on a number it cannot compare (task 1003987).
+//
+// THE DEFECT. `npx --no-install` walks UP the directory tree. A git worktree has no
+// node_modules of its own, so the lookup climbs out to the main checkout and succeeds —
+// and knip, unable to resolve itself as a declared dependency of the tree it is
+// scanning, reports ITSELF as an unlisted binary.
+//
+// MEASURED on one tree, 2026-09-17:
+//   main checkout (knip local)   -> 221, PASS
+//   worktree      (knip ambient) -> 222, FAIL against baseline 221
+// The extra was `binaries: package.json knip`. Diffed BY NAME the exports lists were
+// identical — 221 both sides. Nothing about the code had moved.
+//
+// That false red cost a full elimination pass on task 1003848: the count was the
+// loudest signal on the board and it pointed away from the real defect.
+//
+// The module's contract is fail-OPEN on infrastructure, fail-CLOSED on findings. A
+// count taken through an ambient knip is an infrastructure artefact, so it must not be
+// scored. CI is unaffected — `npm ci` puts knip in the project's own node_modules.
+//
+// Run:  node --test tests/knip_ratchet_ambient.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const ratchets = require('../scripts/gds/fitness-ratchets.js');
+const SRC = readFileSync(path.join(REPO_ROOT, 'scripts/gds/fitness-ratchets.js'), 'utf8');
+
+test('the local-knip check runs BEFORE npx, so an ambient knip is never scored', () => {
+  const fn = SRC.slice(SRC.indexOf('function knipIssueCount()'));
+  const body = fn.slice(0, fn.indexOf('\n}\n'));
+  const guard = body.indexOf('localKnipPath()');
+  const spawn = body.indexOf('execSync(');
+  assert.ok(guard > 0 && spawn > 0, 'both the guard and the spawn must be present');
+  assert.ok(guard < spawn,
+    'checking after spawning would score the ambient count first — the whole bug');
+});
+
+test('it returns null (skip) rather than a number when knip is not local', () => {
+  // The fail direction matters: a number here is compared against a baseline measured
+  // with a LOCAL knip, so returning one is worse than returning nothing.
+  const fn = SRC.slice(SRC.indexOf('function knipIssueCount()'));
+  const body = fn.slice(0, fn.indexOf('\n}\n'));
+  assert.match(body, /if \(!localKnipPath\(\)\)[\s\S]{0,600}return null;/,
+    'the unresolvable case must skip, not score');
+});
+
+test('the skip NAMES its cause — a generic line sent readers hunting a broken install', () => {
+  assert.equal(typeof ratchets.lastKnipSkipReason, 'function');
+  ratchets.knipIssueCount();
+  const reason = ratchets.lastKnipSkipReason();
+  // In this repo the test runs where knip IS local (CI, main checkout), so the reason
+  // is null; where it is NOT local the reason must be specific. Assert whichever case
+  // this machine is in, so the test is meaningful on both.
+  if (ratchets.localKnipPath()) {
+    assert.equal(reason, null, 'a scored run must not claim it was skipped');
+  } else {
+    assert.ok(reason && /knip/i.test(reason), 'the skip must say what was missing');
+    assert.match(reason, /node_modules/, 'and where it looked');
+  }
+});
+
+test('localKnipPath finds a knip that IS local, and reports none when it is not', () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'knipprobe-'));
+  try {
+    // The predicate is about THIS repo's root, so prove it against the real answer
+    // rather than a reimplementation: it must agree with the filesystem.
+    const expected = ['node_modules/knip/package.json', 'node_modules/.bin/knip']
+      .some((rel) => fs.existsSync(path.join(REPO_ROOT, rel)));
+    assert.equal(!!ratchets.localKnipPath(), expected,
+      'localKnipPath must agree with what is actually on disk');
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test('the caller fails OPEN on a skip — an unscorable metric is not a violation', () => {
+  assert.match(SRC, /knip not scored: \$\{lastKnipSkipReason\(\)/,
+    'the warning must carry the specific reason');
+  const warnIdx = SRC.indexOf('knip not scored:');
+  const after = SRC.slice(warnIdx, warnIdx + 300);
+  assert.match(after, /process\.exit\(0\)/,
+    'a skip must exit 0 — failing closed here is what this task removed');
+});
+
+test('a REAL regression still fails closed — the fix narrows nothing', () => {
+  // Guard against "fixed" by making the whole metric advisory.
+  const knipOnly = SRC.slice(SRC.indexOf('if (knipOnly)'));
+  const block = knipOnly.slice(0, knipOnly.indexOf('return;'));
+  assert.match(block, /violations\.length/, 'violations must still be evaluated');
+  assert.match(block, /process\.exit\(1\)/, 'and still fail the gate when present');
+});

package/tests/rank_floor_wiring.mjs

@@ -52,6 +52,10 @@ async function createdFloor({ scopeModules, needsMigration = false, requiresRank
   await createTask({
     versionId: 'BONGOS-V2',
     title: 'a task',
+    // Stated rather than inferred (task 1002988): createTask now refuses a craft it
+    // cannot work out, and "a task" says nothing. This fixture is about the RANK
+    // FLOOR, so it should not be at the mercy of the discipline heuristic.
+    discipline: 'engineer',
     goalId: '1000111',
     needsMigration,
     requiresRank,

package/tests/reward_gate.mjs

@@ -210,7 +210,7 @@ async function withStubbedCreatePool(run) {
 
 t('a task CREATED with NO reward is born with a positive, capped value', async () => {
   await withStubbedCreatePool(async (captured) => {
-    const row = await db.createTask({ versionId: 1, goalId: 77, title: 't', kind: 'feature', estMinutes: 40 });
+    const row = await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', kind: 'feature', estMinutes: 40 });
     assert.ok(captured.creditsReward > 0, 'INSERT must bind a positive credits_reward');
     assert.equal(captured.creditsReward, 40, 'feature @40min -> 40 drachmae');
     assert.ok(captured.creditsReward <= db.REWARD_SUGGESTION_CAP, 'must respect the cap');
@@ -220,7 +220,7 @@ t('a task CREATED with NO reward is born with a positive, capped value', async (
 
 t('a task CREATED with credits_reward 0 (the route default) is auto-assigned', async () => {
   await withStubbedCreatePool(async (captured) => {
-    await db.createTask({ versionId: 1, goalId: 77, title: 't', creditsReward: 0, kind: 'bug', estMinutes: 40 });
+    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', creditsReward: 0, kind: 'bug', estMinutes: 40 });
     // bug weight 1.25 -> 50; 0 is treated as "unset" so the default kicks in.
     assert.equal(captured.creditsReward, 50);
   });
@@ -228,14 +228,14 @@ t('a task CREATED with credits_reward 0 (the route default) is auto-assigned', a
 
 t('a huge-est new task is CAPPED at creation, not ballooned', async () => {
   await withStubbedCreatePool(async (captured) => {
-    await db.createTask({ versionId: 1, goalId: 77, title: 't', kind: 'feature', estMinutes: 9999 });
+    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', kind: 'feature', estMinutes: 9999 });
     assert.equal(captured.creditsReward, db.REWARD_SUGGESTION_CAP);
   });
 });
 
 t('an EXPLICIT positive credits_reward is PRESERVED (never overridden)', async () => {
   await withStubbedCreatePool(async (captured) => {
-    await db.createTask({ versionId: 1, goalId: 77, title: 't', creditsReward: 17, kind: 'feature', estMinutes: 40 });
+    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', creditsReward: 17, kind: 'feature', estMinutes: 40 });
     assert.equal(captured.creditsReward, 17, 'author-set positive value must survive untouched');
   });
 });

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 },
   );
 });