@bongos/core 1.21.106 → 1.21.108

package/modules/lifecycle/routes/project-settings.js

@@ -31,6 +31,7 @@
 const express = require('express');
 const api = require('../../../src/module-api');
 const goalCategory = require('../goal-category');
+const autopickup = require('../autopickup');
 
 const log = api.logger('lifecycle');
 
@@ -380,6 +381,64 @@ module.exports = function buildProjectSettingsRouter() {
     }
   });
 
+  // --- tweak auto-pickup (task 1004677, ADR 0371 D3/D5) ----------------------
+  //
+  // GET /project-settings/tweak-autopickup — the switch, the monthly cap, and how
+  // many rounds the lane has picked up this calendar month (counted from marked
+  // claims, never a stored counter).
+  //
+  // rank: any signed-in builder. The runner reads it before it tries a round, and
+  // the studio shows the count; it carries no reward internals or file paths.
+  async function autopickupBody() {
+    const resolved = await api.projectSettings.resolveTweakAutopickup();
+    const used = await autopickup.countThisMonth();
+    return {
+      mode: resolved.mode,
+      cap: resolved.cap,
+      used_this_month: used,
+      remaining_this_month: Math.max(0, resolved.cap - used),
+      per_round_limit: autopickup.MAX_AUTO_APPLIES_PER_ROUND,
+      source: resolved.source,
+      invalid: resolved.invalid,
+      sentence: api.projectSettings.describeTweakAutopickup(resolved),
+    };
+  }
+
+  router.get('/project-settings/tweak-autopickup', api.requireBuilder, async (req, res) => {
+    try {
+      res.set('Cache-Control', 'no-store');
+      res.json(await autopickupBody());
+    } catch (err) {
+      log.error(`GET /project-settings/tweak-autopickup: ${err && err.message}`);
+      res.fail('project_settings_read_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
+  // PATCH /project-settings/tweak-autopickup — body { mode?: 'off' | 'on', cap?: n }.
+  //
+  // rank: project.settings.manage (metic+, government_010), the same atom as the
+  // other writes on this page. Each field is validated by the resolver's own parser,
+  // and both are checked before either is written, so a half-valid body writes nothing.
+  router.patch('/project-settings/tweak-autopickup', api.requireBuilder, api.requirePermission('project.settings.manage'), api.requireActAlone('rules'), async (req, res) => {
+    if (api.validateOrRespond(req, res, { mode: { type: 'string' }, cap: { type: 'number' } })) return;
+    const body = req.body || {};
+    if (body.mode == null && body.cap == null) {
+      return res.fail('bad_tweak_autopickup', { status: 400, message: 'send mode, cap, or both' });
+    }
+    const mode = body.mode == null ? null : api.projectSettings.parseAutopickup(body.mode);
+    if (mode && !mode.mode) return res.fail('bad_tweak_autopickup', { status: 400, message: `mode: ${mode.reason}` });
+    const cap = body.cap == null ? null : api.projectSettings.parseAutopickupCap(body.cap);
+    if (cap && cap.cap == null) return res.fail('bad_tweak_autopickup', { status: 400, message: `cap: ${cap.reason}` });
+    try {
+      if (mode) await api.projectSettings.set(api.projectSettings.KEYS.TWEAK_AUTOPICKUP, mode.mode, req.builder.id);
+      if (cap) await api.projectSettings.set(api.projectSettings.KEYS.TWEAK_AUTOPICKUP_CAP, cap.cap, req.builder.id);
+      res.json({ ok: true, ...(await autopickupBody()) });
+    } catch (err) {
+      log.error(`PATCH /project-settings/tweak-autopickup: ${err && err.message}`);
+      res.fail('project_settings_write_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
   return router;
 };
 

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.106",
+  "version": "1.21.108",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.21.106",
+      "version": "1.21.108",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.106",
+  "version": "1.21.108",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -9482,5 +9482,21 @@
       "id": "1004683",
       "text": "After pressing Create, a founder now sees \"Getting <name> ready\" with a plain count (\"4 of 6 done\", or \"ready\" with a tick) and one sentence saying what is happening and whether it is their turn. Below it are two short lists,"
     }
+  ],
+  "1.21.107": [
+    {
+      "id": "1004677",
+      "text": "A project now has a switch for letting a runner pick up submitted page tweaks on its own, off by default, with a monthly limit of 20 rounds. The server enforces the limit when the work is claimed, so two runners can never both"
+    }
+  ],
+  "1.21.108": [
+    {
+      "id": "1004668",
+      "text": "Adding new tasks to a goal that already has work in it no longer sets off a false alarm saying the tasks were filed in the wrong place. The planning guides also stop telling people that new tasks wait for an owner's go-ahead:"
+    },
+    {
+      "id": "1004696",
+      "text": "Artists can now recommend removing a line while editing a page's words: mark it with \"Remove this line\" or just delete its words, see it crossed out, keep it after all, and send it with their rewrites. Each removal goes to an"
+    }
   ]
 }

package/scripts/gds/government-walk.js

@@ -70,6 +70,7 @@ const BAD = 'x';
 const REQUESTS = Object.freeze({
   'PATCH /project-settings/rot-days': ['PATCH', '/project-settings/rot-days', { days: 'soon' }],
   'PATCH /project-settings/ship-mode': ['PATCH', '/project-settings/ship-mode', { mode: 'sometimes' }],
+  'PATCH /project-settings/tweak-autopickup': ['PATCH', '/project-settings/tweak-autopickup', { mode: 'sometimes' }],
   'PATCH /work-categories/:id': ['PATCH', `/work-categories/${BAD}`, {}],
   'POST /security/reports/:id/confirm': ['POST', `/security/reports/${BAD}/confirm`, {}],
   'POST /security/reports/:id/dispute': ['POST', `/security/reports/${BAD}/dispute`, {}],

package/scripts/gds/run-unit-tests.js

@@ -121,6 +121,9 @@ const INTEGRATION = new Set([
   // index actually refuses the commingling INSERT and still allows the parallel
   // -worktree case. It self-skips without a DB, and refuses any database that
   // has a `builders` table, since it TRUNCATEs claims.
+  // task 1004677: two marked auto-pickup claims racing for the last slot of the
+  // monthly cap; only real connections prove the advisory lock. Scratch DB only.
+  'autopickup_cap_db',
   'claims_requested_worktree_db',
   'clawback_confirmed_backlog',
   // task 1003113: the copy_desk_flags schema half. The module's own tests are

package/scripts/gds/seed-bv2-ideator-surface-tasks.js

@@ -13,7 +13,7 @@
 //
 // Run: node scripts/gds/seed-bv2-ideator-surface-tasks.js
 const os = require('os');
-const { expectedCriterionCounts, verifySeedCriteriaLinks } = require('./seed-verify-criteria');
+const { baselineSeedCriteria, expectedCriterionCounts, verifySeedCriteriaLinks } = require('./seed-verify-criteria');
 const sess = require(os.homedir() + '/.config/cloudbongos/gds-session.json');
 const BASE = sess.api_base.replace(/\/$/, '');
 const TOKEN = sess.token;
@@ -328,24 +328,11 @@ async function main() {
   const ids = {};
   const criterionIdListsPerTask = [];
 
-  // BASELINE. verifySeedCriteriaLinks unions the plan's slugs with EVERY criterion
-  // the goal carries, so a criterion this seed does not touch is compared against an
-  // expected zero. Goal 1000095 already held six criteria with live task links before
-  // this seed existed, so an unbaselined check would report six false mismatches and
-  // exit(1) on a correct run. Snapshot the untouched criteria's real counts HERE,
-  // before anything is written, and fold them into the plan — the check then still
-  // catches any drift on the four this seed owns, which is what it is for.
-  const OURS = new Set(Object.values(CRIT));
-  const baseline = {};
-  const pre = await api('GET', `/goals/${GOAL}`);
-  if (!pre.ok || !pre.json || !Array.isArray(pre.json.criteria)) {
-    console.error(`Could not read goal ${GOAL} to baseline its existing criteria (status ${pre.status}). Refusing to seed blind.`);
-    process.exit(1);
-  }
-  for (const row of pre.json.criteria) {
-    if (!OURS.has(row.criterion_id)) baseline[row.criterion_id] = Number(row.linked_tasks) || 0;
-  }
-  console.log(`Baselined ${Object.keys(baseline).length} pre-existing criteria on goal ${GOAL}.`);
+  // BASELINE, before anything is written. Goal 1000095 already held six criteria
+  // with live task links before this seed existed; verifying against the pre-seed
+  // snapshot plus the plan keeps those from reading as false mismatches while still
+  // catching any drift (task 1004668 moved this into seed-verify-criteria.js).
+  const baseline = await baselineSeedCriteria({ goalId: GOAL, fetchGoal: (gid) => api('GET', `/goals/${gid}`) });
 
   console.log(`Seeding ${TASKS.length} tasks into goal ${GOAL} (${VER})…\n`);
 
@@ -370,7 +357,10 @@ async function main() {
       continue;
     }
     ids[t.ref] = r.json.task.id;
-    criterionIdListsPerTask.push(t.crit);
+    // Count only links THIS run created. A re-run replays an existing task
+    // (`idempotent: true`) whose links the baseline already holds; counting it
+    // again would expect them twice (task 1004668).
+    if (!r.json.idempotent) criterionIdListsPerTask.push(t.crit);
     console.log(`  ${t.ref} → ${r.json.task.id}  ${title.slice(0, 74)}`);
   }
 
@@ -391,7 +381,8 @@ async function main() {
   console.log('');
   await verifySeedCriteriaLinks({
     goalId: GOAL,
-    expectedCounts: { ...baseline, ...expectedCriterionCounts(criterionIdListsPerTask) },
+    expectedCounts: expectedCriterionCounts(criterionIdListsPerTask),
+    baseline,
     fetchGoal: (gid) => api('GET', `/goals/${gid}`),
   });
 }

package/scripts/gds/seed-verify-criteria.js

@@ -12,21 +12,48 @@
 // (some use cli-lib's apiCall, others a local throttled fetch — see the
 // scripts/gds/CLAUDE.md roster), so this takes a `fetchGoal(goalId)` callback
 // rather than assuming a client shape.
+//
+// WHY A BASELINE (task 1004668). A seed into a goal that already carries linked
+// work used to cry wolf: every criterion the seed did not touch was compared
+// against an expected count of zero, so goal 1000095 (six criteria already linked)
+// would have reported six false mismatches and exit(1) on a correct run — and a
+// check that fails correct runs trains the next builder to ignore it. A seed now
+// snapshots the goal's counts BEFORE its first write (baselineSeedCriteria) and
+// verifies `baseline + plan`, which still catches a stray link on a criterion the
+// seed was never meant to touch. Without a baseline only the plan's own criteria
+// are checked; nothing else is assumed to be zero.
+//
+// With a baseline, the plan is the links THIS RUN CREATED, not every task the seed
+// names. A seed is resumable (POST /tasks is idempotent on source_ref and replays
+// an existing task with `idempotent: true`), and a replayed task's links are
+// already inside the baseline — tally it again and a correct re-run expects them
+// twice. So a baselined seed skips replays when it tallies (see
+// seed-bv2-ideator-surface-tasks.js).
+
+// countsByCriterion — { criterion_id: linked_tasks } from GET /goals/:id rows.
+function countsByCriterion(criteriaRows) {
+  const counts = {};
+  for (const row of criteriaRows || []) counts[row.criterion_id] = Number(row.linked_tasks) || 0;
+  return counts;
+}
 
 // diffCriterionLinks — pure comparison: expected (slug -> count, tallied from
 // the criterion_ids actually POSTed) vs actual (the `criteria` rows
 // GET /goals/:id returns, each carrying criterion_id + linked_tasks). Returns
-// every mismatching slug, including one present on only one side.
-function diffCriterionLinks(expectedCounts, criteriaRows) {
-  const actual = {};
-  for (const row of criteriaRows || []) {
-    actual[row.criterion_id] = Number(row.linked_tasks) || 0;
-  }
-
-  const slugs = new Set([...Object.keys(expectedCounts || {}), ...Object.keys(actual)]);
+// every mismatching slug.
+//
+// With `baseline` (the pre-seed snapshot) every criterion on the goal is checked
+// against baseline + plan — a criterion created after the snapshot starts at 0.
+// Without it, only the plan's own criteria are checked: a criterion the seed
+// does not cite has an unknown prior count, and guessing zero is the false alarm.
+function diffCriterionLinks(expectedCounts, criteriaRows, { baseline = null } = {}) {
+  const actual = countsByCriterion(criteriaRows);
+  const plan = expectedCounts || {};
+  const slugs = new Set(Object.keys(plan));
+  if (baseline) for (const slug of [...Object.keys(baseline), ...Object.keys(actual)]) slugs.add(slug);
   const mismatches = [];
   for (const slug of slugs) {
-    const expected = (expectedCounts && expectedCounts[slug]) || 0;
+    const expected = ((baseline && baseline[slug]) || 0) + (plan[slug] || 0);
     const got = actual[slug] || 0;
     if (expected !== got) mismatches.push({ criterion_id: slug, expected, actual: got });
   }
@@ -45,25 +72,53 @@ function expectedCriterionCounts(criterionIdListsPerTask) {
   return counts;
 }
 
+function readCriteria(r) {
+  const body = (r && (r.json || r.data)) || null;
+  return r && r.ok && body && Array.isArray(body.criteria) ? body.criteria : null;
+}
+
+// baselineSeedCriteria — call BEFORE the seed's first write. Returns the goal's
+// current { criterion_id: linked_tasks } snapshot to hand to
+// verifySeedCriteriaLinks, or exit(1)s: a seed that cannot read the goal it is
+// about to write into must not seed blind.
+async function baselineSeedCriteria({ goalId, fetchGoal, log = console.log, exit = process.exit }) {
+  const r = await fetchGoal(goalId);
+  const criteria = readCriteria(r);
+  if (!criteria) {
+    log(`BASELINE FAILED: GET goal ${goalId} did not return a criteria list (status ${r && r.status}). Refusing to seed blind.`);
+    return exit(1);
+  }
+  const baseline = countsByCriterion(criteria);
+  const linked = Object.values(baseline).filter((n) => n > 0).length;
+  log(`Baselined goal ${goalId}: ${criteria.length} criteria, ${linked} already carrying linked tasks.`);
+  return baseline;
+}
+
 // verifySeedCriteriaLinks — Phase-5 self-check: fetch the goal, diff its
-// linked_tasks against the plan, and exit(1) loudly on any mismatch (a zero
-// where tasks were expected is the shape that shipped silently in the
-// RETRO2 incident, but any drift is worth stopping the seed for).
-async function verifySeedCriteriaLinks({ goalId, expectedCounts, fetchGoal, log = console.log, exit = process.exit }) {
+// linked_tasks against the plan (plus the pre-seed `baseline` when given), and
+// exit(1) loudly on any mismatch (a zero where tasks were expected is the shape
+// that shipped silently in the RETRO2 incident, but any drift is worth stopping
+// the seed for).
+async function verifySeedCriteriaLinks({ goalId, expectedCounts, baseline = null, fetchGoal, log = console.log, exit = process.exit }) {
   const r = await fetchGoal(goalId);
-  const body = (r && (r.json || r.data)) || null;
-  if (!r || !r.ok || !body || !Array.isArray(body.criteria)) {
+  const criteria = readCriteria(r);
+  if (!criteria) {
     log(`VERIFY FAILED: GET goal ${goalId} did not return a criteria list (status ${r && r.status}). Cannot confirm criterion links landed.`);
     return exit(1);
   }
-  const mismatches = diffCriterionLinks(expectedCounts, body.criteria);
+  const mismatches = diffCriterionLinks(expectedCounts, criteria, { baseline });
   if (mismatches.length) {
     log(`VERIFY FAILED: criterion links on goal ${goalId} do not match the plan (${mismatches.length} mismatch${mismatches.length === 1 ? '' : 'es'}):`);
     for (const m of mismatches) log(`  ${m.criterion_id}: expected ${m.expected} linked task(s), got ${m.actual}`);
     log('Likely cause: a criterion_ids mapping bug (e.g. a positional "Cn" token resolved against the wrong scope — learning 1000188). Fix and re-run before trusting this seed.');
     return exit(1);
   }
-  log(`VERIFY OK: all ${Object.keys(expectedCounts || {}).length} criteria on goal ${goalId} carry their planned task count.`);
+  if (baseline) {
+    log(`VERIFY OK: all ${criteria.length} criteria on goal ${goalId} carry their pre-seed count plus the planned links.`);
+  } else {
+    log(`VERIFY OK: all ${Object.keys(expectedCounts || {}).length} planned criteria on goal ${goalId} carry their planned task count.`);
+    log('  (No baseline was taken, so criteria this seed does not cite were not checked — pass baselineSeedCriteria() output as `baseline` to cover them.)');
+  }
 }
 
-module.exports = { diffCriterionLinks, expectedCriterionCounts, verifySeedCriteriaLinks };
+module.exports = { diffCriterionLinks, expectedCriterionCounts, baselineSeedCriteria, verifySeedCriteriaLinks };

package/src/bongos/project-settings.js

@@ -50,6 +50,8 @@ const SETTING_KEYS = {
   ROT_DAYS: 'attention.rot_days',
   FOCUS_VERSION: 'roadmap.focus_version',
   SHIP_MODE: 'ship.mode',
+  TWEAK_AUTOPICKUP: 'tweak.autopickup',
+  TWEAK_AUTOPICKUP_CAP: 'tweak.autopickup_monthly_cap',
 };
 
 // SHIP MODE (task 1004628, ADR 0369) — WHO starts a ship, never HOW it lands.
@@ -278,6 +280,75 @@ function describeShipMode(resolved) {
   return `${what}${how}`;
 }
 
+
+// TWEAK AUTO-PICKUP (task 1004677, ADR 0371 D3/D5). Whether the Autobongos runner's
+// tweak lane may pick up a submitted page round on its own, and how many rounds it
+// may pick up per calendar month. Off by default: a project that never turns it on
+// keeps today's queue exactly. The cap is ENFORCED by the server at claim time
+// (modules/lifecycle/autopickup.js); this file only resolves the numbers.
+const AUTOPICKUP_MODES = Object.freeze(['off', 'on']);
+const DEFAULT_AUTOPICKUP = 'off';
+// 20 rounds: a grade costs the project a few dollars, so 20 is a bounded, legible
+// monthly spend at about the level of one active artist (ADR 0371 D5).
+const DEFAULT_AUTOPICKUP_CAP = 20;
+// Past 1000 the cap is an off switch typed as a big number; that should be asked
+// for out loud, the same reasoning as MAX_ROT_DAYS.
+const MAX_AUTOPICKUP_CAP = 1000;
+
+function parseAutopickup(raw) {
+  if (raw == null || String(raw).trim() === '') return { reason: 'empty' };
+  const v = String(raw).trim().toLowerCase();
+  if (!AUTOPICKUP_MODES.includes(v)) return { reason: `must be one of ${AUTOPICKUP_MODES.join(' | ')}` };
+  return { mode: v };
+}
+
+function parseAutopickupCap(raw) {
+  if (raw == null || raw === '') return { reason: 'empty' };
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return { reason: 'not a number' };
+  if (!Number.isInteger(n)) return { reason: 'must be a whole number of rounds' };
+  if (n <= 0) return { reason: 'must be positive' };
+  if (n > MAX_AUTOPICKUP_CAP) return { reason: `out of range (1..${MAX_AUTOPICKUP_CAP})` };
+  return { cap: n };
+}
+
+// One knob through its parser: { value, source, invalid }. Never throws; an
+// unreadable database answers the default, the resolveShipMode posture.
+async function resolveOne(key, parse, pick, fallback) {
+  let row = null;
+  try {
+    row = await getSetting(key);
+  } catch (err) {
+    logger.error(`project_settings read failed; falling back to the default ${key}: ${err && err.message}`);
+    return { value: fallback, source: 'default', invalid: null };
+  }
+  if (row && row.value != null && row.value !== '') {
+    const got = parse(row.value);
+    if (pick(got) != null) return { value: pick(got), source: 'project_settings', invalid: null };
+    return { value: fallback, source: 'default', invalid: { where: `project_settings['${key}']`, raw: String(row.value), reason: got.reason } };
+  }
+  return { value: fallback, source: 'default', invalid: null };
+}
+
+// resolveTweakAutopickup() — { mode, cap, source: { mode, cap }, invalid: [...] }.
+// mode is always 'off' or 'on', cap always a usable positive integer.
+async function resolveTweakAutopickup() {
+  const m = await resolveOne(SETTING_KEYS.TWEAK_AUTOPICKUP, parseAutopickup, (g) => g.mode, DEFAULT_AUTOPICKUP);
+  const c = await resolveOne(SETTING_KEYS.TWEAK_AUTOPICKUP_CAP, parseAutopickupCap, (g) => g.cap, DEFAULT_AUTOPICKUP_CAP);
+  return {
+    mode: m.value,
+    cap: c.value,
+    source: { mode: m.source, cap: c.source },
+    invalid: [m.invalid, c.invalid].filter(Boolean),
+  };
+}
+
+function describeTweakAutopickup(resolved) {
+  const r = resolved || {};
+  if (r.mode !== 'on') return 'Off: a submitted page waits until a person runs /tweak for it.';
+  return `On: a running Autobongos runner applies submitted pages on its own, up to ${r.cap} a month. The artist still approves every one.`;
+}
+
 // parseDays is exported for the tests only — the range check and the default are
 // asserted against the SAME constants the resolver reads, because a test that
 // re-typed 30 or 365 would be the second copy of the number this file exists to
@@ -299,4 +370,12 @@ module.exports = {
   parseShipMode,
   resolveShipMode,
   describeShipMode,
+  AUTOPICKUP_MODES,
+  DEFAULT_AUTOPICKUP,
+  DEFAULT_AUTOPICKUP_CAP,
+  MAX_AUTOPICKUP_CAP,
+  parseAutopickup,
+  parseAutopickupCap,
+  resolveTweakAutopickup,
+  describeTweakAutopickup,
 };

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.106'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.108'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');
@@ -474,6 +474,13 @@ module.exports = {
     get parseShipMode() { return require('./bongos/project-settings').parseShipMode; },
     get resolveShipMode() { return require('./bongos/project-settings').resolveShipMode; },
     get describeShipMode() { return require('./bongos/project-settings').describeShipMode; },
+    // Tweak auto-pickup (task 1004677, ADR 0371 D3/D5): the switch and the monthly cap.
+    get AUTOPICKUP_MODES() { return require('./bongos/project-settings').AUTOPICKUP_MODES; },
+    get MAX_AUTOPICKUP_CAP() { return require('./bongos/project-settings').MAX_AUTOPICKUP_CAP; },
+    get parseAutopickup() { return require('./bongos/project-settings').parseAutopickup; },
+    get parseAutopickupCap() { return require('./bongos/project-settings').parseAutopickupCap; },
+    get resolveTweakAutopickup() { return require('./bongos/project-settings').resolveTweakAutopickup; },
+    get describeTweakAutopickup() { return require('./bongos/project-settings').describeTweakAutopickup; },
   },
   readConfigFileSync: instanceConfig.readConfigFileSync,
   configHome: instanceConfig.configHome,