@bongos/core 1.21.106 → 1.21.108

package/tests/autopickup_cap.mjs

@@ -0,0 +1,236 @@
+// tests/autopickup_cap.mjs — tweak auto-pickup's setting, monthly cap and claim mark
+// (task 1004677 / BV2.TW19a, ADR 0371 D3, D5, D6).
+//
+// Pinned here (DB-free; the race lives in tests/autopickup_cap_db.mjs):
+//   1. the two parsers and the resolver: off by default, cap 20 by default, an
+//      unusable stored value reported and never thrown, a dead DB answers defaults;
+//   2. the refusal ladder: not a tweak, switch off, round limit, monthly cap, and the
+//      lock is taken BEFORE either count;
+//   3. claimTask: a marked claim runs the gate before the insert and names the
+//      column; an unmarked claim's insert is unchanged;
+//   4. the routes: any builder reads (with this month's count), only
+//      project.settings.manage writes, and a half-valid body writes nothing.
+//
+// Run:  node --test tests/autopickup_cap.mjs
+import { strict as assert } from 'node:assert';
+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 poolMod = require(path.join(ROOT, 'src', 'bongos', 'pool.js'));
+const {
+  DEFAULT_AUTOPICKUP, DEFAULT_AUTOPICKUP_CAP, parseAutopickup, parseAutopickupCap,
+  resolveTweakAutopickup, describeTweakAutopickup, SETTING_KEYS, AUTOPICKUP_MODES, MAX_AUTOPICKUP_CAP,
+} = require('../src/bongos/project-settings.js');
+const { autoPickupRefusal, LOCK_KEY, MAX_AUTO_APPLIES_PER_ROUND } = require('../modules/lifecycle/autopickup.js');
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+
+async function withPool(query, fn) {
+  const pool = poolMod.pool;
+  const saved = pool.query;
+  pool.query = query;
+  try { return await fn(); } finally { pool.query = saved; }
+}
+const settingsRows = (map) => async (_sql, [key]) => ({ rows: key in map ? [{ key, value: map[key] }] : [] });
+
+// ---- 1. the setting ---------------------------------------------------------
+
+test('the parsers accept exactly off|on and a whole positive cap', () => {
+  assert.deepEqual([...AUTOPICKUP_MODES], ['off', 'on']);
+  assert.equal(api.projectSettings.MAX_AUTOPICKUP_CAP, MAX_AUTOPICKUP_CAP, 'the doorway hands out the same bound');
+  assert.deepEqual(parseAutopickup(' On '), { mode: 'on' });
+  assert.match(parseAutopickup('maybe').reason, /off \| on/);
+  assert.deepEqual(parseAutopickupCap('5'), { cap: 5 });
+  assert.match(parseAutopickupCap('0').reason, /positive/);
+  assert.match(parseAutopickupCap('2.5').reason, /whole/);
+  assert.match(parseAutopickupCap('100000').reason, /out of range/);
+});
+
+test('an untouched project is off with a cap of 20', async () => {
+  assert.equal(DEFAULT_AUTOPICKUP, 'off');
+  assert.equal(DEFAULT_AUTOPICKUP_CAP, 20);
+  const r = await withPool(settingsRows({}), () => resolveTweakAutopickup());
+  assert.deepEqual(r, { mode: 'off', cap: 20, source: { mode: 'default', cap: 'default' }, invalid: [] });
+  assert.match(describeTweakAutopickup(r), /waits until a person/);
+});
+
+test('stored values are read; an unusable one is reported and falls back', async () => {
+  const r = await withPool(settingsRows({ [SETTING_KEYS.TWEAK_AUTOPICKUP]: 'on', [SETTING_KEYS.TWEAK_AUTOPICKUP_CAP]: 'lots' }),
+    () => resolveTweakAutopickup());
+  assert.equal(r.mode, 'on');
+  assert.equal(r.source.mode, 'project_settings');
+  assert.equal(r.cap, 20);
+  assert.equal(r.invalid.length, 1);
+  assert.equal(r.invalid[0].raw, 'lots');
+  assert.match(describeTweakAutopickup({ mode: 'on', cap: 7 }), /up to 7 a month/);
+});
+
+test('a database that cannot be read answers the defaults', async () => {
+  const r = await withPool(async () => { throw new Error('db down'); }, () => resolveTweakAutopickup());
+  assert.equal(r.mode, 'off');
+  assert.equal(r.cap, 20);
+});
+
+// ---- 2. the refusal ladder --------------------------------------------------
+
+function fakeClient({ round = 0, month = 0 } = {}) {
+  const calls = [];
+  return {
+    calls,
+    async query(sql, params) {
+      calls.push(sql.includes('pg_advisory_xact_lock') ? `lock:${params[0]}` : sql.includes('date_trunc') ? 'month' : 'round');
+      if (sql.includes('pg_advisory_xact_lock')) return { rows: [] };
+      return { rows: [{ n: sql.includes('date_trunc') ? month : round }] };
+    },
+  };
+}
+const tweak = { id: 9, source: 'page-tweak' };
+const on = { mode: 'on', cap: 3 };
+
+test('a marked claim on anything but a page tweak is refused, before any lock', async () => {
+  const c = fakeClient();
+  assert.equal((await autoPickupRefusal(c, { id: 9, source: 'manual' }, on)).code, 'AUTO_PICKUP_NOT_A_TWEAK');
+  assert.deepEqual(c.calls, []);
+});
+
+test('the switch off refuses a marked claim', async () => {
+  assert.equal((await autoPickupRefusal(fakeClient(), tweak, { mode: 'off', cap: 3 })).code, 'AUTO_PICKUP_OFF');
+});
+
+test('the lock is taken before either count, on the one project-wide key', async () => {
+  const c = fakeClient();
+  assert.equal(await autoPickupRefusal(c, tweak, on), null);
+  assert.equal(LOCK_KEY, 'page-tweak/autopickup');
+  assert.deepEqual(c.calls, ['lock:page-tweak/autopickup', 'round', 'month']);
+});
+
+test('a third automatic apply of one round is refused', async () => {
+  assert.equal(MAX_AUTO_APPLIES_PER_ROUND, 2);
+  assert.equal(await autoPickupRefusal(fakeClient({ round: 1 }), tweak, on), null);
+  const r = await autoPickupRefusal(fakeClient({ round: 2 }), tweak, on);
+  assert.equal(r.code, 'AUTO_PICKUP_ROUND_LIMIT');
+  assert.match(r.message, /waits for a person/);
+});
+
+test('the monthly cap refuses at the cap and admits below it', async () => {
+  assert.equal(await autoPickupRefusal(fakeClient({ month: 2 }), tweak, on), null);
+  const r = await autoPickupRefusal(fakeClient({ month: 3 }), tweak, on);
+  assert.equal(r.code, 'AUTO_PICKUP_CAP_REACHED');
+  assert.equal(r.cap, 3);
+});
+
+// ---- 3. claimTask wiring ----------------------------------------------------
+
+test('claimTask runs the gate before the insert, and names the column only on a marked claim', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'lifecycle', 'db-claims.js'), 'utf8');
+  const body = src.slice(src.indexOf('async function claimTask('), src.indexOf('async function claimTasksBatch'));
+  const gate = body.indexOf('autoPickupRefusal(client, task, autoPickupSettings)');
+  const insert = body.indexOf('INSERT INTO claims');
+  assert.ok(gate > 0 && insert > gate, 'the gate runs inside the transaction, before the insert');
+  assert.match(body.slice(gate, insert), /if \(refusal\) throw refusal;/, 'a refusal stops the claim');
+  assert.match(body, /\$\{autoPickup \? ', auto_pickup' : ''\}/);
+  assert.match(body, /goal_id, source FROM tasks WHERE id = \$1 FOR UPDATE/, 'the task row carries its source');
+});
+
+test('POST /claims accepts auto_pickup and maps every refusal to a 409', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'lifecycle', 'routes', 'claims.js'), 'utf8');
+  assert.match(src, /auto_pickup: \{ type: 'boolean' \}/);
+  assert.match(src, /autoPickup: autoPickup === true/);
+  for (const code of ['AUTO_PICKUP_NOT_A_TWEAK', 'AUTO_PICKUP_OFF', 'AUTO_PICKUP_CAP_REACHED', 'AUTO_PICKUP_ROUND_LIMIT']) {
+    assert.match(src, new RegExp(`err.code === '${code}' \\? 409`));
+  }
+});
+
+// ---- 4. the routes ----------------------------------------------------------
+
+const fakeRes = () => ({
+  code: null, statusCode: 200, payload: null, headers: {},
+  fail(code, opts) { this.code = code; this.statusCode = opts?.status ?? 400; this.payload = { error: code, ...(opts || {}) }; return this; },
+  status(c) { this.statusCode = c; return this; },
+  set(k, v) { this.headers[k] = v; return this; },
+  json(p) { this.payload = p; return this; },
+});
+
+function buildRouter({ used = 4 } = {}) {
+  const ps = api.projectSettings;
+  const saved = { resolve: ps.resolveTweakAutopickup, set: ps.set };
+  const writes = [];
+  const state = { mode: 'off', cap: 20 };
+  ps.resolveTweakAutopickup = async () => ({ ...state, source: { mode: 'default', cap: 'default' }, invalid: [] });
+  ps.set = async (key, value, by) => {
+    writes.push({ key, value, by });
+    if (key === 'tweak.autopickup') state.mode = value; else state.cap = value;
+  };
+  const autopickup = require('../modules/lifecycle/autopickup.js');
+  const savedCount = autopickup.countThisMonth;
+  autopickup.countThisMonth = async () => used;
+  const file = path.join(ROOT, 'modules', 'lifecycle', 'routes', 'project-settings.js');
+  delete require.cache[require.resolve(file)];
+  const router = require(file)();
+  const route = (method, p) => router.stack.find((l) => l.route && l.route.path === p && l.route.methods[method]).route;
+  const restore = () => { ps.resolveTweakAutopickup = saved.resolve; ps.set = saved.set; autopickup.countThisMonth = savedCount; };
+  return { route, writes, restore };
+}
+const handler = (r) => r.stack[r.stack.length - 1].handle;
+
+test('the read is open to any builder and reports this month\'s count against the cap', async () => {
+  const { route, restore } = buildRouter({ used: 4 });
+  try {
+    const get = route('get', '/project-settings/tweak-autopickup');
+    assert.equal(get.stack.length, 2, 'requireBuilder + the handler');
+    const res = fakeRes();
+    await handler(get)({}, res);
+    assert.equal(res.payload.mode, 'off');
+    assert.equal(res.payload.used_this_month, 4);
+    assert.equal(res.payload.remaining_this_month, 16);
+    assert.equal(res.payload.per_round_limit, 2);
+    assert.equal(res.headers['Cache-Control'], 'no-store');
+  } finally { restore(); }
+});
+
+test('the write is gated on project.settings.manage and the Rules decision rule', () => {
+  const { route, restore } = buildRouter();
+  try {
+    const write = route('patch', '/project-settings/tweak-autopickup').stack;
+    assert.equal(write.length, 4);
+    assert.equal(write[2].handle.name, 'actAloneGate');
+    const src = fs.readFileSync(path.join(ROOT, 'modules', 'lifecycle', 'routes', 'project-settings.js'), 'utf8');
+    assert.match(src, /router\.patch\('\/project-settings\/tweak-autopickup', api\.requireBuilder, api\.requirePermission\('project\.settings\.manage'\)/);
+  } finally { restore(); }
+});
+
+test('a half-valid body writes nothing; a good one writes both and echoes the new read', async () => {
+  const { route, writes, restore } = buildRouter({ used: 0 });
+  try {
+    const patch = handler(route('patch', '/project-settings/tweak-autopickup'));
+    const bad = fakeRes();
+    await patch({ body: { mode: 'on', cap: 0 }, builder: { id: 7 } }, bad);
+    assert.equal(bad.code, 'bad_tweak_autopickup');
+    assert.equal(writes.length, 0);
+
+    const empty = fakeRes();
+    await patch({ body: {}, builder: { id: 7 } }, empty);
+    assert.equal(empty.code, 'bad_tweak_autopickup');
+
+    const good = fakeRes();
+    await patch({ body: { mode: 'ON', cap: 5 }, builder: { id: 7 } }, good);
+    assert.equal(good.code, null);
+    assert.deepEqual(writes, [
+      { key: 'tweak.autopickup', value: 'on', by: 7 },
+      { key: 'tweak.autopickup_monthly_cap', value: 5, by: 7 },
+    ]);
+    assert.equal(good.payload.mode, 'on');
+    assert.equal(good.payload.cap, 5);
+  } finally { restore(); }
+});
+
+test('core_275 is additive: one nullable column, recorded in schema_migrations', () => {
+  const sql = fs.readFileSync(path.join(ROOT, 'migrations', 'core_275_claims_auto_pickup.sql'), 'utf8');
+  assert.match(sql, /ALTER TABLE claims ADD COLUMN IF NOT EXISTS auto_pickup boolean;/);
+  assert.doesNotMatch(sql, /NOT NULL|DROP /);
+  assert.match(sql, /INSERT INTO schema_migrations \(version\) VALUES \('core_275_claims_auto_pickup'\)/);
+});

package/tests/autopickup_cap_db.mjs

@@ -0,0 +1,115 @@
+// tests/autopickup_cap_db.mjs — the auto-pickup cap holds under a race, against a
+// REAL Postgres (task 1004677 / BV2.TW19a, ADR 0371 D5).
+//
+// tests/autopickup_cap.mjs proves the refusal ladder DB-free. What it cannot prove
+// is the claim this file exists for: two runners racing for the LAST slot cannot
+// both get it. That is a property of pg_advisory_xact_lock plus the count running
+// inside the claim's transaction, so it needs a real database and two real
+// connections.
+//
+// It SELF-SKIPS (exit 0) with no reachable Postgres, and is listed in
+// run-unit-tests.js's INTEGRATION set so the DB-free lane never runs it. It builds
+// throwaway `tasks` and `claims` tables, so point it at a scratch database.
+//
+// Run:  DATABASE_URL=postgres://... node tests/autopickup_cap_db.mjs
+
+import pg from 'pg';
+import fs from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+import { createRequire } from 'node:module';
+import { strict as assert } from 'node:assert';
+
+const require = createRequire(import.meta.url);
+const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL || undefined });
+
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`autopickup_cap_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}). Set DATABASE_URL to run.`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+const { rows: realRows } = await pool.query(`SELECT to_regclass('public.builders') IS NOT NULL AS has_builders`);
+if (realRows[0].has_builders) {
+  console.log('autopickup_cap_db.mjs SKIPPED — this database has a `builders` table, so it is not a scratch DB.');
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+let passed = 0, failed = 0;
+async function t(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL ${name}\n     ${e.message}`); }
+}
+
+await pool.query(`
+  CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY);
+  CREATE TABLE IF NOT EXISTS tasks (id bigint PRIMARY KEY, source text);
+  CREATE TABLE IF NOT EXISTS claims (
+    id bigserial PRIMARY KEY, task_id bigint, builder_id bigint,
+    claimed_at timestamptz DEFAULT now(), released_at timestamptz);
+`);
+const HERE = path.dirname(url.fileURLToPath(import.meta.url));
+await pool.query(fs.readFileSync(path.join(HERE, '..', 'migrations', 'core_275_claims_auto_pickup.sql'), 'utf8'));
+
+const { autoPickupRefusal, countThisMonth } = require('../modules/lifecycle/autopickup.js');
+
+async function reset() {
+  await pool.query('TRUNCATE claims, tasks');
+  await pool.query(`INSERT INTO tasks (id, source) VALUES (1,'page-tweak'),(2,'page-tweak'),(3,'page-tweak'),(4,'manual')`);
+}
+
+// One marked claim the way claimTask makes it: BEGIN, the gate (which takes the
+// lock and counts), the insert, COMMIT. `pause` holds the transaction open after
+// the count so the other racer's count is forced to happen while it is in flight.
+async function markedClaim(taskId, settings, pause = 0) {
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN');
+    const refusal = await autoPickupRefusal(client, { id: taskId, source: 'page-tweak' }, settings);
+    if (refusal) { await client.query('ROLLBACK'); return refusal.code; }
+    if (pause) await new Promise((r) => setTimeout(r, pause));
+    await client.query('INSERT INTO claims (task_id, builder_id, auto_pickup) VALUES ($1, 1, TRUE)', [taskId]);
+    await client.query('COMMIT');
+    return 'claimed';
+  } catch (e) {
+    await client.query('ROLLBACK').catch(() => {});
+    throw e;
+  } finally { client.release(); }
+}
+
+await t('core_275 adds a nullable auto_pickup column', async () => {
+  const { rows } = await pool.query(`SELECT is_nullable, data_type FROM information_schema.columns WHERE table_name='claims' AND column_name='auto_pickup'`);
+  assert.equal(rows[0].data_type, 'boolean');
+  assert.equal(rows[0].is_nullable, 'YES');
+});
+
+await t('two runners racing for the last slot: exactly one wins', async () => {
+  await reset();
+  await pool.query(`INSERT INTO claims (task_id, builder_id, auto_pickup) VALUES (3, 1, TRUE)`); // cap 2, one used
+  const settings = { mode: 'on', cap: 2 };
+  const results = await Promise.all([markedClaim(1, settings, 300), markedClaim(2, settings, 300)]);
+  assert.deepEqual(results.sort(), ['AUTO_PICKUP_CAP_REACHED', 'claimed'], JSON.stringify(results));
+  assert.equal(await countThisMonth(pool), 2);
+});
+
+await t('a round applied twice automatically refuses a third marked claim', async () => {
+  await reset();
+  const settings = { mode: 'on', cap: 20 };
+  assert.equal(await markedClaim(1, settings), 'claimed');
+  assert.equal(await markedClaim(1, settings), 'claimed');
+  assert.equal(await markedClaim(1, settings), 'AUTO_PICKUP_ROUND_LIMIT');
+});
+
+await t('unmarked claims and last month\'s marked claims do not count', async () => {
+  await reset();
+  await pool.query(`INSERT INTO claims (task_id, builder_id, auto_pickup, claimed_at) VALUES
+    (1, 1, NULL, now()), (2, 1, FALSE, now()), (3, 1, TRUE, date_trunc('month', now()) - interval '1 day'),
+    (4, 1, TRUE, now())`); // task 4 is not a page tweak
+  assert.equal(await countThisMonth(pool), 0);
+});
+
+await pool.end();
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0); // the doorway's own pool would otherwise hold the process open

package/tests/copy_desk_page_submit.mjs

@@ -282,6 +282,42 @@ try {
     assert.equal((t.description.match(/```page-tweak\n/g) || []).length, 1);
     assert.equal(t.status, 'ready');
   });
