@bongos/core 1.21.107 → 1.21.108

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

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_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

@@ -161,5 +161,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);

package/tests/seed_verify_criteria.mjs

@@ -15,11 +15,13 @@
 
 import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
 
 const require = createRequire(import.meta.url);
 const {
   diffCriterionLinks,
   expectedCriterionCounts,
+  baselineSeedCriteria,
   verifySeedCriteriaLinks,
 } = require('../scripts/gds/seed-verify-criteria.js');
 
@@ -145,5 +147,133 @@ await testAsync('a failed/malformed GET is treated as a verification failure, no
   assert.ok(logs.some((l) => l.includes('VERIFY FAILED')));
 });
 
+// --- task 1004668: seeding into a goal that already carries linked work -----
+//
+// Goal 1000095 held six criteria with live links (1, 9, 4, 3, 6, 10) before a
+// seed touched it. The old diff unioned those into the check with an expected
+// count of zero, so a CORRECT seed exited 1 six times over.
+
+const POPULATED = [
+  { criterion_id: 'old-1', linked_tasks: 1 }, { criterion_id: 'old-2', linked_tasks: 9 },
+  { criterion_id: 'old-3', linked_tasks: 4 }, { criterion_id: 'old-4', linked_tasks: 3 },
+  { criterion_id: 'old-5', linked_tasks: 6 }, { criterion_id: 'old-6', linked_tasks: 10 },
+];
+
+test('THE INCIDENT: without a baseline, criteria the seed does not cite are not assumed to be zero', () => {
+  const rows = [...POPULATED, { criterion_id: 'ours', linked_tasks: 2 }];
+  assert.deepEqual(diffCriterionLinks({ ours: 2 }, rows), []);
+});
+
+test('without a baseline the plan\'s own criteria are still checked', () => {
+  const rows = [...POPULATED, { criterion_id: 'ours', linked_tasks: 0 }];
+  assert.deepEqual(diffCriterionLinks({ ours: 2 }, rows), [{ criterion_id: 'ours', expected: 2, actual: 0 }]);
+});
+
+test('with a baseline, an untouched criterion at its pre-seed count passes', () => {
+  const baseline = { 'old-1': 1, 'old-2': 9, 'old-3': 4, 'old-4': 3, 'old-5': 6, 'old-6': 10, ours: 0 };
+  const rows = [...POPULATED, { criterion_id: 'ours', linked_tasks: 2 }];
+  assert.deepEqual(diffCriterionLinks({ ours: 2 }, rows, { baseline }), []);
+});
+
+test('with a baseline, a stray link onto a criterion the seed never cites is caught', () => {
+  // The RETRO2 mislink lands tasks on the WRONG criterion. With a baseline that
+  // excess is visible even though the wrong criterion is not in the plan.
+  const baseline = { 'old-1': 1, ours: 0 };
+  const rows = [{ criterion_id: 'old-1', linked_tasks: 3 }, { criterion_id: 'ours', linked_tasks: 0 }];
+  assert.deepEqual(diffCriterionLinks({ ours: 2 }, rows, { baseline }), [
+    { criterion_id: 'old-1', expected: 1, actual: 3 },
+    { criterion_id: 'ours', expected: 2, actual: 0 },
+  ]);
+});
+
+test('with a baseline, a planned criterion that already had links expects baseline + plan', () => {
+  const rows = [{ criterion_id: 'shared', linked_tasks: 7 }];
+  assert.deepEqual(diffCriterionLinks({ shared: 2 }, rows, { baseline: { shared: 5 } }), []);
+  assert.deepEqual(diffCriterionLinks({ shared: 2 }, rows, { baseline: { shared: 4 } }),
+    [{ criterion_id: 'shared', expected: 6, actual: 7 }]);
+});
+
+test('a criterion created after the baseline starts at zero, so a link on it is caught', () => {
+  const rows = [{ criterion_id: 'brand-new', linked_tasks: 1 }];
+  assert.deepEqual(diffCriterionLinks({}, rows, { baseline: {} }),
+    [{ criterion_id: 'brand-new', expected: 0, actual: 1 }]);
+});
+
+const goalWith = (criteria) => async () => ({ ok: true, status: 200, json: { criteria } });
+
+// A RESUMED seed (grade finding on task 1004668). The first run created task A
+// (linked to `ours`) and died; the re-run baselines AFTER that, replays A
+// (`idempotent: true`) and creates B. The plan must count only B — tallying the
+// replay too expects A's link twice and fails a correct resume.
+function tallyCreated(responses) {
+  // The reference seed's tally rule, exactly: skip a replayed create.
+  return expectedCriterionCounts(responses.filter((r) => !r.idempotent).map((r) => r.crit));
+}
+
+test('a resumed seed tallies only what THIS run created, and verifies OK', () => {
+  const baseline = { ours: 1 }; // A's link, from the first run
+  const responses = [{ crit: ['ours'], idempotent: true }, { crit: ['ours'] }];
+  const rows = [{ criterion_id: 'ours', linked_tasks: 2 }];
+  assert.deepEqual(diffCriterionLinks(tallyCreated(responses), rows, { baseline }), []);
+  // The bug the finding names: counting the replay expects 3.
+  const naive = expectedCriterionCounts(responses.map((r) => r.crit));
+  assert.deepEqual(diffCriterionLinks(naive, rows, { baseline }), [{ criterion_id: 'ours', expected: 3, actual: 2 }]);
+});
+
+test('a fully re-run seed (every create a replay) plans nothing and verifies OK', () => {
+  const responses = [{ crit: ['ours'], idempotent: true }, { crit: ['ours'], idempotent: true }];
+  assert.deepEqual(diffCriterionLinks(tallyCreated(responses), [{ criterion_id: 'ours', linked_tasks: 2 }], { baseline: { ours: 2 } }), []);
+});
+
+test('the baselined reference seed skips replays when it tallies', () => {
+  const src = readFileSync(new URL('../scripts/gds/seed-bv2-ideator-surface-tasks.js', import.meta.url), 'utf8');
+  assert.match(src, /baselineSeedCriteria\(/, 'it takes a baseline');
+  assert.match(src, /if \(!r\.json\.idempotent\) criterionIdListsPerTask\.push\(t\.crit\);/, 'and tallies only created tasks');
+});
+
+await testAsync('baselineSeedCriteria snapshots the goal before any write', async () => {
+  const logs = [];
+  const baseline = await baselineSeedCriteria({
+    goalId: 1000095, fetchGoal: goalWith(POPULATED), log: (l) => logs.push(l), exit: () => { throw new Error('should not exit'); },
+  });
+  assert.deepEqual(baseline, { 'old-1': 1, 'old-2': 9, 'old-3': 4, 'old-4': 3, 'old-5': 6, 'old-6': 10 });
+  assert.ok(logs.some((l) => l.includes('6 already carrying linked tasks')));
+});
+
+await testAsync('baselineSeedCriteria refuses to seed blind when the goal cannot be read', async () => {
+  let exitCode = null; const logs = [];
+  await baselineSeedCriteria({
+    goalId: 1000095, fetchGoal: async () => ({ ok: false, status: 401, json: null }),
+    log: (l) => logs.push(l), exit: (c) => { exitCode = c; },
+  });
+  assert.equal(exitCode, 1);
+  assert.ok(logs.some((l) => l.includes('Refusing to seed blind')));
+});
+
+await testAsync('a correct seed into a populated goal verifies OK end to end, baseline passed through', async () => {
+  const logs = []; let exitCalled = false;
+  const baseline = await baselineSeedCriteria({ goalId: 1000095, fetchGoal: goalWith(POPULATED), log: () => {} });
+  await verifySeedCriteriaLinks({
+    goalId: 1000095,
+    expectedCounts: expectedCriterionCounts([['ours'], ['ours']]),
+    baseline,
+    fetchGoal: goalWith([...POPULATED, { criterion_id: 'ours', linked_tasks: 2 }]),
+    log: (l) => logs.push(l),
+    exit: () => { exitCalled = true; },
+  });
+  assert.equal(exitCalled, false, logs.join('\n'));
+  assert.ok(logs.some((l) => l.includes('VERIFY OK') && l.includes('pre-seed count')));
+});
+
+await testAsync('without a baseline the OK line says what it did not check', async () => {
+  const logs = [];
+  await verifySeedCriteriaLinks({
+    goalId: 1000095, expectedCounts: { ours: 2 },
+    fetchGoal: goalWith([...POPULATED, { criterion_id: 'ours', linked_tasks: 2 }]),
+    log: (l) => logs.push(l), exit: () => { throw new Error('should not exit'); },
+  });
+  assert.ok(logs.some((l) => /were not checked/.test(l) && l.includes('baselineSeedCriteria')));
+});
+
 console.log(`\nseed_verify_criteria: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);