@bongos/core 1.19.1059 → 1.19.1061

package/modules/copy-desk/routes/copy-desk.js

@@ -103,6 +103,109 @@ const CLAIM_BODY_SCHEMA = Object.freeze({});
 const ASK_BODY_SCHEMA = Object.freeze({
   reason: { required: true, type: 'string', maxLength: flags.MAX_REASON_CHARS, minLength: 1 },
 });
+// The draft autosave (task 1004319 / TW08): the reading the editor was built
+// on, and every changed line as { key, after }. Nothing else, and in
+// particular no `before`, `section`, `placement` or file: every fact about a
+// target is resolved from the page reading (pages.resolveDraft).
+const DRAFT_BODY_SCHEMA = Object.freeze({
+  reading_hash: { required: true, type: 'string', maxLength: 64, minLength: 1 },
+  lines:        { required: true, type: 'array', maxItems: pages.MAX_DRAFT_LINES },
+});
+// The submit takes nothing: it freezes the draft already on the task.
+const SUBMIT_BODY_SCHEMA = Object.freeze({});
+
+// The refusals of pages.resolveDraft / freezeBatch, as HTTP statuses.
+const PAGE_REFUSAL_STATUS = Object.freeze({
+  reading_missing: 503,
+  reading_moved: 409,
+  lines_refused: 409,
+  nothing_to_submit: 409,
+  multiple_blocks: 409,
+  block_unreadable: 409,
+  block_schema_unknown: 409,
+  block_field_missing: 409,
+  wrong_page: 409,
+});
+const PAGE_REFUSAL_MEANS = Object.freeze({
+  reading_moved: 'The page changed since the editor loaded it, so a line key may now mean a different line. Reload the page to get the current reading; nothing was saved.',
+  unknown_line: 'The page reading has no line with that key. Reload the editor.',
+  line_empty: 'A line cannot be rewritten to nothing. Removing text from a page is a code change; leave the line as it is or give it new words.',
+  line_too_long: `A line holds at most ${pages.MAX_LINE_CHARS} characters.`,
+  lines_refused: 'Some lines cannot be frozen as written: the page no longer shows them (target_gone), shows the same words in more than one place (ambiguous_target), or the rewrite dropped or added a {…} hole (placeholder_mismatch). Fix or remove each named line and submit again; nothing was submitted.',
+  nothing_to_submit: 'The draft has no rewritten lines yet.',
+});
+
+function refusePage(res, r) {
+  const status = PAGE_REFUSAL_STATUS[r.code] || 400;
+  const means = PAGE_REFUSAL_MEANS[r.code];
+  return res.fail(r.code, status, { ...(r.detail || {}), ...(means ? { what_this_means: means } : {}) });
+}
+
+// The page's reading, which every draft and batch target comes from. Returns
+// null when it has already responded.
+function readingPageOrFail(res, pageId) {
+  const readings = readingsState();
+  if (!readings.data) {
+    res.fail('readings_missing', 503, {
+      run: readings.info.run || 'node scripts/gds/page-reader.js',
+      what_this_means: 'A draft is resolved against the committed page readings, and this instance has none. Nothing was saved.',
+    });
+    return null;
+  }
+  const readingPage = (readings.data.pages || []).find((p) => p && p.id === pageId);
+  if (!readingPage) {
+    res.fail('page_unread', 503, {
+      page_id: pageId,
+      what_this_means: 'The page readings do not include this page yet, so there are no lines to resolve a draft against.',
+    });
+    return null;
+  }
+  return readingPage;
+}
+
+// The page's OPEN round, from the same read the page routes use.
+function openRoundOf(tasks, pageId) {
+  const open = (tasks || []).filter((t) => {
+    const ref = pages.parseRoundRef(t.source_ref);
+    return ref && ref.page_id === pageId && t.status !== 'shipped' && t.status !== 'abandoned';
+  });
+  return open.length ? open[open.length - 1] : null;
+}
+
+// The answer to a repeated submit: the round is in the queue (ready, a frozen
+// batch, nobody holding it) and the caller is its artist, the builder of its
+// latest web claim. Null when that is not the case.
+function alreadySubmitted(round, builderId, pageId) {
+  if (round.holder_id != null || round.status !== 'ready' || String(round.artist_id) !== String(builderId)) return null;
+  const b = pages.parseBatchBlock(round.description);
+  if (!b.ok) return null;
+  return {
+    ok: true, outcome: 'already_submitted', page_id: pageId,
+    round: { task_id: String(round.id), state: 'submitted', status: 'ready' },
+    batch: { line_count: b.batch.lines.length, submitted_at: b.batch.submitted_at, reading_hash: b.batch.reading_hash },
+    unplaced_tasks: (b.batch.unplaced_tasks || []).map((id) => ({ task_id: String(id) })),
+    next: { path: '/copy-desk/next' },
+  };
+}
+
+// The port's not_held outcome, as the answer the editor shows.
+function refuseNotHeld(res, pageId, r, round) {
+  // Nobody holds it and its batch is frozen: it is in the /tweak queue.
+  if (!r.holder && round && pages.blockPresence(round.description).batch) {
+    return res.fail('page_in_flight', 409, {
+      page_id: pageId,
+      what_this_means: 'This page has been submitted and is on its way to the site. Its draft is frozen until it ships or is sent back.',
+    });
+  }
+  const who = r.holder ? (r.holder.name || r.holder.login || 'Another builder') : null;
+  return res.fail('page_not_held', 409, {
+    page_id: pageId,
+    holder: r.holder ? { id: r.holder.id, login: r.holder.login, name: r.holder.name } : null,
+    what_this_means: who
+      ? `${who} holds this page now, so only they can change its draft.`
+      : 'You do not hold this page. Claim it again (POST /copy-desk/pages/:pageId/claim) and the draft is still there.',
+  });
+}
 
 // Load the registry or answer the named "no registry" state. Returns null when
 // it has already responded, so every handler is `if (!reg) return;`.