+  // Task 1004696: the artist recommends a line be removed. The real routes:
+  // the save stores it, the editor read returns it, and the submit hands it to
+  // an engineer as a removal, never into the applier's batch.
+  await test('a removal is saved, read back, and submitted as an engineer task to take the line out', async () => {
+    const PROJECTS = '/copy-desk/pages/landing:projects';
+    const PROJECT_LINES = [
+      L('L0001', 'hero', 'Projects', 'placed', { file: 'modules/public-landing/public/projects.html', line: 5, string_id: 'pj0001' }),
+      L('L0002', 'hero', 'Every project on this instance, newest first', 'placed', { file: 'modules/public-landing/public/projects.html', line: 6, string_id: 'pj0002' }),
+    ];
+    const r0 = readingsWith({ hash: 'studio-h1', lines: STUDIO_LINES }, { hash: 'index-h2', lines: INDEX_LINES });
+    r0.pages.push({ id: 'landing:projects', reading_hash: 'projects-h1', lines: PROJECT_LINES });
+    writeReadings(r0);
+    assert.equal((await call('POST', `${PROJECTS}/claim`, ALICE)).status, 201);
+
+    const empty = await call('PUT', `${PROJECTS}/draft`, ALICE, { reading_hash: 'projects-h1', lines: [{ key: 'L0002', after: '' }] });
+    assert.equal(errCode(empty.body), 'line_empty', 'empty words alone never remove a line');
+    assert.match(errDetail(empty.body).what_this_means, /remove: true/, 'the refusal says how to ask for a removal');
+
+    const saved = await call('PUT', `${PROJECTS}/draft`, ALICE, { reading_hash: 'projects-h1', lines: [{ key: 'L0001', after: 'All projects' }, { key: 'L0002', remove: true }] });
+    assert.equal(saved.status, 200, JSON.stringify(saved.body));
+    assert.deepEqual(saved.body.counter, { changed: 2, total: 2 });
+    const read = await call('GET', `${PROJECTS}/draft`, ALICE);
+    assert.deepEqual(read.body.draft.lines, [{ key: 'L0001', after: 'All projects' }, { key: 'L0002', after: '', remove: true }]);
+
+    const r = await call('POST', `${PROJECTS}/submit`, ALICE);
+    assert.equal(r.status, 200, JSON.stringify(r.body));
+    assert.equal(r.body.batch.line_count, 1, 'only the rewrite is the applier\'s');
+    const round = db.tasks.find((t) => t.source_ref === 'page-tweak/landing:projects/r1');
+    assert.deepEqual(pages.parseBatchBlock(round.description).batch.lines.map((l) => l.key), ['L0001']);
+    const eng = db.tasks.find((t) => t.source_ref === `page-tweak-unplaced/${round.id}/L0002`);
+    assert.ok(eng, 'the removal is an engineer task, keyed like any engineer line');
+    assert.equal(eng.title, 'Remove "Every project on this instance, newest first" (landing:projects)');
+    assert.match(eng.description, /stop showing a line/);
+    assert.match(eng.description, /take it out/);
+    assert.deepEqual([eng.status, eng.discipline], ['backlog', 'engineer']);
+  });
 } finally {
   server.close();
   pageData._setRoot(null);

package/tests/government_act_alone_buildings.mjs

@@ -242,6 +242,7 @@ const BAD = 'x';
 const REQUESTS = {
   '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/tests/hall_tweak_editor.mjs

@@ -188,21 +188,37 @@ try {
     assert.deepEqual(lib.noteFor(byKey.L0002, 'Projects', ed.notes), { kind: 'engineer', text: 'goes to an engineer' }, 'shared with no registry row goes to an engineer, the submit\'s rule');
     assert.deepEqual(lib.noteFor(byKey.L0004, 'Agents write the code.', ed.notes), { kind: 'was', text: 'was: AI agents claim tasks and ship the code.' });
     assert.equal(lib.noteFor(byKey.L0003, 'Building Digitally,', ed.notes), null);
+    // An emptied line says it will be removed, ahead of any other note (task 1004696).
+    assert.deepEqual(lib.noteFor(byKey.L0004, '  ', ed.notes), { kind: 'removed', text: 'to be removed · goes to an engineer · was: AI agents claim tasks and ship the code.' });
+    assert.equal(lib.noteFor(byKey.L0001, '', ed.notes).kind, 'removed');
   });
 
-  await test('the autosave body is the WHOLE draft: every changed, non-empty line, and nothing else', () => {
+  await test('the autosave body is the WHOLE draft: every changed line, an emptied one as a removal, and nothing else', () => {
     const values = lib.initialValues(READING.lines, { lines: [{ key: 'L0004', after: 'Agents write the code.' }] });
-    values.L0003 = '';           // emptied: removing words is a code change, never saved
+    values.L0003 = '   ';        // emptied: the artist recommends removing it (task 1004696)
     values.L0006 = 'Built by agents.'; // back to the page's words: not a rewrite
     values.L0007 = 'Log in';
     assert.deepEqual(lib.draftBody('rh-1', READING.lines, values), {
       reading_hash: 'rh-1',
-      lines: [{ key: 'L0004', after: 'Agents write the code.' }, { key: 'L0007', after: 'Log in' }],
+      lines: [{ key: 'L0003', remove: true }, { key: 'L0004', after: 'Agents write the code.' }, { key: 'L0007', after: 'Log in' }],
     });
+    assert.equal(lib.changedCount(READING.lines, values), 3, 'a removal counts as a change');
     assert.equal(lib.counterText(2, 7, 'saving'), '2 of 7 rewritten · saving…');
     assert.equal(lib.counterText(2, 7, 'saved'), '2 of 7 rewritten · saved');
   });
 
+  await test('a removal the server holds reads back as an empty value, so the next save from ANY editor keeps it (task 1004696)', () => {
+    const draft = { lines: [{ key: 'L0003', after: '', remove: true }, { key: 'L0004', after: 'Agents write the code.' }] };
+    const values = lib.initialValues(READING.lines, draft);
+    assert.equal(values.L0003, '');
+    assert.equal(lib.isRemoved(READING.lines.find((l) => l.key === 'L0003'), values.L0003), true);
+    values.L0007 = 'Log in';   // the tweak editor or the studio saves something else
+    assert.deepEqual(lib.draftBody('rh-1', READING.lines, values).lines,
+      [{ key: 'L0003', remove: true }, { key: 'L0004', after: 'Agents write the code.' }, { key: 'L0007', after: 'Log in' }]);
+    values.L0003 = 'Building, digitally';   // typed over: the rewrite replaces the removal
+    assert.deepEqual(lib.draftBody('rh-1', READING.lines, values).lines[0], { key: 'L0003', after: 'Building, digitally' });
+  });
+
   await test('names, addresses and the page id', () => {
     assert.equal(lib.displayTitle(PAGE), 'Home', 'a templated title on "/" is the page called Home');
     assert.equal(lib.displayTitle(NEXT.recommended), 'Projects');

package/tests/paintbrush.mjs

@@ -9,6 +9,8 @@
 // else's view changes — the page's words come back when editing ends, and the
 // only writes are the copy desk's own page-round routes (owner, 2026-10-04: the
 // edits are real wording changes, kept apart from the palette's feedback docs).
+// Task 1004696 adds removing a line (saved as { key, remove: true }, sent to an
+// engineer) and the artist review one press away, while editing and once sent.
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
 import fs from 'node:fs';
@@ -176,7 +178,16 @@ function boot({ round = null, draft = null, claim = { status: 200, body: { ok: t
   };
   const type = (el, text) => { el.textContent = text; fire('input', { target: el }); };
   const editable = () => p.body.querySelectorAll('*').filter((n) => n.hasAttribute('contenteditable'));
-  return { ...p, leave: () => (winListeners.pagehide || []).forEach((fn) => fn()), brush: window.OTBPaintbrush, calls, bar, press, type, fire, editable, html: document.documentElement, writes: () => calls.filter((c) => c.method !== 'GET') };
+  // The review sheet's script, as the page would load it: answer the tag the
+  // paintbrush appended with a stand-in OTBPageNotes that records its opening.
+  const notesOpened = [];
+  const loadNotes = () => {
+    const tag = head.children.find((c) => /\/builders\/page-notes\.js\?v=2026-10-04-test$/.test(c.src || ''));
+    assert.ok(tag, 'the review sheet\'s own script was asked for, at the paintbrush\'s ?v');
+    window.OTBPageNotes = { open: () => notesOpened.push('open') };
+    tag.onload();
+  };
+  return { ...p, leave: () => (winListeners.pagehide || []).forEach((fn) => fn()), brush: window.OTBPaintbrush, calls, bar, press, type, fire, editable, html: document.documentElement, head, loadNotes, notesOpened, writes: () => calls.filter((c) => c.method !== 'GET') };
 }
 const settle = () => new Promise((r) => setTimeout(r, 5));
 
@@ -310,7 +321,10 @@ test('the only routes it writes are the copy desk\'s page round — never page-n
   const routes = [...BRUSH.matchAll(/request\('(POST|PUT|PATCH|DELETE)', [^,]*?'\/([a-z-]+)'/g)].map((m) => m[1] + ' ' + m[2]);
   assert.deepEqual(routes.sort(), ['POST claim', 'POST submit', 'PUT draft']);
   assert.match(BRUSH, /var API = '\/api\/bongos\/copy-desk\/pages\/';/);
-  assert.doesNotMatch(BRUSH, /page-notes/);
+  assert.doesNotMatch(BRUSH, /\/api\/bongos\/page-notes|\/page-notes\//, 'no feedback-doc route');
+  // Task 1004696: it may OPEN the artist review sheet (which writes its own
+  // doc); that script is the only page-notes thing it names.
+  assert.deepEqual([...BRUSH.matchAll(/page-notes[\w.-]*/g)].map((m) => m[0]).filter((w) => w !== 'page-notes.js'), []);
 });
 
 test('its styles live in style.css, on the token tier', () => {
@@ -342,6 +356,141 @@ test('words only: bold, italic and underline keys do nothing in the words; elsew
   assert.equal(prevented, 3, 'a key outside the edited words is not touched');
 });
 
+// ---------- removing a line (task 1004696) ----------
+const held = () => boot({ round: { task_id: '9', state: 'writing', held_by_you: true, holder: { login: 'me' } } });
+
+test('REMOVE THIS LINE acts on the line the artist is in: saved as a removal, struck through, and KEEP puts it back', async () => {
+  const p = held();
+  p.brush.open();
+  await settle();
+  assert.match(p.bar().innerHTML, /Where the build is going<\/span><button[^>]*data-pb-remove>/, 'the first line is offered from the start, even when the window fires no focus');
+  p.fire('focusin', { target: p.lede });
+  assert.match(p.bar().innerHTML, /Every version, from first idea to shipped\.<\/span><button[^>]*data-pb-remove>Remove this line/);
+  p.press('data-pb-remove');
+  await settle();
+  const put = p.writes().filter((c) => c.method === 'PUT').pop();
+  assert.deepEqual(JSON.parse(JSON.stringify(put.body.lines)), [{ key: 'L0003', remove: true }], 'saved as a removal, never as empty words');
+  assert.ok(p.lede.classList.contains('pb-word--removed'));
+  assert.ok(!p.lede.hasAttribute('contenteditable'), 'a removed line is not typed into');
+  assert.equal(p.lede.getAttribute('tabindex'), '0', 'but it can still be reached, to keep it');
+  assert.equal(p.lede.textContent, 'Every version, from first idea to shipped.', 'it shows the page\'s words, struck through');
+  assert.match(p.bar().innerHTML, /<strong>1 change<\/strong>/);
+  assert.match(p.bar().innerHTML, /data-pb-keep>Keep this line/);
+  p.press('data-pb-keep');
+  await settle();
+  assert.ok(!p.lede.classList.contains('pb-word--removed'));
+  assert.equal(p.lede.getAttribute('contenteditable'), 'plaintext-only', 'editable again');
+  assert.deepEqual(JSON.parse(JSON.stringify(p.writes().filter((c) => c.method === 'PUT').pop().body.lines)), [], 'and the removal leaves the draft');
+});
+
+test('emptying a line\'s words and leaving it marks it to be removed, instead of silently dropping it', async () => {
+  const p = held();
+  p.brush.open();
+  await settle();
+  p.type(p.h1, '   ');
+  assert.equal(p.h1.getAttribute('contenteditable'), 'plaintext-only', 'still editable while the artist is in it: they may be retyping');
+  p.fire('focusout', { target: p.h1 });
+  await settle();
+  assert.ok(p.h1.classList.contains('pb-word--removed'));
+  assert.equal(p.h1.textContent, 'Where the build is going');
+  const put = p.writes().filter((c) => c.method === 'PUT').pop();
+  assert.deepEqual(JSON.parse(JSON.stringify(put.body.lines)), [{ key: 'L0002', remove: true }]);
+});
+
+test('REVIEW lists a removal as its own row, says it goes to an engineer, and SEND submits it with the rewrites', async () => {
+  const p = held();
+  p.brush.open();
+  await settle();
+  p.type(p.h1, 'Where we are going');
+  p.fire('focusin', { target: p.linkWords });
+  p.press('data-pb-remove');
+  p.press('data-pb-review');
+  await settle();
+  const html = p.bar().innerHTML;
+  assert.match(html, /pb__change--remove[\s\S]*Remove<\/span> See every goal/);
+  assert.match(html, /A line you remove goes to an engineer to take out\./);
+  p.press('data-pb-send');
+  await settle();
+  const lastPut = p.writes().filter((c) => c.method === 'PUT').pop();
+  assert.deepEqual(JSON.parse(JSON.stringify(lastPut.body.lines)), [{ key: 'L0002', after: 'Where we are going' }, { key: 'L0004', remove: true }]);
+  assert.match(p.bar().innerHTML, /Sent for approval: 2 changes/);
+  assert.equal(p.linkWords.textContent, 'See every goal', 'the page shows its own words again');
+  assert.ok(!p.linkWords.classList.contains('pb-word--removed') && !p.linkWords.hasAttribute('tabindex'), 'and nothing of the mark is left behind');
+});
+
+test('a removal saved earlier comes back struck through when editing resumes', async () => {
+  const p = boot({
+    round: { task_id: '9', state: 'writing', held_by_you: true, holder: { login: 'me' } },
+    draft: { reading_hash: 'abc123', lines: [{ key: 'L0003', after: '', remove: true }] },
+  });
+  p.brush.open();
+  await settle();
+  assert.ok(p.lede.classList.contains('pb-word--removed'));
+  assert.equal(p.lede.textContent, 'Every version, from first idea to shipped.');
+  assert.match(p.bar().innerHTML, /1 change/);
+});
+
+// ---------- the artist review alongside (task 1004696) ----------
+test('ARTIST REVIEW in the editing bar saves the words, opens the review sheet for this page, and editing carries on', async () => {
+  const p = held();
+  p.brush.open();
+  await settle();
+  assert.match(p.bar().innerHTML, /data-pb-notes[^>]*>Artist review</);
+  p.type(p.h1, 'A heading, mid-edit');
+  p.press('data-pb-notes');
+  await settle();
+  assert.ok(p.writes().some((c) => c.method === 'PUT'), 'the words were saved before the sheet opened');
+  p.loadNotes();
+  await settle();
+  assert.deepEqual(p.notesOpened, ['open']);
+  assert.ok(p.bar(), 'the paintbrush stays');
+  assert.equal(p.h1.getAttribute('contenteditable'), 'plaintext-only', 'and the words are still being edited');
+  assert.ok(!p.writes().some((c) => /page-notes/.test(c.url)), 'the paintbrush itself writes no feedback doc');
+});
+
+test('once SENT, the bar asks whether to review how the page looks too: one press opens the sheet, Not now closes', async () => {
+  const p = held();
+  p.brush.open();
+  await settle();
+  p.type(p.h1, 'Where we are going');
+  p.press('data-pb-review');
+  p.press('data-pb-send');
+  await settle();
+  const html = p.bar().innerHTML;
+  assert.match(html, /Review how this page looks too\?/);
+  assert.match(html, /each point becomes an idea under your name/);
+  assert.match(html, /data-pb-notes data-pb-focus>Start an artist review/);
+  p.press('data-pb-notes');
+  await settle();
+  p.loadNotes();
+  await settle();
+  assert.deepEqual(p.notesOpened, ['open']);
+  assert.equal(p.bar(), null, 'the sent bar\'s work is done, so it closes');
+
+  const q = held();
+  q.brush.open();
+  await settle();
+  q.type(q.h1, 'Another heading');
+  q.press('data-pb-review');
+  q.press('data-pb-send');
+  await settle();
+  q.press('data-pb-close');
+  assert.equal(q.bar(), null);
+  assert.equal(q.head.children.filter((c) => /page-notes/.test(c.src || '')).length, 0, 'Not now loads nothing');
+});
+
+test('a review sheet that cannot load says so in the bar and points to the top bar\'s Review', async () => {
+  const p = held();
+  p.brush.open();
+  await settle();
+  p.press('data-pb-notes');
+  await settle();
+  const tag = p.head.children.find((c) => /page-notes\.js/.test(c.src || ''));
+  tag.onerror();
+  await settle();
+  assert.match(p.bar().innerHTML, /The artist review could not open\. Press Review in the top bar instead\./);
+});
+
 test('a word on the page matches its line however its spaces wrap, and one table serves every element', async () => {
   const p = boot({ round: { task_id: '9', state: 'writing', held_by_you: true, holder: { login: 'me' } } });
   p.lede.textContent = '  Every version,\n   from first idea to shipped. ';