@bongos/core 1.19.816 → 1.19.818

package/tests/migration_allocation.mjs

@@ -168,6 +168,76 @@ function shouldReserveMigrationNumber(task) {
     }
   });
 
+  // ---- task 1003910: "schema" must be QUALIFIED to flag ------------------
+  //
+  // The live false positive (task 1003902, flagged though it alters no table) was
+  // NOT caused by the `--json-schema` flag the bug report blamed — that compound
+  // was already stripped. It was a bare back-reference later in the same
+  // paragraph. The first case below is that exact sentence, so a regression
+  // reintroducing a bare-"schema" rule fails on the wording that actually shipped
+  // the bug rather than on a paraphrase of it.
+  await test('a BARE "schema" no longer flags — the live task 1003902 wording (task 1003910)', () => {
+    const falsePositives = [
+      '`result` is EMPTY when a schema is in play, which reads as a failure if you parse the wrong field',
+      'Require a structured verdict via --json-schema',
+      'a JSON Schema for the payload',
+      'see the schema.org markup',
+      'the --output-schema flag takes a path',
+      'the worker returns a schema',
+    ];
+    for (const text of falsePositives) {
+      assert.equal(detectsMigration(text), false, `must NOT flag: ${JSON.stringify(text)}`);
+    }
+  });
+
+  await test('a DB noun or a change verb is what makes "schema" count (task 1003910)', () => {
+    const truePositives = [
+      'DB schema change',
+      'the database schema for tasks',
+      'table-schema drift',
+      'schema bump for the counter',
+      'change the schema of tasks',
+      'altering the task schema',
+    ];
+    for (const text of truePositives) {
+      assert.equal(detectsMigration(text), true, `must flag: ${JSON.stringify(text)}`);
+    }
+  });
+
+  // The direction of the failure is the point: an unrecognised phrasing must fall
+  // to NOT-flagged. A false positive reserves a migration number that is never
+  // used (task 1002614 burned 213), floors the task at Metic (ADR 0270) and halts
+  // an unattended chain; a missed one is a PATCH, the same correction a false one
+  // always needed.
+  await test('an unknown "schema" phrasing fails SAFE, not loud (task 1003910)', () => {
+    assert.equal(detectsMigration('the widget-schema thing nobody has named yet'), false);
+    assert.equal(detectsMigration('schema'), false, 'the bare noun alone decides nothing');
+  });
+
+  // A change VERB is not evidence on its own. The first cut of task 1003910's
+  // allowlist let any verb legitimise any noun, so 'update the response schema'
+  // flagged — the exact false-positive class task 1002648 fixed for the old
+  // blocklist, reintroduced by the mechanism that replaced it. The noun slot now
+  // excludes API/transport nouns, and these pin that it stays excluded.
+  await test('a change verb does NOT legitimise an API noun (task 1003910)', () => {
+    const falsePositives = [
+      'update the response schema',
+      'modify the API schema',
+      'change the request schema',
+      'updating the json schema',
+      'extend the payload schema',
+    ];
+    for (const text of falsePositives) {
+      assert.equal(detectsMigration(text), false, `must NOT flag: ${JSON.stringify(text)}`);
+    }
+  });
+
+  await test('the same verbs still flag a DB-shaped or unqualified noun (task 1003910)', () => {
+    for (const text of ['change the schema of tasks', 'alter the table schema', 'altering the task schema', 'change the schema']) {
+      assert.equal(detectsMigration(text), true, `must flag: ${JSON.stringify(text)}`);
+    }
+  });
+
   await test('classifier still flags real schema work (regression)', () => {
     const truePositives = [
       'add a migration to backfill the marker',

package/tests/speciality_offered.mjs

@@ -0,0 +1,212 @@
+// tests/speciality_offered.mjs — a project puts its name behind a speciality, and
+// a builder decides whether to take it (task 1003972).
+//
+// THE ONE RULE EVERYTHING HERE PROTECTS: it OFFERS, it does not ADOPT. A
+// speciality's contract_md is injected into every session where the adopter holds
+// a claim in that craft, and ADR 0296's consent work exists because that text is
+// another builder's text arriving in this builder's session. Auto-adopting a
+// project's presets would hand every new builder a standing instruction they never
+// read — the same failure, arriving by a different door.
+//
+// So the negative cases are the load-bearing ones, as usual: nothing here may
+// return a speciality the viewer cannot adopt, and nothing may adopt on their
+// behalf.
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const S = require(path.join(ROOT, 'modules', 'specialities', 'specialities.js'));
+const db = require(path.join(ROOT, 'modules', 'specialities', 'db.js'));
+
+const ME = '1000025';
+const spec = (over = {}) => ({
+  id: '1', name: 'Economics', discipline: 'ideator',
+  owner_kind: 'builder', owner_builder_id: '1000099',
+  visibility: 'public', offered: true, ...over,
+});
+const viewer = { builderId: ME, projectIds: ['p1'] };
+
+// ---------- the rule ----------
+test('an offered, adoptable speciality is suggested', () => {
+  assert.deepEqual(S.offeredTo([spec()], viewer, []).map((s) => s.id), ['1']);
+});
+
+test('a speciality nobody offered is NOT a suggestion, however visible', () => {
+  assert.deepEqual(S.offeredTo([spec({ offered: false })], viewer, []), []);
+});
+
+test('an offered speciality the viewer may not adopt is NOT suggested', () => {
+  // The whole point of running canAdopt here rather than trusting the query: a
+  // private speciality belonging to someone else must never be recommended, and a
+  // widened SQL filter must not be able to change that.
+  const theirs = spec({ visibility: 'private', owner_builder_id: '1000099' });
+  assert.deepEqual(S.offeredTo([theirs], viewer, []), []);
+});
+
+test('a builder-owned speciality set to "project" is not suggested to others', () => {
+  // It resolves to no project, so canAdopt treats it as owner-only. The offer
+  // flag must not smuggle it past that.
+  assert.deepEqual(S.offeredTo([spec({ visibility: 'project' })], viewer, []), []);
+});
+
+test('a speciality you already hold is not suggested back to you', () => {
+  const adoptions = [{ id: '1', discipline: 'ideator', active: true }];
+  assert.deepEqual(S.offeredTo([spec()], viewer, adoptions), []);
+});
+
+test('an inactive past adoption still suppresses the suggestion', () => {
+  // You have had it; re-suggesting something you dropped is nagging, not helping.
+  const adoptions = [{ id: '1', discipline: 'ideator', active: false }];
+  assert.deepEqual(S.offeredTo([spec()], viewer, adoptions), []);
+});
+
+test('a craft you already have an ACTIVE speciality in yields no suggestion', () => {
+  // One active speciality per craft is a DB constraint (the partial unique index),
+  // so offering a second in the same craft is offering something that would be
+  // refused. Surfacing it as neither is the honest answer.
+  const adoptions = [{ id: '77', discipline: 'ideator', active: true }];
+  assert.deepEqual(S.offeredTo([spec()], viewer, adoptions), []);
+});
+
+test('a different craft is still suggested while one craft is taken', () => {
+  const adoptions = [{ id: '77', discipline: 'artist', active: true }];
+  assert.deepEqual(S.offeredTo([spec()], viewer, adoptions).map((s) => s.id), ['1']);
+});
+
+test('offeredTo never adopts, and never mutates what it was given', () => {
+  const rows = [spec()];
+  const before = JSON.stringify(rows);
+  const adoptions = [];
+  S.offeredTo(rows, viewer, adoptions);
+  assert.equal(JSON.stringify(rows), before, 'the catalogue is not rewritten');
+  assert.deepEqual(adoptions, [], 'nothing was adopted on the builder\'s behalf');
+});
+
+test('missing inputs yield no suggestions rather than throwing', () => {
+  assert.deepEqual(S.offeredTo(null, viewer), []);
+  assert.deepEqual(S.offeredTo([spec()], null), []);
+  assert.deepEqual(S.offeredTo([spec()], viewer, null).map((s) => s.id), ['1']);
+});
+
+// ---------- the queries ----------
+function fake(results = []) {
+  const calls = [];
+  const queue = [...results];
+  const exec = async (text, params) => {
+    calls.push({ sql: text.replace(/\s+/g, ' ').trim(), params });
+    return queue.shift() || { rows: [], rowCount: 0 };
+  };
+  exec.calls = calls;
+  return exec;
+}
+
+test('offering records WHO offered it and when', () => {
+  // A recommendation carries someone's name by definition — the surface says who
+  // suggested it, so a builder accepting a standing instruction can see whose
+  // judgement they are taking.
+  const q = fake([{ rows: [{ id: '1' }], rowCount: 1 }]);
+  return db.setOffered('1', { offered: true, builderId: ME }, q).then(() => {
+    assert.match(q.calls[0].sql, /offered = \$2/);
+    assert.match(q.calls[0].sql, /offered_by = CASE WHEN \$2 THEN \$3::bigint ELSE NULL END/);
+    assert.match(q.calls[0].sql, /offered_at = CASE WHEN \$2 THEN now\(\) ELSE NULL END/);
+    assert.deepEqual(q.calls[0].params, ['1', true, ME]);
+  });
+});
+
+test('withdrawing an offer clears the witness rather than leaving a stale name', async () => {
+  const q = fake([{ rows: [{ id: '1' }], rowCount: 1 }]);
+  await db.setOffered('1', { offered: false, builderId: null }, q);
+  assert.deepEqual(q.calls[0].params, ['1', false, null]);
+});
+
+test('listOffered filters on the flag AND on visibility, never the flag alone', async () => {
+  const q = fake([{ rows: [], rowCount: 0 }]);
+  await db.listOffered({ builderId: ME, projectIds: ['p1'] }, q);
+  const sql = q.calls[0].sql;
+  assert.match(sql, /WHERE offered/);
+  assert.match(sql, /visibility = 'public'/);
+  assert.match(sql, /owner_builder_id = \$1/);
+});
+
+// ---------- the wiring, which fails loudly only if someone checks ----------
+const src = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8');
+
+test('GET /specialities/offered is registered BEFORE /specialities/:id', () => {
+  // Express matches in registration order. Registered after, the :id route
+  // captures "offered" as an id — which is exactly what happened when this was
+  // first written, under a comment claiming the opposite.
+  const routes = src('modules/specialities/routes/specialities.js');
+  const offered = routes.indexOf("router.get('/specialities/offered'");
+  const byId = routes.indexOf("router.get('/specialities/:id'");
+  assert.ok(offered > 0 && byId > 0, 'both routes exist');
+  assert.ok(offered < byId, 'the literal path must be registered before the parameterised one');
+});
+
+test('offering is gated on project.curate, not on ownership', () => {
+  // Editing your own speciality is yours; recommending one to everybody is a
+  // claim on their attention and their sessions. Different act, different gate.
+  const routes = src('modules/specialities/routes/specialities.js');
+  for (const verb of ['offer', 'unoffer']) {
+    const at = routes.indexOf(`router.post('/specialities/:id/${verb}'`);
+    assert.ok(at > 0, `${verb} route exists`);
+    const decl = routes.slice(at, at + 220);
+    assert.match(decl, /requirePermission\('project\.curate'\)/, `${verb} must carry the curation gate`);
+  }
+});
+
+test('EVERY :id route checks visibleTo — including the curation ones', () => {
+  // The finding this test exists for: offer/unoffer read a speciality by id and
+  // skipped visibleTo, which every sibling performed. project.curate says "you
+  // may curate", not "you may curate THIS row" — so a curator could offer a
+  // project-owned speciality belonging to a project they are not in, and the
+  // 403-vs-404 shape confirmed its existence besides.
+  //
+  // DERIVED from the source rather than listed, so a route added later is covered
+  // without anyone remembering to extend this test.
+  const routes = src('modules/specialities/routes/specialities.js');
+  const decls = [...routes.matchAll(/router\.(get|post|patch|delete)\('(\/specialities\/:id[^']*)'/g)];
+  assert.ok(decls.length >= 6, `expected the :id routes to be found, saw ${decls.length}`);
+
+  let checked = 0;
+  for (const m of decls) {
+    const start = m.index;
+    // The handler body runs to the next router. registration, or to the end.
+    const nextAt = routes.indexOf('router.', start + 10);
+    const body = routes.slice(start, nextAt > 0 ? nextAt : routes.length);
+
+    // The rule applies to routes that READ the row. POST /:id/abandon does not:
+    // it deactivates the CALLER'S OWN adoption via db.abandon(req.builder.id, id),
+    // so the row is scoped by the session rather than by the path — a speciality
+    // you cannot see is one you never adopted, and the query matches nothing.
+    if (!/db\.getSpeciality\(/.test(body)) {
+      assert.match(body, /req\.builder\.id/,
+        `${m[1].toUpperCase()} ${m[2]} neither reads the speciality nor scopes to the caller — it is scoped to nobody`);
+      continue;
+    }
+    checked++;
+    assert.match(body, /visibleTo\(s, req\.builder\)/,
+      `${m[1].toUpperCase()} ${m[2]} reads a speciality by id without asking whether the caller may see it`);
+  }
+  // Not vacuous: if a refactor stopped every route reading the row, the loop above
+  // would pass by skipping everything.
+  assert.ok(checked >= 5, `expected several row-reading routes to be checked, saw ${checked}`);
+});
+
+test('the DB refuses a private speciality being offered', () => {
+  const sql = src('modules/specialities/migrations/specialities_002_offered.sql');
+  assert.match(sql, /CHECK \(offered = FALSE OR visibility <> 'private'\)/);
+});
+
+test('nothing in the offer path adopts', () => {
+  // The guarantee stated at the top of this file, asserted against the source so
+  // a future convenience cannot quietly add it.
+  const routes = src('modules/specialities/routes/specialities.js');
+  const at = routes.indexOf("router.get('/specialities/offered'");
+  const handler = routes.slice(at, routes.indexOf('}));', at));
+  assert.doesNotMatch(handler, /db\.adopt\(/, 'the suggestions read must never adopt');
+});

package/tests/stale_worktrees.mjs

@@ -2,6 +2,7 @@
 // facts (task 1003365): no repo, no API, just the porcelain text + two predicates.
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
 import { parseWorktreeList, classifyWorktrees, classifyHusks, lineFor } from '../scripts/gds/stale-worktrees.js';
 
 const PORCELAIN = [
@@ -120,3 +121,56 @@ test('--line reports both leaks in one line when both exist', () => {
   assert.match(line, /Stale worktrees: 1 /);
   assert.match(line, /Worktree husks: 1 /);
 });
+
+// ---- task 1003912: an UNSTARTED claim worktree is live, not stale ----------
+//
+// `worktree.js add` branches off origin/main and commits nothing, so until the
+// builder's first commit the branch IS origin/main — and therefore trivially an
+// ancestor of it. The classifier called that "merged into main", and
+// /worktree-clean removes every name on the stale list, so a cleanup run inside
+// that window would take a live claim's tree. Observed live 2026-09-13 (task
+// 1002594). `worktree.js remove` refusing a DIRTY tree does not cover this: a
+// worktree with no commits yet is precisely the one that is still clean.
+
+const MAIN_WT = { path: 'C:/repo', branch: 'main', isMain: true };
+const CLAIM_WT = { path: 'C:/repo/.claude/worktrees/task-1002594', branch: 'task-1002594', isMain: false };
+
+test('a branch sitting exactly at origin/main is LIVE, not stale (task 1003912)', () => {
+  const r = classifyWorktrees([MAIN_WT, CLAIM_WT], {
+    branchExists: () => true,
+    isMerged: () => true,        // it genuinely IS an ancestor — that is the trap
+    isUnstarted: (b) => b === 'task-1002594',
+  });
+  assert.deepEqual(r.stale, [], 'a claim worktree with no commits must never be offered for deletion');
+  assert.equal(r.live.length, 1);
+  assert.match(r.live[0].why, /unstarted/, 'and the report should say why it is being spared');
+});
+
+test('unstarted is checked BEFORE merged — every unstarted branch is also "merged"', () => {
+  // If the order flipped the guard would be unreachable, and every other case here
+  // would still be green.
+  const r = classifyWorktrees([MAIN_WT, CLAIM_WT], {
+    branchExists: () => true, isMerged: () => true, isUnstarted: () => true,
+  });
+  assert.equal(r.stale.length, 0);
+});
+
+test('a branch that really did land is still stale — the guard narrows nothing else', () => {
+  const r = classifyWorktrees([MAIN_WT, CLAIM_WT], {
+    branchExists: () => true, isMerged: () => true, isUnstarted: () => false,
+  });
+  assert.equal(r.stale.length, 1, 'work that landed must still be cleaned up');
+  assert.equal(r.stale[0].why, 'merged into main');
+});
+
+test('a caller supplying no isUnstarted still classifies (older callers keep working)', () => {
+  const r = classifyWorktrees([MAIN_WT, CLAIM_WT], { branchExists: () => true, isMerged: () => true });
+  assert.equal(r.stale.length, 1);
+});
+
+test('SKILL.md no longer promises the current claim is safe by construction (task 1003912)', () => {
+  const md = readFileSync(new URL('../.claude/skills/worktree-clean/SKILL.md', import.meta.url), 'utf8');
+  assert.ok(!/never stale by construction/.test(md),
+    'that sentence is what would stop an agent double-checking a live claim it was about to delete');
+  assert.match(md, /ask before removing it/, 'and it must say what to do instead');
+});