@@ -663,6 +766,47 @@ module.exports = function buildCopyDeskRouter() {
     }
   });
 
+  // -------------------------------------------------------------------------
+  // GET /copy-desk/next — the Tweak/CopyWrite Flow's recommendation (task
+  // 1004318 / BV2.TW07, ADR 0341 D8): the page the caller should tweak next
+  // and why ("2 people asked for it"), plus the next few for "pick another".
+  //
+  // Order: asked for (most distinct askers, then the oldest ask), then changed
+  // since the last tweak (most changed lines), then untweaked (landing,
+  // builders, status, then inventory order); tweaked pages with no drift last.
+  // A page another builder holds, or whose round is in flight, is never
+  // recommended (it is listed in `skipped`). The caller's own held page is
+  // `resume`, not a recommendation.
+  //
+  // "Take next" is POST /copy-desk/pages/:pageId/claim on `recommended.page_id`
+  // (each candidate carries its `take`), one call. The availability rule here
+  // is the claim's own, so that call is not refused for a reason this read knew.
+  //
+  // rank: any signed-in builder. The read is the caller's own and needs no
+  // craft; the claim it points at is where the artist gate lives.
+  // -------------------------------------------------------------------------
+  router.get('/copy-desk/next', api.requireBuilder, async (req, res) => {
+    try {
+      const inv = inventoryOrFail(res);
+      if (!inv) return;
+      const lifecycle = pageReadsOrFail(res);
+      if (!lifecycle) return;
+      const readings = readingsState();
+      const [tasks, asks] = await Promise.all([
+        lifecycle.listPageTweakTasks(),
+        flags.pageAskSummary(),
+      ]);
+      const out = pageStatus.composeNext({ inventory: inv.data, readings: readings.data, tasks, asks, builderId: req.builder.id });
+      out.inventory = { at: inv.at };
+      out.readings = readings.info;
+      res.set('Cache-Control', 'no-store');
+      res.json(out);
+    } catch (err) {
+      log.error({ err }, 'GET /copy-desk/next failed');
+      if (!res.headersSent) res.fail('copy_next_failed', 500);
+    }
+  });
+
   // -------------------------------------------------------------------------
   // POST /copy-desk/pages/:pageId/claim — claim a page's tweak (task 1004317 /
   // BV2.TW06, ADR 0341 D2 and D5). Also Resume and "Take next".
@@ -800,6 +944,211 @@ module.exports = function buildCopyDeskRouter() {
     }
   });
 
