@bongos/core 1.19.638 → 1.19.640

package/tests/role_responsibilities.mjs

@@ -0,0 +1,187 @@
+// tests/role_responsibilities.mjs
+//
+// task 1003732 (goal 1000095, criterion wa6-written-responsibilities) — the three
+// written role responsibilities land as ONE source with three consumers.
+//
+// WHAT IS WORTH PINNING HERE. The criterion's whole content is "one source, shown
+// on the profile, injected into the pack, referenced by grading". So the failure to
+// guard against is not a typo — it is a SECOND COPY. If the packs, the hall and the
+// grader can each hold their own wording, the project can show a builder one
+// standard and judge them by another, which is the specific unfairness the single
+// source exists to prevent. Every test below is a leg of that.
+//
+// The text itself is the owner's, verbatim (fixed 2026-09-08). It is asserted here
+// character-for-character on purpose: a well-meaning tidy-up of someone else's
+// authored sentence is exactly the drift this task forbids, and a test is the only
+// thing that makes "do not paraphrase" survive contact with a future editor.
+//
+// Run:  node tests/role_responsibilities.mjs
+
+import { strict as assert } from 'node:assert';
+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 src = require(path.join(ROOT, 'src', 'role-responsibilities.js'));
+const modules = require(path.join(ROOT, 'src', 'modules.js'));
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+const gen = require(path.join(ROOT, 'scripts', 'gds', 'gen-role-responsibilities.js'));
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// --- the source ---------------------------------------------------------
+
+// The owner's sentences, verbatim from criterion wa6-written-responsibilities.
+// Duplicated here deliberately — a test that read the value it is checking would
+// assert nothing. This copy is the fixture; the source file is the subject.
+const OWNER_TEXT = {
+  engineer: 'Running and optimizing the running of Claude nonstop, and ensuring Ideators and Artists can continue to interface with that system effectively.',
+  artist: 'No slop in the appearance and text of the project; the story, emotion and ideology of the project are communicated effectively; project purpose and gravitas are upheld.',
+  ideator: 'Make good ideas; be a philosopher / thought leader for the project; enable Engineers to scope and Artists to create with maximum efficiency — a baseline for creating scopes of work.',
+};
+
+test('the three statements are the owner\'s text, character for character', () => {
+  assert.deepEqual({ ...src.ROLE_RESPONSIBILITIES }, OWNER_TEXT);
+});
+
+test('exactly the three CORE crafts carry a statement — no more, no fewer', () => {
+  assert.deepEqual(Object.keys(src.ROLE_RESPONSIBILITIES), ['engineer', 'artist', 'ideator']);
+  // Governor is deferred (ADR 0274) and `ui` is module-contributed (ADR 0272):
+  // inventing a sentence for either is the paraphrase this task forbids.
+  assert.equal(src.responsibilityFor('ui'), null);
+  assert.equal(src.responsibilityFor('governor'), null);
+});
+
+test('the map is frozen — a consumer cannot edit the standard at runtime', () => {
+  assert.ok(Object.isFrozen(src.ROLE_RESPONSIBILITIES));
+});
+
+test('responsibilityFor: case-insensitive, and absence is null not a placeholder', () => {
+  assert.equal(src.responsibilityFor('ENGINEER'), OWNER_TEXT.engineer);
+  for (const bad of [null, undefined, '', 'unclassified', 42, {}]) {
+    assert.equal(src.responsibilityFor(bad), null, `${JSON.stringify(bad)} must be null`);
+  }
+});
+
+test('responsibilitiesFor scopes to the disciplines an instance offers', () => {
+  assert.deepEqual(src.responsibilitiesFor(['artist', 'ui']), { artist: OWNER_TEXT.artist });
+  assert.deepEqual(src.responsibilitiesFor([]), {});
+  assert.deepEqual(src.responsibilitiesFor(null), {});
+});
+
+// --- consumer 1: the hall (via the injected client projection) ----------
+
+test('clientModules carries the statements for the offered crafts only', () => {
+  const c = modules.clientModules();
+  for (const d of Object.keys(c.responsibilities)) {
+    assert.ok(c.disciplines.includes(d), `${d} is offered a statement but is not an offered discipline`);
+    assert.equal(c.responsibilities[d], OWNER_TEXT[d], `${d}: the projection must not reword the source`);
+  }
+  // `ui` is offered by the ui-design module but has no statement — the projection
+  // must carry the craft without inventing a standard for it.
+  if (c.disciplines.includes('ui')) assert.equal(c.responsibilities.ui, undefined);
+});
+
+// --- consumer 2: the grader (via the module doorway) --------------------
+
+test('the doorway exposes it, so a module never deep-requires the source', () => {
+  assert.equal(api.responsibilityFor('artist'), OWNER_TEXT.artist);
+  assert.deepEqual({ ...api.ROLE_RESPONSIBILITIES }, OWNER_TEXT);
+});
+
+test('the grader prompt states the standard for a craft, and stays silent without one', () => {
+  const { buildPrompt } = require(path.join(ROOT, 'modules', 'grading', 'grader-prompt.js'));
+  const build = (discipline) => buildPrompt({
+    task: { id: 1, title: 't', kind: 'feature', discipline },
+    valueSummary: 'v', changedFiles: ['a.js'], diff: 'x',
+  });
+  assert.ok(build('artist').includes(OWNER_TEXT.artist), 'the artist statement must reach the prompt verbatim');
+  // A craft with no written standard must not get an invented one — a grader told
+  // "this role has no standard" would supply its own.
+  for (const d of ['ui', 'unclassified', undefined]) {
+    assert.ok(!build(d).includes('What this craft is answerable for'), `${d} must add no responsibility line`);
+  }
+});
+
+// --- consumer 3: the packs (generated, so they cannot drift) ------------
+
+test('every pack the registry names carries the block, matching the source', () => {
+  const { writes, warnings } = gen.plan();
+  assert.deepEqual(writes.map((w) => w.rel), [], `a pack block is stale: ${writes.map((w) => w.rel).join(', ')}`);
+  assert.deepEqual(warnings, [], `every registered pack must carry the marker pair: ${warnings.join(' | ')}`);
+});
+
+test('the block carries the statement verbatim and says it is generated', () => {
+  for (const t of gen.packTargets()) {
+    const text = fs.readFileSync(t.abs, 'utf8');
+    const expected = OWNER_TEXT[t.discipline];
+    if (!expected) continue;
+    assert.ok(text.includes(expected), `${t.rel} must quote the ${t.discipline} statement verbatim`);
+    assert.ok(text.includes(gen.BEGIN) && text.includes(gen.END), `${t.rel} must keep the marker pair`);
+    assert.ok(/do not hand-edit/i.test(text), `${t.rel} must warn that the block is generated`);
+  }
+});
+
+test('the generator is idempotent and preserves a CRLF pack\'s line endings', () => {
+  // The packs are .md: CRLF on a Windows checkout, LF in CI. A generator that
+  // always wrote '\n' would make the committed bytes platform-dependent, so the
+  // freshness gate would be red on one checkout and green on the other.
+  const block = gen.blockFor('artist');
+  const crlf = `head\r\n${gen.BEGIN}\r\nstale\r\n${gen.END}\r\ntail\r\n`;
+  const out = gen.inject(crlf, block);
+  assert.ok(!/[^\r]\n/.test(out), 'a CRLF file must stay pure CRLF');
+  assert.equal(gen.inject(out, block), out, 'a second pass must change nothing');
+
+  const lf = `head\n${gen.BEGIN}\nstale\n${gen.END}\ntail\n`;
+  const outLf = gen.inject(lf, block);
+  assert.ok(!outLf.includes('\r'), 'an LF file must stay pure LF');
+  assert.equal(gen.inject(outLf, block), outLf, 'a second pass must change nothing');
+});
+
+test('a pack with no markers is reported, never silently skipped', () => {
+  assert.equal(gen.inject('no markers here', gen.blockFor('artist')), null);
+});
+
+// --- the whole point: there is no second copy ---------------------------
+
+test('no consumer hardcodes a statement — the packs\' generated blocks are the only copies', () => {
+  // Anything that repeats a statement outside the source, its generated blocks, the
+  // criterion record, or this fixture is a second copy that can drift.
+  const ALLOWED = new Set([
+    'src/role-responsibilities.js',   // the source
+    'docs/packs/engineer.md',         // generated blocks
+    'docs/packs/artist.md',
+    'docs/packs/ideator.md',
+    'tests/role_responsibilities.mjs', // this fixture
+  ]);
+  const scan = ['src', 'scripts', 'modules', 'tests', 'docs/packs'];
+  const offenders = [];
+  const walk = (dir) => {
+    let entries = [];
+    try { entries = fs.readdirSync(path.join(ROOT, dir), { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const rel = `${dir}/${e.name}`;
+      if (e.isDirectory()) { if (e.name !== 'node_modules') walk(rel); continue; }
+      if (!/\.(js|mjs|md|json|html)$/.test(e.name)) continue;
+      if (ALLOWED.has(rel)) continue;
+      let text;
+      try { text = fs.readFileSync(path.join(ROOT, rel), 'utf8'); } catch { continue; }
+      for (const [craft, sentence] of Object.entries(OWNER_TEXT)) {
+        if (text.includes(sentence)) offenders.push(`${rel} repeats the ${craft} statement`);
+      }
+    }
+  };
+  for (const d of scan) walk(d);
+  assert.deepEqual(offenders, [], `a second copy can drift from the source:\n  ${offenders.join('\n  ')}`);
+});
+
+console.log(`\nrole_responsibilities: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/sequence.mjs

@@ -16,10 +16,15 @@ const {
   pickNext,
   summarize,
   MIN_SPEC_CHARS,
+  fetchGoalTasks,
+  fetchGoalTaskRows,
+  declaredSurfaceExcludesMigrations,
+  GOAL_PAGE,
 } = require('../scripts/gds/sequence.js');
 
 let passed = 0, failed = 0;
 const t = (n, f) => { try { f(); passed++; console.log(`  PASS  ${n}`); } catch (e) { failed++; console.log(`  FAIL  ${n}\n        ${e.message}`); } };
+const ta = async (n, f) => { try { await f(); passed++; console.log(`  PASS  ${n}`); } catch (e) { failed++; console.log(`  FAIL  ${n}\n        ${e.message}`); } };
 
 // A description long enough to clear the thin-spec gate, so fixtures testing
 // OTHER halt reasons don't trip it incidentally.
@@ -327,5 +332,157 @@ t('pickNext on an empty plan returns no pick and nothing skipped', () => {
   assert.equal(r.head, null);
 });
 
+// ------------------------------------------------- goal paging (task 1003699)
+
+// A fake board big enough to have the cliff the bug fell off. The UNFILTERED
+// listing is capped at UNFILTERED_CAP rows exactly as the real route caps
+// ?limit at 1000, so a row past it is genuinely unreachable that way — which is
+// what makes the acceptance test meaningful rather than a small-instance smoke.
+const UNFILTERED_CAP = 1000;
+
+function fakeBoard({ goalId = 42, rowsInGoal = 3, targetIndex = 1100, total = 1200, failPages = [] } = {}) {
+  const table = [];
+  for (let i = 0; i < total; i += 1) {
+    table.push({ id: 10000 + i, title: `filler ${i}`, status: 'ready', goal_id: 999, touches: [] });
+  }
+  // The task under test sits PAST the unfiltered cap, and is in the goal.
+  table[targetIndex] = { id: 777, title: 'the task past the window', status: 'ready', goal_id: goalId, touches: [] };
+  for (let k = 1; k < rowsInGoal; k += 1) {
+    table[targetIndex - k] = { id: 800 + k, title: `sibling ${k}`, status: 'ready', goal_id: goalId, touches: [] };
+  }
+
+  const calls = [];
+  const api = {
+    tasks: {
+      async getTasks({ query } = {}) {
+        const q = query || {};
+        calls.push({ ...q });
+        if (q.offset === 0) return { ok: false, status: 400 };   // the real route's rule
+        const page = calls.length - 1;
+        if (failPages.includes(page)) return { ok: false, status: 500 };
+        const rows = q.goal_id === undefined
+          ? table.slice(0, UNFILTERED_CAP)
+          : table.filter((r) => Number(r.goal_id) === Number(q.goal_id));
+        const off = Number(q.offset) || 0;
+        const lim = Number(q.limit) || rows.length;
+        return { ok: true, data: { tasks: rows.slice(off, off + lim) } };
+      },
+      async getTasksId({ id }) {
+        const row = table.find((r) => Number(r.id) === Number(id));
+        return row ? { ok: true, data: { task: { ...row, dependencies: [], dependents: [] } } } : { ok: false };
+      },
+    },
+  };
+  return { api, calls, table };
+}
+
+await ta('the unfiltered listing genuinely cannot see the task — the premise of the bug', async () => {
+  const { api } = fakeBoard();
+  const r = await api.tasks.getTasks({ query: { limit: 1000 } });
+  const ids = (r.data.tasks || []).map((x) => Number(x.id));
+  assert.equal(ids.length, UNFILTERED_CAP);
+  assert.ok(!ids.includes(777), 'task 777 must sit outside the unfiltered window, or this suite proves nothing');
+});
+
+await ta('--goal finds a task that is NOT in the first page of the unfiltered listing', async () => {
+  const { api } = fakeBoard();
+  const byId = await fetchGoalTasks(api, 42, 50);
+  assert.ok(byId.has(777), 'the goal-scoped read must return the task past the 1000-row window');
+  assert.equal(byId.size, 3, 'and its two siblings, and nothing from another goal');
+});
+
+await ta('a goal larger than one page is paged until exhausted, and offset=0 is never sent', async () => {
+  const { api, calls } = fakeBoard({ rowsInGoal: GOAL_PAGE + 7, targetIndex: 1100, total: 2000 });
+  const rows = await fetchGoalTaskRows(api, 42);
+  assert.equal(rows.length, GOAL_PAGE + 7, 'every row in the goal, across pages');
+  assert.ok(calls.length >= 2, 'more than one page was requested');
+  assert.equal(calls[0].offset, undefined, 'page one sends no offset (the route rejects offset=0)');
+  assert.equal(calls[1].offset, GOAL_PAGE, 'page two continues from the page size');
+  assert.ok(calls.every((c) => c.goal_id === 42), 'every page is scoped server-side');
+});
+
+await ta('an unreadable FIRST page throws — it must never read as an empty chain', async () => {
+  const { api } = fakeBoard({ failPages: [0] });
+  await assert.rejects(() => fetchGoalTaskRows(api, 42), (e) => {
+    assert.match(e.message, /refusing to report a partial goal/);
+    assert.match(e.message, /goal 42 at offset 0/, 'the message names which page failed');
+    return true;
+  });
+});
+
+await ta('a LATER page failing also throws — a partial goal must not read as a whole one', async () => {
+  const { api } = fakeBoard({ rowsInGoal: GOAL_PAGE + 7, targetIndex: 1100, total: 2000, failPages: [1] });
+  await assert.rejects(() => fetchGoalTaskRows(api, 42), /refusing to report a partial goal/);
+});
+
+await ta('the goal_id match is kept as a guard against a core that ignores the param', async () => {
+  const { api } = fakeBoard();
+  // Simulate a pinned older core: the goal_id filter is silently ignored.
+  const inner = api.tasks.getTasks;
+  api.tasks.getTasks = ({ query } = {}) => inner({ query: { ...query, goal_id: undefined } });
+  const byId = await fetchGoalTasks(api, 42, 50);
+  assert.equal(byId.size, 0, 'a whole-table answer must not become someone else\'s plan');
+});
+
+// -------------------------------------------- needs_migration (task 1003699)
+
+await ta('needs_migration no longer halts on the word alone (task 1003697\'s shape)', async () => {
+  // The real 1003697: the flag set from prose, four touched files, none of them a
+  // migration — and a description that DOES contain a literal migrations/ path,
+  // which is why keying on the prose would not have fixed anything.
+  const t1003697 = task({
+    id: 1003697,
+    needs_migration: true,
+    touches: ['config/rename-history-baseline.json', 'scripts/gds/gds-literal-scan.js',
+      'scripts/gds/rename-history-check.js', 'tests/rename_history_restraint.mjs'],
+    description: `${SPEC} see migrations/163_goal_dep_trigger.sql — DO NOT change any migration`,
+  });
+  assert.ok(declaredSurfaceExcludesMigrations(t1003697));
+  const reasons = haltReasons(t1003697, { rank: 'metic', claimableIds: new Set([1003697]) });
+  assert.ok(!reasons.some((r) => r.code === 'needs_migration'), reasons.map((r) => r.code).join(','));
+});
+
+await ta('a task that genuinely touches migrations/ still halts', async () => {
+  const real = task({ id: 5, needs_migration: true, touches: ['migrations/214_add_column.sql', 'src/x.js'] });
+  assert.equal(declaredSurfaceExcludesMigrations(real), false);
+  const reasons = haltReasons(real, { rank: 'metic', claimableIds: new Set([5]) });
+  assert.ok(reasons.some((r) => r.code === 'needs_migration'));
+});
+
+await ta('a flagged task with NO declared surface keeps halting — silence is not evidence', async () => {
+  for (const touches of [[], undefined]) {
+    const unknown = task({ id: 6, needs_migration: true, touches });
+    assert.equal(declaredSurfaceExcludesMigrations(unknown), false);
+    const reasons = haltReasons(unknown, { rank: 'metic', claimableIds: new Set([6]) });
+    assert.ok(reasons.some((r) => r.code === 'needs_migration'), `touches=${JSON.stringify(touches)}`);
+  }
+});
+
+await ta('a MODULE-OWNED migration counts — modules/<key>/migrations/ is real schema work here', async () => {
+  // ADR 0083 / docs/modules-contract.md: ten modules ship their own migrations.
+  // An anchored ^migrations/ test called these "not a migration" and suppressed
+  // the halt — and nothing else would have caught it, because the protected-path
+  // registry's own migrations/ glob is root-anchored too.
+  for (const p of [
+    'modules/economy/migrations/012_add_col.sql',
+    'modules/lifecycle/migrations/163_goal_dep_trigger.sql',
+    'src/db/migrations/x.sql',
+  ]) {
+    const real = task({ id: 7, needs_migration: true, touches: [p, 'src/x.js'] });
+    assert.equal(declaredSurfaceExcludesMigrations(real), false, p);
+    const reasons = haltReasons(real, { rank: 'metic', claimableIds: new Set([7]) });
+    assert.ok(reasons.some((r) => r.code === 'needs_migration'), `${p} must still halt`);
+  }
+});
+
+await ta('the migrations match reads a path SEGMENT, so a lookalike filename does not count', async () => {
+  assert.equal(declaredSurfaceExcludesMigrations(task({ needs_migration: true, touches: ['./migrations/9.sql'] })), false);
+  assert.equal(declaredSurfaceExcludesMigrations(task({ needs_migration: true, touches: ['Migrations/9.sql'] })), false);
+  assert.equal(declaredSurfaceExcludesMigrations(task({ needs_migration: true, touches: ['modules\\economy\\migrations\\012.sql'] })), false);
+  // The word in a FILE name, with no migrations directory, is not schema work.
+  assert.equal(declaredSurfaceExcludesMigrations(task({ needs_migration: true, touches: ['docs/migrations-guide.md'] })), true);
+  assert.equal(declaredSurfaceExcludesMigrations(task({ needs_migration: true, touches: ['docs/recipes/migrations.md'] })), true);
+});
+
 console.log(`\nsequence: ${passed} passed, ${failed} failed`);
 process.exit(failed ? 1 : 0);