@bongos/core 1.21.107 → 1.21.109

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/scripts/hall-preview/server.js

@@ -271,7 +271,18 @@ const app = express();
 app.use((req, res, next) => {
   const m = req.path.match(/^\/api\/(?:gds|bongos)(?:\/v1)?\/(.+)$/);
   if (!m) return next();
-  const apiPath = m[1].replace(/\/$/, '');
+  // Decoded before any matching (task 1004700): the paintbrush sends its page id
+  // through encodeURIComponent, so builders:studio arrives as builders%3Astudio
+  // and every copy-desk fixture and canned write missed. A malformed escape keeps
+  // the raw path, which then simply finds no fixture.
+  let apiPath = m[1].replace(/\/$/, '');
+  try { apiPath = decodeURIComponent(apiPath); } catch { /* keep raw */ }
+  // Decoding can mint a backslash, NUL or `..` segment that the fixture-name
+  // mapper does not neutralise (path.join honours `\` on Windows), so a decoded
+  // path that could leave the fixtures dir is refused outright.
+  if (/[\\\0]|(^|\/)\.\.(\/|$)/.test(apiPath)) {
+    return res.status(400).json({ error: { code: 'bad_path', message: 'path escapes the fixtures' } });
+  }
 
   // SSE live channel: emit one nudge (so "live refresh" paths run once), then
   // keep-alive comments. Pages treat this exactly like prod's stream.

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.107'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.109'; // 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');

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/hall_preview_encoded_paths.mjs

@@ -0,0 +1,81 @@
+// tests/hall_preview_encoded_paths.mjs — the hall preview decodes the API path
+// before matching fixtures and canned writes (task 1004700).
+//
+// The paintbrush sends its page id through encodeURIComponent, so builders:studio
+// arrives as builders%3Astudio. Matched raw, every copy-desk read and canned write
+// 404'd and the bar said "That page could not be taken just now". This boots the
+// real harness and asks for both spellings.
+//
+// Run:  node --test tests/hall_preview_encoded_paths.mjs
+
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+let child;
+let base;
+
+function freePort() {
+  return new Promise((resolve, reject) => {
+    const s = net.createServer();
+    s.once('error', reject);
+    s.listen(0, '127.0.0.1', () => { const { port } = s.address(); s.close(() => resolve(port)); });
+  });
+}
+
+before(async () => {
+  const port = await freePort();
+  base = `http://127.0.0.1:${port}/api/bongos/copy-desk/pages`;
+  child = spawn(process.execPath, ['scripts/hall-preview/server.js', '--port', String(port), '--fixture-me'], { cwd: ROOT, stdio: ['ignore', 'pipe', 'pipe'] });
+  await new Promise((resolve, reject) => {
+    const t = setTimeout(() => reject(new Error('hall-preview did not start')), 60000);
+    child.stdout.on('data', (b) => { if (String(b).includes('hall-preview:')) { clearTimeout(t); resolve(); } });
+    child.once('exit', (code) => { clearTimeout(t); reject(new Error(`hall-preview exited ${code}`)); });
+  });
+});
+
+after(() => { if (child) child.kill(); });
+
+async function call(method, id, tail) {
+  const r = await fetch(`${base}/${id}/${tail}`, { method, headers: { 'content-type': 'application/json' }, body: method === 'GET' ? undefined : '{}' });
+  return { status: r.status, body: await r.json() };
+}
+
+test('GET draft: an encoded page id gets the same fixture as the plain one', async () => {
+  const plain = await call('GET', 'builders:studio', 'draft');
+  const encoded = await call('GET', encodeURIComponent('builders:studio'), 'draft');
+  assert.equal(plain.status, 200);
+  assert.equal(encoded.status, 200);
+  assert.deepEqual(encoded.body, plain.body);
+  // and the catch-all, for a page with no fixture of its own
+  const other = await call('GET', encodeURIComponent('builders:work'), 'draft');
+  assert.equal(other.status, 200);
+  assert.deepEqual(other.body, (await call('GET', 'builders:work', 'draft')).body);
+});
+
+test('canned PUT draft: an encoded page id gets the same canned reply as the plain one', async () => {
+  const plain = await call('PUT', 'builders:studio', 'draft');
+  const encoded = await call('PUT', encodeURIComponent('builders:studio'), 'draft');
+  assert.equal(plain.status, 200);
+  assert.equal(encoded.status, 200);
+  assert.deepEqual(encoded.body, plain.body);
+});
+
+test('a decoded backslash or .. segment cannot walk out of the fixtures dir', async () => {
+  for (const id of ['..%5c..%5c..%5cpackage', '..%2F..%2Fpackage', 'a%00b']) {
+    const r = await call('GET', id, 'draft');
+    assert.equal(r.status, 400, id);
+    assert.equal(r.body.error.code, 'bad_path', id);
+  }
+  // the PUT path is checked before CANNED_WRITES too
+  assert.equal((await call('PUT', '..%5cx', 'draft')).status, 400);
+});
+
+test('a malformed escape does not crash the harness', async () => {
+  const r = await call('GET', 'builders%E0%A4%A', 'draft');
+  assert.equal(r.status, 404);
+});

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. ';

package/tests/planning_session_skill.mjs

@@ -83,12 +83,70 @@ test('the mechanics-map step names the subagent mechanism and the retro preceden
   assert.ok(section.includes('task 1003075'));
 });
 
-test('the step is scoped to process-change sessions, not every planning session', () => {
+// task 1004675 (idea 1001074): the step used to read as an opt-in for
+// process-change sessions only, so the sessions with a confident owner model
+// skipped it. It is now the default; skipping is what needs a stated reason.
+function phase15() {
   const start = NORM.indexOf('Phase 1.5 — Map the mechanism');
   const end = NORM.indexOf('Phase 2 — Criteria', start);
-  const section = NORM.slice(start, end === -1 ? undefined : end);
-  assert.ok(/process-change/i.test(section));
-  assert.ok(/skip/i.test(section), 'says explicitly when to skip it');
+  return NORM.slice(start, end === -1 ? undefined : end);
+}
+
+test('the mapping step is the default for any existing surface, and skipping it needs a stated reason', () => {
+  const section = phase15();
+  assert.ok(!/process-change sessions only/i.test(section), 'no longer framed as opt-in for process-change sessions');
+  assert.match(section, /by default for any session that touches an existing surface/);
+  assert.match(section, /Skipping it is the thing that needs a stated reason/);
+  assert.match(section, /confident model/, 'names the confident-owner case as the one most likely to skip');
+});
+
+test('the mapping subagent is always asked the computable-quantity question', () => {
+  assert.match(phase15(), /Name any quantity this design assumes is computable, and say whether it actually is/);
+});
+
+// --- task 1004675: tie criteria to the agreed design --------------------------
+
+function criteriaPhase() {
+  const start = NORM.indexOf('### Phase 2 — Criteria');
+  const end = NORM.indexOf('### Phase 2.5', start);
+  return NORM.slice(start, end);
+}
+
+test('Phase 2 says the grader reads the description and diff, not the spec', () => {
+  const s = criteriaPhase();
+  assert.match(s, /grader reads the \*\*task description and the diff\*\*/);
+  assert.match(s, /does \*\*not\*\* read `docs\/specs\/`/);
+});
+
+test('Phase 2 names the three bindings: model vs rendering, a proof a wrong build fails, cite the design of record', () => {
+  const s = criteriaPhase();
+  assert.match(s, /Split the settled design into MODEL and RENDERING/);
+  assert.match(s, /goes \*\*into the criterion text\*\*/, 'the model goes in the criterion');
+  assert.match(s, /stays in the spec, free to change/, 'the rendering stays in the spec');
+  assert.match(s, /proof whose scenario a wrong build fails/);
+  assert.match(s, /Cite the design of record in every task description, and make sure the builder can open it/);
+  assert.match(s, /private artifact link/, 'warns that an unopenable design of record is decorative');
+});
+
+test('Phase 3 carries the binding into the proof task and every task description', () => {
+  const start = NORM.indexOf('### Phase 3');
+  const s = NORM.slice(start, NORM.indexOf('### Phase 4', start));
+  assert.match(s, /The proof's scenario must be one a wrong build fails/);
+  assert.match(s, /every description cites the design of record/);
+});
+
+test('Phase 4 lays naming options side by side before recommending one', () => {
+  const start = NORM.indexOf('### Phase 4');
+  const s = NORM.slice(start, NORM.indexOf('### Phase 5', start));
+  assert.match(s, /show the options side by side before recommending one/);
+  assert.match(s, /never one name with "or something else\?"/);
+});
+
+test('big design-driven asks are routed to /planning-session before seeding, from both playbooks', () => {
+  const when = NORM.slice(NORM.indexOf('## When to invoke'), NORM.indexOf('## When NOT to invoke'));
+  assert.match(when, /big design-driven ask arrives — route it here BEFORE any task is seeded/);
+  const goal = fs.readFileSync(path.join(ROOT, '.claude/skills/goal-create/SKILL.md'), 'utf8').replace(/\s+/g, ' ');
+  assert.match(goal, /big design-driven ask\*\* .* route it to `\/planning-session` before seeding anything/);
 });
 
 // --- task 1001438: the Phase 5 promote must be scoped to the seeded set -----
@@ -161,5 +219,45 @@ test('Phase 5 re-probes the session before the first write, and on a 401 re-auth
   assert.match(p5, /idempotent/i, 'and says why a re-run is safe');
 });
 
+// ---- task 1004668: a new task does not wait at backlog, and ready is not claimable ----
+// POST /tasks answers 'backlog', then the reconciler's sweep promotes any task with
+// no unmet dependency within about a minute. Three playbooks said a new task sits at
+// backlog until promoted; one triage told the owner 15 tasks awaited their go and then
+// hit 409 cannot_promote on every one.
+
+const read = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8').replace(/\s+/g, ' ');
+const PLAYBOOKS = ['planning-session', 'idea-triage', 'goal-create', 'owner-review', 'backlog-review']
+  .map((s) => [s, read(`.claude/skills/${s}/SKILL.md`)]);
+
+test('no playbook says a newly created task lands at backlog and waits for a promote', () => {
+  for (const [name, text] of PLAYBOOKS) {
+    assert.ok(!/Every newly-seeded task lands `status='backlog'`/.test(text), `${name}: the seed-lands-at-backlog claim`);
+    assert.ok(!/Every new task lands status='backlog'/.test(text), `${name}: the new-task-lands-at-backlog claim`);
+    assert.ok(!/lands the new task in `backlog`, \*\*not\*\* `active`/.test(text), `${name}: the triage claim`);
+  }
+});
+
+test('the Phase 5 promote step reads the statuses first and names the claim gate as the enforcement', () => {
+  const step = promoteStep();
+  assert.match(step, /Do \*\*not\*\* assume the seed landed at `backlog`/, 'replaces the assumption with a check');
+  assert.match(step, /backlog sweep/, 'names what promotes them');
+  assert.match(step, /`ready` is not "claimable"/, 'says ready is not claimable');
+  assert.match(step, /DEPS_NOT_SHIPPED/, 'names the claim-time dependency gate');
+});
+
+test('idea-triage and goal-create say to re-read the status and promote only what is still at backlog', () => {
+  const triage = PLAYBOOKS.find(([n]) => n === 'idea-triage')[1];
+  assert.match(triage, /auto-promoted to `ready` within about a minute/);
+  assert.match(triage, /Re-read its status after creating/);
+  assert.match(triage, /409 cannot_promote/);
+  const goal = PLAYBOOKS.find(([n]) => n === 'goal-create')[1];
+  assert.match(goal, /promote only a non-spike still at 'backlog'/);
+});
+
+test('the seeding contract names the pre-seed baseline for a populated goal', () => {
+  assert.ok(NORM.includes('baselineSeedCriteria'), 'names the baseline helper');
+  assert.match(NORM, /BEFORE the first write/);
+});
+
 console.log(`\nplanning_session_skill: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);