+  // -------------------------------------------------------------------------
+  // PUT /copy-desk/pages/:pageId/draft — autosave the artist's draft (task
+  // 1004319 / BV2.TW08, ADR 0341 D4).
+  //
+  // Body: { reading_hash, lines: [{ key, after }] }, the WHOLE draft: every line
+  // the artist has changed. The saved draft becomes exactly that (a line sent
+  // back at its current text is dropped, so only changed lines are stored).
+  // rank: any signed-in builder; only the HOLDER of the page's writing claim
+  //       (the web claim the page claim took) may save, checked in the
+  //       lifecycle transaction.
+  //
+  // Every target is resolved from the page reading by key: section, current
+  // text (`before`) and placement are the reading's, never the body's. A body
+  // built on an older reading is refused `reading_moved`, whole, since its keys
+  // may now mean other lines.
+  //
+  // Cheap and idempotent: a save that resolves to the draft already stored
+  // writes nothing (200 `unchanged`; `updated_at` does not move). The editor
+  // debounces; the server only has to make a repeated save free.
+  //
+  //   200 saved | unchanged   with the draft and "N of M rewritten"
+  //   409 page_not_held       the caller does not hold the page (holder named)
+  //   409 no_open_round       the page has no round: claim it first
+  //   409 reading_moved · 400 unknown_line / line_empty / line_too_long
+  // -------------------------------------------------------------------------
+  router.put('/copy-desk/pages/:pageId/draft', api.requireBuilder, async (req, res) => {
+    try {
+      if (validateOrRespond(req, res, DRAFT_BODY_SCHEMA)) return;
+      const found = pageOrFail(req, res);
+      if (!found) return;
+      const { pageId } = found;
+      const lifecycle = pageReadsOrFail(res);
+      if (!lifecycle) return;
+      if (typeof lifecycle.updateHeldTaskDescription !== 'function') {
+        return res.fail('lifecycle_unavailable', 503, { what_this_means: 'This instance cannot save a page draft. Nothing was saved.' });
+      }
+      const readingPage = readingPageOrFail(res, pageId);
+      if (!readingPage) return;
+
+      const resolved = pages.resolveDraft({ readingPage, body: req.body, savedAt: new Date().toISOString() });
+      if (!resolved.ok) return refusePage(res, resolved);
+
+      const round = openRoundOf(await lifecycle.listPageTweakTasks({ pageId }), pageId);
+      if (!round) {
+        return res.fail('no_open_round', 409, {
+          page_id: pageId,
+          what_this_means: 'Nobody is writing this page. Claim it first (POST /copy-desk/pages/:pageId/claim).',
+        });
+      }
+
+      let draft = resolved.draft;
+      const r = await lifecycle.updateHeldTaskDescription({
+        taskId: round.id,
+        builderId: req.builder.id,
+        source: pages.SOURCE,
+        compose: (task) => {
+          const prev = pages.parseDraftBlock(task.description);
+          // The same draft again: keep the stored block, saved_at included.
+          if (prev.ok && pages.sameDraft(prev.draft, resolved.draft)) {
+            draft = prev.draft;
+            return { ok: true, description: task.description };
+          }
+          // No draft yet and nothing changed: there is nothing to store.
+          if (prev.code === 'no_block' && !resolved.draft.lines.length) return { ok: true, description: task.description };
+          return pages.replaceBlock(task.description, pages.FENCES.draft, pages.composeDraftBlock(resolved.draft));
+        },
+      });
+      switch (r.outcome) {
+        case 'saved':
+        case 'unchanged':
+          return res.json({
+            ok: true,
+            outcome: r.outcome,
+            page_id: pageId,
+            round: { task_id: String(round.id), state: 'writing' },
+            draft: { reading_hash: draft.reading_hash, saved_at: draft.saved_at, lines: draft.lines },
+            // The editor's counter, "N of M rewritten · saved" (Editor.dc.html).
+            counter: { changed: draft.lines.length, total: readingPage.lines.length },
+          });
+        case 'not_held':
+          return refuseNotHeld(res, pageId, r, round);
+        case 'refused':
+          return refusePage(res, r.refusal);
+        default:
+          throw new Error(`updateHeldTaskDescription: unexpected outcome ${r.outcome}`);
+      }
+    } catch (err) {
+      log.error({ err }, 'PUT /copy-desk/pages/:pageId/draft failed');
+      if (!res.headersSent) res.fail('copy_page_draft_failed', 500);
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // POST /copy-desk/pages/:pageId/submit — freeze the draft and queue the page
+  // for /tweak (task 1004319 / BV2.TW08, ADR 0341 D4, D7).
+  //
+  // Body: {} (it freezes the draft already on the task; nothing is taken from
+  //       the request). rank: any signed-in builder; the holder only.
+  //
+  // One lifecycle transaction:
+  //   * every draft line is re-resolved on the CURRENT page reading; a line the
+  //     page no longer shows is refused by name (target_gone), as are an
+  //     ambiguous one and a {…} hole added or dropped. Any refusal refuses the
+  //     submit, listing the lines, and nothing is frozen;
+  //   * a rewrite of an UNPLACED line (and of shared shell text with no
+  //     registry row) leaves the batch and files its own engineer task
+  //     (source page-tweak-unplaced, backlog), carrying the page, the line and
+  //     the wording. The page does not wait for it;
+  //   * the rest is frozen into the `page-tweak` block with each line's file,
+  //     line and string id from the reading, naming the engineer tasks;
+  //   * the artist's web claim is released and the task goes back to `ready`:
+  //     the round reads `submitted`, the /tweak queue.
+  //
+  //   200 submitted            with the batch, the engineer tasks, and where
+  //                            "next up" reads (GET /copy-desk/next)
+  //   200 already_submitted    a repeated submit by the round's artist
+  //   409 lines_refused · nothing_to_submit · page_not_held · no_open_round
+  // -------------------------------------------------------------------------
+  router.post('/copy-desk/pages/:pageId/submit', api.requireBuilder, async (req, res) => {
+    try {
+      if (validateOrRespond(req, res, SUBMIT_BODY_SCHEMA)) return;
+      const found = pageOrFail(req, res);
+      if (!found) return;
+      const { page, pageId } = found;
+      const lifecycle = pageReadsOrFail(res);
+      if (!lifecycle) return;
+      if (typeof lifecycle.submitPageTweak !== 'function') {
+        return res.fail('lifecycle_unavailable', 503, { what_this_means: 'This instance cannot submit a page. Nothing was submitted.' });
+      }
+      const readingPage = readingPageOrFail(res, pageId);
+      if (!readingPage) return;
+
+      const round = openRoundOf(await lifecycle.listPageTweakTasks({ pageId }), pageId);
+      if (!round) {
+        return res.fail('no_open_round', 409, {
+          page_id: pageId,
+          what_this_means: 'Nobody is writing this page. Claim it first (POST /copy-desk/pages/:pageId/claim).',
+        });
+      }
+      // A double-click: the round's own artist submitting what is already in
+      // the queue gets the same answer, not a refusal.
+      const again = alreadySubmitted(round, req.builder.id, pageId);
+      if (again) return res.json(again);
+
+      const building = proposals.resolveTargetVersion(await lifecycle.listVersions());
+      const submittedAt = new Date().toISOString();
+      let frozen = null;
+      const r = await lifecycle.submitPageTweak({
+        taskId: round.id,
+        builderId: req.builder.id,
+        versionId: building ? building.id : null,
+        freeze: (task) => {
+          const d = pages.parseDraftBlock(task.description);
+          if (!d.ok) return d.code === 'no_block' ? { ok: false, code: 'nothing_to_submit', detail: {} } : d;
+          if (d.draft.page_id !== pageId) return { ok: false, code: 'wrong_page', detail: { page_id: pageId, draft_page_id: d.draft.page_id } };
+          const f = pages.freezeBatch({ readingPage, draft: d.draft, submittedAt });
+          if (!f.ok) return f;
+          const probe = pages.replaceBlock(task.description, pages.FENCES.batch, '');
+          if (!probe.ok) return probe;
+          frozen = f;
+          return {
+            ok: true,
+            unplaced: f.unplaced.map((l) => ({
+              key: l.key,
+              source: pages.UNPLACED_SOURCE,
+              sourceRef: pages.unplacedSourceRef(task.id, l.key),
+              title: pages.unplacedTaskTitle(page, l),
+              description: pages.unplacedTaskBody(page, l, task.id),
+              touches: Array.isArray(page.files) ? page.files : [],
+            })),
+            description: (ids) => pages.replaceBlock(task.description, pages.FENCES.batch,
+              pages.composeBatchBlock({ ...f.batch, unplaced_tasks: ids })).description,
+          };
+        },
+      });
+      switch (r.outcome) {
+        case 'submitted':
+          return res.json({
+            ok: true, outcome: 'submitted', page_id: pageId,
+            round: { task_id: String(r.task.id), state: 'submitted', status: r.task.status },
+            batch: { line_count: frozen.batch.lines.length, submitted_at: submittedAt, reading_hash: frozen.batch.reading_hash },
+            unplaced_tasks: r.unplaced_tasks.map((u) => ({ task_id: u.id, key: u.key, created: u.created })),
+            // "Next up" (the editor's closing card) reads the recommendation.
+            next: { path: '/copy-desk/next' },
+          });
+        case 'not_held': {
+          // A second submit that raced the first waits on the task's row
+          // lock and then finds the claim released: read the round again,
+          // and if the first froze it, this is the same double-click.
+          const now = openRoundOf(await lifecycle.listPageTweakTasks({ pageId }), pageId);
+          const same = now && alreadySubmitted(now, req.builder.id, pageId);
+          if (same) return res.json(same);
+          return refuseNotHeld(res, pageId, r, now || round);
+        }
+        case 'refused':
+          return refusePage(res, r.refusal);
+        default:
+          throw new Error(`submitPageTweak: unexpected outcome ${r.outcome}`);
+      }
+    } catch (err) {
+      log.error({ err }, 'POST /copy-desk/pages/:pageId/submit failed');
+      if (!res.headersSent) res.fail('copy_page_submit_failed', 500);
+    }
+  });
+
   return router;
 };
 

package/modules/copy-desk/tests/copy_no_cms.mjs

@@ -21,7 +21,8 @@
 // which no renderer reads — and the wording reaches a person only after somebody
 // claims that task and ships the diff. So the four things pinned here are:
 //
-//   * the write surface is EXACTLY the three verbs the module defines,
+//   * the write surface is EXACTLY the verbs the module defines (seven since
+//     TW08: the page draft and submit write the round TASK, never a row),
 //   * no column on copy_desk_flags could hold replacement text,
 //   * nothing in this module writes a file, and
 //   * the ONLY thing that writes a surface file is the applier, it lives outside
@@ -80,7 +81,13 @@ await test('the write surface is exactly the verbs the module defines', () => {
     // flag row whose target is a page id. Neither stores wording.
     'POST /copy-desk/pages/:pageId/asks',
     'POST /copy-desk/pages/:pageId/claim',
+    // TW08 (task 1004319, ADR 0341 D4, D11): the draft autosave and the
+    // submit. Both write the page round's TASK DESCRIPTION through the
+    // lifecycle port, the place ADR 0233 lets wording rest; neither writes a
+    // row here, a file, or anything a renderer reads.
+    'POST /copy-desk/pages/:pageId/submit',
     'POST /copy-desk/proposals',
+    'PUT /copy-desk/pages/:pageId/draft',
   ], 'a new write route on this module must be a deliberate, reviewed change to this list');
 });
 
@@ -185,6 +192,34 @@ await test('the page claim creates a TASK through the port and writes no row her
   assert.ok(/roundTaskBody\(page, n\)/.test(claim), 'the round body comes from pages.roundTaskBody over the inventory page');
 });
 
+await test('the draft and the submit write only the round task, through the port, with targets from the reading', () => {
+  const src = stripComments(read('routes/copy-desk.js'));
+  const handler = (verb, p) => {
+    const start = src.indexOf(`router.${verb}('${p}'`);
+    assert.ok(start >= 0, `${verb.toUpperCase()} ${p} is mounted`);
+    const next = src.indexOf('router.', start + 1);
+    return src.slice(start, next === -1 ? undefined : next);
+  };
+  const draft = handler('put', '/copy-desk/pages/:pageId/draft');
+  const submit = handler('post', '/copy-desk/pages/:pageId/submit');
+  assert.ok(/lifecycle\.updateHeldTaskDescription\(/.test(draft), 'the draft lands on the task via the lifecycle port');
+  assert.ok(/lifecycle\.submitPageTweak\(/.test(submit), 'the submit lands on the task via the lifecycle port');
+  for (const [name, h] of [['draft', draft], ['submit', submit]]) {
+    assert.equal(/insertFlag|closeFlag|INSERT INTO|UPDATE /i.test(h), false, `the ${name} route must write no row in this module`);
+    // Every target fact is the reading's. A handler reading `before`, a
+    // section, a placement or a file from the body would let a caller describe
+    // an edit to a sentence the page does not show.
+    assert.equal(/req\.body\.(before|section|placement|file|line|string_id|text)\b/.test(h), false,
+      `the ${name} route must not take a target from the request body`);
+    assert.ok(/readingPageOrFail\(res, pageId\)/.test(h), `the ${name} route resolves against the page reading`);
+  }
+  assert.ok(/pages\.resolveDraft\(\{ readingPage,/.test(draft), 'the draft is resolved from the reading by pages.resolveDraft');
+  assert.ok(/pages\.freezeBatch\(\{ readingPage,/.test(submit), 'the batch is frozen from the reading by pages.freezeBatch');
+  // The body schemas carry no target field.
+  const schemas = src.slice(src.indexOf('const DRAFT_BODY_SCHEMA'), src.indexOf('const PAGE_REFUSAL_STATUS'));
+  assert.equal(/\b(before|section|placement|file|string_id)\s*:/.test(schemas), false, 'the draft and submit schemas name no target field');
+});
+
 await test('the module manifest declares no seam another module could write copy through', () => {
   const manifest = JSON.parse(read('module.json'));
   assert.deepEqual(manifest.provides, [], 'a provided port here would be a copy write path for every other module');

package/modules/copy-desk/tests/copy_page_draft.mjs

@@ -0,0 +1,202 @@
+// modules/copy-desk/tests/copy_page_draft.mjs — the page draft and the frozen
+// batch, pure (task 1004319 / BV2.TW08, ADR 0341 D4).
+//
+// What the resolvers in pages.js must do before any route or transaction is
+// involved: a draft save resolves every target from the page reading and keeps
+// only changed lines; the same draft again is recognised as the same; the
+// submit re-resolves each line on the CURRENT reading, refuses by name the
+// lines it cannot place, and splits the unplaced rewrites out for an engineer.
+//
+// The whole path (routes, the lifecycle transaction, the engineer tasks, the
+// released claim) is tests/copy_desk_page_submit.mjs (root).
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const pages = require('../pages.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.stack || err.message}`); }
+}
+
+// A page reading in the shape page-reader.js writes: placed lines carry their
+// registry row, a shared line may or may not have one, an unplaced line none.
+const L = (key, section, text, placement, row) => ({ key, section, text, placement, ...(row || {}) });
+const READING = {
+  id: 'landing:index',
+  reading_hash: 'h-now',
+  lines: [
+    L('L0001', 'skip link', 'Skip to content', 'shared', { file: 'shell.js', line: 7, string_id: 'aaa111' }),
+    L('L0002', 'top bar', 'Ctrl K', 'shared'),
+    L('L0003', 'hero', 'Build here', 'placed', { file: 'index.html', line: 12, string_id: 'bbb222' }),
+    L('L0004', 'hero', '{…} of {…} shipped', 'placed', { file: 'index.js', line: 40, string_id: 'ccc333' }),
+    L('L0005', 'hero', 'Cloud Bongos: Building Digitally', 'unplaced'),
+    L('L0006', 'footer', 'Resume', 'placed', { file: 'index.html', line: 90, string_id: 'ddd444' }),
+  ],
+};
+const SAVED_AT = '2026-09-28T10:00:00.000Z';
+const body = (lines, hash = 'h-now') => ({ reading_hash: hash, lines });
+
+console.log('copy-desk: the page draft and the frozen batch');
+
+test('a draft resolves every target from the reading and keeps only changed lines, in page order', () => {
+  const r = pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([
+    { key: 'L0006', after: 'Pick up where you left off' },
+    { key: 'L0003', after: '  Build   it here ' },
+    { key: 'L0001', after: 'Skip to content' }, // unchanged: dropped
+  ]) });
+  assert.equal(r.ok, true, JSON.stringify(r));
+  assert.deepEqual(r.draft, {
+    page_id: 'landing:index', reading_hash: 'h-now', saved_at: SAVED_AT,
+    lines: [
+      { key: 'L0003', section: 'hero', before: 'Build here', after: 'Build it here', placement: 'placed' },
+      { key: 'L0006', section: 'footer', before: 'Resume', after: 'Pick up where you left off', placement: 'placed' },
+    ],
+  });
+});
+
+test('a draft body cannot describe its own target: before, section and placement are ignored', () => {
+  const r = pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([
+    { key: 'L0003', after: 'New words', before: 'A sentence the page does not show', section: 'x', placement: 'unplaced' },
+  ]) });
+  assert.equal(r.ok, true);
+  assert.deepEqual([r.draft.lines[0].before, r.draft.lines[0].section, r.draft.lines[0].placement], ['Build here', 'hero', 'placed']);
+});
+
+test('a draft built on another reading is refused whole, reading_moved, naming the current hash', () => {
+  const r = pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([{ key: 'L0003', after: 'x y' }], 'h-old') });
+  assert.equal(r.ok, false);
+  assert.equal(r.code, 'reading_moved');
+  assert.deepEqual(r.detail, { reading_hash: 'h-now', sent: 'h-old' });
+});
+
+test('the draft refusals are named: unknown line, empty line, too long, duplicate, malformed, no reading', () => {
+  const code = (lines) => pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body(lines) }).code;
+  assert.equal(code([{ key: 'L0099', after: 'x' }]), 'unknown_line');
+  assert.equal(code([{ key: 'L0003', after: '   ' }]), 'line_empty');
+  assert.equal(code([{ key: 'L0003', after: 'x'.repeat(pages.MAX_LINE_CHARS + 1) }]), 'line_too_long');
+  assert.equal(code([{ key: 'L0003', after: 'a' }, { key: 'L0003', after: 'b' }]), 'duplicate_line');
+  assert.equal(code([{ key: 'nope', after: 'a' }]), 'line_malformed');
+  assert.equal(code([{ key: 'L0003' }]), 'line_malformed');
+  assert.equal(pages.resolveDraft({ readingPage: null, body: body([]) }).code, 'reading_missing');
+});
+
+test('an autosave mid-sentence is accepted: the placeholder arithmetic waits for the submit', () => {
+  const r = pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([{ key: 'L0004', after: 'shipped so far' }]) });
+  assert.equal(r.ok, true);
+});
+
+test('sameDraft ignores saved_at, so an unchanged autosave is recognised', () => {
+  const a = pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([{ key: 'L0003', after: 'Build it here' }]) }).draft;
+  const b = pages.resolveDraft({ readingPage: READING, savedAt: '2026-09-28T11:00:00.000Z', body: body([{ key: 'L0003', after: 'Build it here' }]) }).draft;
+  const c = pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([{ key: 'L0003', after: 'Build it there' }]) }).draft;
+  assert.equal(pages.sameDraft(a, b), true);
+  assert.equal(pages.sameDraft(a, c), false);
+  // Round-trips through the block: what is stored is what is compared.
+  const parsed = pages.parseDraftBlock(pages.composeDraftBlock(a));
+  assert.equal(parsed.ok, true);
+  assert.equal(pages.sameDraft(parsed.draft, b), true);
+});
+
+test('replaceBlock replaces the one draft in place, appends when there is none, refuses two', () => {
+  const intro = 'Page tweak round 1.';
+  const d1 = pages.composeDraftBlock({ page_id: 'landing:index', reading_hash: 'h', saved_at: 'a', lines: [] });
+  const d2 = pages.composeDraftBlock({ page_id: 'landing:index', reading_hash: 'h', saved_at: 'b', lines: [] });
+  const first = pages.replaceBlock(intro, pages.FENCES.draft, d1);
+  assert.equal(first.description, `${intro}\n\n${d1}`);
+  const second = pages.replaceBlock(first.description, pages.FENCES.draft, d2);
+  assert.equal(second.description, `${intro}\n\n${d2}`);
+  // The batch fence is a prefix of the draft fence: replacing the batch must
+  // not touch the draft.
+  const batch = pages.composeBatchBlock({ page_id: 'landing:index', reading_hash: 'h', submitted_at: 's', lines: [] });
+  const both = pages.replaceBlock(second.description, pages.FENCES.batch, batch).description;
+  assert.ok(both.includes(d2) && both.includes(batch));
+  assert.equal(pages.parseDraftBlock(both).ok, true);
+  assert.equal(pages.parseBatchBlock(both).ok, true);
+  assert.equal(pages.replaceBlock(`${d1}\n\n${d2}`, pages.FENCES.draft, d1).code, 'multiple_blocks');
+});
+
+const draftOf = (lines) => pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body(lines) }).draft;
+
+test('the submit freezes placed and shared lines with their registry rows, and splits the unplaced out', () => {
+  const draft = draftOf([
+    { key: 'L0001', after: 'Jump to the page' },
+    { key: 'L0002', after: 'Control K' },
+    { key: 'L0003', after: 'Build it here' },
+    { key: 'L0005', after: 'Cloud Bongos: build it with us' },
+  ]);
+  const f = pages.freezeBatch({ readingPage: READING, draft, submittedAt: 'S' });
+  assert.equal(f.ok, true, JSON.stringify(f));
+  assert.deepEqual(f.batch.lines.map((l) => [l.key, l.placement, l.file, l.line, l.string_id, l.after]), [
+    ['L0001', 'shared', 'shell.js', 7, 'aaa111', 'Jump to the page'],
+    ['L0003', 'placed', 'index.html', 12, 'bbb222', 'Build it here'],
+  ]);
+  // Unplaced text, and shared shell text the registry has no row for, go to an engineer.
+  assert.deepEqual(f.unplaced.map((l) => [l.key, l.placement, l.before, l.after]), [
+    ['L0002', 'shared', 'Ctrl K', 'Control K'],
+    ['L0005', 'unplaced', 'Cloud Bongos: Building Digitally', 'Cloud Bongos: build it with us'],
+  ]);
+  assert.equal(f.batch.reading_hash, 'h-now');
+  assert.equal(f.batch.submitted_at, 'S');
+});
+
+test('a line the page no longer shows is refused target_gone, by name, and nothing is frozen', () => {
+  const draft = draftOf([{ key: 'L0003', after: 'Build it here' }, { key: 'L0006', after: 'Carry on' }]);
+  const moved = { ...READING, reading_hash: 'h-next', lines: READING.lines.filter((l) => l.key !== 'L0003') };
+  const f = pages.freezeBatch({ readingPage: moved, draft, submittedAt: 'S' });
+  assert.equal(f.ok, false);
+  assert.equal(f.code, 'lines_refused');
+  assert.deepEqual(f.detail.refused, [{ key: 'L0003', section: 'hero', before: 'Build here', code: 'target_gone' }]);
+});
+
+test('a line that moved to another key is found by its words, and frozen under its new key', () => {
+  const draft = draftOf([{ key: 'L0006', after: 'Carry on' }]);
+  const shifted = { ...READING, reading_hash: 'h-next', lines: [
+    L('L0001', 'skip link', 'Skip to content', 'shared', { file: 'shell.js', line: 7, string_id: 'aaa111' }),
+    L('L0002', 'hero', 'A new line above', 'placed', { file: 'index.html', line: 5, string_id: 'eee555' }),
+    L('L0007', 'footer', 'Resume', 'placed', { file: 'index.html', line: 91, string_id: 'ddd444' }),
+  ] };
+  const f = pages.freezeBatch({ readingPage: shifted, draft, submittedAt: 'S' });
+  assert.equal(f.ok, true, JSON.stringify(f));
+  assert.deepEqual([f.batch.lines[0].key, f.batch.lines[0].line, f.batch.reading_hash], ['L0007', 91, 'h-next']);
+});
+
+test('the same words in two places on a moved page are ambiguous_target, never a guess', () => {
+  const draft = draftOf([{ key: 'L0006', after: 'Carry on' }]);
+  const twice = { ...READING, lines: [
+    L('L0001', 'a', 'Resume', 'placed', { file: 'x', line: 1, string_id: 's1' }),
+    L('L0002', 'b', 'Resume', 'placed', { file: 'x', line: 2, string_id: 's1' }),
+  ] };
+  const f = pages.freezeBatch({ readingPage: twice, draft, submittedAt: 'S' });
+  assert.deepEqual(f.detail.refused.map((x) => x.code), ['ambiguous_target']);
+});
+
+test('the placeholder arithmetic is checked per line at submit', () => {
+  const bad = pages.freezeBatch({ readingPage: READING, draft: draftOf([{ key: 'L0004', after: 'shipped so far' }]), submittedAt: 'S' });
+  assert.deepEqual(bad.detail.refused, [{ key: 'L0004', section: 'hero', before: '{…} of {…} shipped', code: 'placeholder_mismatch', expected: 2, got: 0 }]);
+  const moved = pages.freezeBatch({ readingPage: READING, draft: draftOf([{ key: 'L0004', after: '{…} shipped, of {…}' }]), submittedAt: 'S' });
+  assert.equal(moved.ok, true, 'a hole may MOVE within the sentence');
+});
+
+test('an empty draft is nothing_to_submit', () => {
+  assert.equal(pages.freezeBatch({ readingPage: READING, draft: draftOf([]), submittedAt: 'S' }).code, 'nothing_to_submit');
+  assert.equal(pages.freezeBatch({ readingPage: READING, draft: null, submittedAt: 'S' }).code, 'nothing_to_submit');
+});
+
+test('the engineer task carries the page, the line and the wording, keyed per round and line', () => {
+  const page = { id: 'landing:index', title: 'Home', path: '/' };
+  const line = { key: 'L0005', section: 'hero', before: 'Cloud Bongos: Building Digitally', after: 'Cloud Bongos: build it with us', placement: 'unplaced' };
+  assert.equal(pages.unplacedSourceRef('5001', 'L0005'), 'page-tweak-unplaced/5001/L0005');
+  assert.equal(pages.unplacedTaskTitle(page, line), 'Place and reword "Cloud Bongos: Building Digitally" (landing:index)');
+  const b = pages.unplacedTaskBody(page, line, '5001');
+  for (const want of ['landing:index', 'Home', 'L0005', 'hero', '"Cloud Bongos: Building Digitally"', '"Cloud Bongos: build it with us"', 'task 5001', 'does not wait']) {
+    assert.ok(b.includes(want), `the body names ${want}`);
+  }
+});
+
+console.log(`\ncopy_page_draft: ${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);