@bongos/core 1.19.1060 → 1.19.1061

package/modules/copy-desk/pages.js

@@ -215,6 +215,196 @@ function roundOpenForWriting(task) {
   return !!task && task.status === 'ready' && !blockPresence(task.description).batch;
 }
 
+// ---------------------------------------------------------------------------
+// The draft and the submit (task 1004319 / BV2.TW08, ADR 0341 D4).
+//
+// Both resolve every TARGET from the page reading (docs/page-readings.json),
+// never from the request body (ADR 0233 §7). A draft save sends only
+// { reading_hash, lines: [{ key, after }] }; the line's section, its current
+// text (`before`) and its placement are copied from the reading. The submit
+// re-resolves each draft line against the CURRENT reading, so a line the page
+// no longer shows is refused by name (`target_gone`) instead of being frozen
+// against a sentence that is not there.
+// ---------------------------------------------------------------------------
+
+// The interpolation hole the inventory writes for `${...}` (proposals.js's
+// PLACEHOLDER; restated here because this file requires nothing).
+const PLACEHOLDER = '{…}';
+// One rewritten line. The longest line any page shows today is 760 characters,
+// so 1000 leaves room to rewrite it and still bounds a draft.
+const MAX_LINE_CHARS = 1000;
+// A draft holds changed lines only, and the longest page has under 500 lines.
+const MAX_DRAFT_LINES = 1000;
+const UNPLACED_SOURCE = 'page-tweak-unplaced';
+const LINE_KEY_RE = /^L[0-9]{4,}$/;
+
+// The inventory's own whitespace rule (proposals.js tidy): a line is measured
+// and compared in the form the reading records it.
+function tidy(raw) {
+  return String(raw == null ? '' : raw).replace(/\s+/g, ' ').trim();
+}
+
+function placeholderCount(text) {
+  return String(text || '').split(PLACEHOLDER).length - 1;
+}
+
+// Replace the ONE block of a fence in a description, or append it when there is
+// none. A description carrying two is refused rather than guessed at.
+function replaceBlock(markdown, fence, block) {
+  const src = String(markdown || '');
+  const re = new RegExp('```' + fence.replace(/-/g, '\\-') + '[ \\t]*\\r?\\n[\\s\\S]*?\\r?\\n```', 'g');
+  const hits = src.match(re) || [];
+  if (hits.length > 1) return fail('multiple_blocks', { fence, count: hits.length });
+  if (hits.length === 1) return { ok: true, description: src.replace(re, () => block) };
+  return { ok: true, description: src.trimEnd() + (src.trim() ? '\n\n' : '') + block };
+}
+
+// resolveDraft({ readingPage, body, savedAt }) -> { ok, draft } | refusal
+//
+// A WHOLE-DRAFT replace: the body is every changed line the artist has, and the
+// draft becomes exactly that. A line whose `after` equals the page's current
+// text is not a change and is dropped, so only changed lines are stored (D4).
+// Placeholder arithmetic is NOT checked here: an autosave lands mid-sentence,
+// and the check belongs to the submit (and again to the applier).
+function resolveDraft({ readingPage, body, savedAt }) {
+  if (!readingPage || !Array.isArray(readingPage.lines)) return fail('reading_missing');
+  const b = body || {};
+  if (String(b.reading_hash || '') !== String(readingPage.reading_hash || '')) {
+    return fail('reading_moved', { reading_hash: readingPage.reading_hash || null, sent: b.reading_hash || null });
+  }
+  const list = Array.isArray(b.lines) ? b.lines : [];
+  if (list.length > MAX_DRAFT_LINES) return fail('too_many_lines', { max: MAX_DRAFT_LINES, was: list.length });
+  const byKey = new Map(readingPage.lines.map((l) => [l.key, l]));
+  const seen = new Set();
+  const unknown = [];
+  const tooLong = [];
+  const empty = [];
+  const out = [];
+  for (const raw of list) {
+    const key = raw && typeof raw.key === 'string' ? raw.key : '';
+    if (!LINE_KEY_RE.test(key) || typeof raw.after !== 'string') return fail('line_malformed', { line: raw == null ? null : raw });
+    if (seen.has(key)) return fail('duplicate_line', { key });
+    seen.add(key);
+    const at = byKey.get(key);
+    if (!at) { unknown.push(key); continue; }
+    const after = tidy(raw.after);
+    if (after === tidy(at.text)) continue;
+    if (!after) { empty.push(key); continue; }
+    if (after.length > MAX_LINE_CHARS) { tooLong.push(key); continue; }
+    out.push({ key, section: at.section == null ? null : at.section, before: at.text, after, placement: at.placement });
+  }
+  if (unknown.length) return fail('unknown_line', { keys: unknown });
+  if (empty.length) return fail('line_empty', { keys: empty });
+  if (tooLong.length) return fail('line_too_long', { keys: tooLong, max: MAX_LINE_CHARS });
+  // Page order, whatever order the editor sent them in.
+  const order = new Map(readingPage.lines.map((l, i) => [l.key, i]));
+  out.sort((x, y) => order.get(x.key) - order.get(y.key));
+  return { ok: true, draft: { page_id: readingPage.id, reading_hash: readingPage.reading_hash, saved_at: savedAt, lines: out } };
+}
+
+// Is a newly resolved draft the one already saved? Then the save writes
+// nothing: an autosave that changed nothing must not touch the task.
+function sameDraft(saved, next) {
+  if (!saved || !next) return false;
+  const pick = (d) => JSON.stringify([d.page_id, d.reading_hash,
+    (d.lines || []).map((l) => [l.key, l.section == null ? null : l.section, l.before, l.after, l.placement])]);
+  return pick(saved) === pick(next);
+}
+
+// Find a draft line on the CURRENT reading: the same key showing the same text,
+// else the one line showing that text in the same section, else the one line
+// showing it anywhere on the page. Anything else is gone, or too ambiguous to
+// pick for the artist.
+function locateLine(lines, draftLine) {
+  const same = (l) => l.text === draftLine.before;
+  const byKey = lines.find((l) => l.key === draftLine.key);
+  if (byKey && same(byKey)) return { line: byKey };
+  const inSection = lines.filter((l) => same(l) && l.section === draftLine.section);
+  if (inSection.length === 1) return { line: inSection[0] };
+  const anywhere = lines.filter(same);
+  if (anywhere.length === 1) return { line: anywhere[0] };
+  return { code: anywhere.length > 1 ? 'ambiguous_target' : 'target_gone' };
+}
+
+// A line the applier cannot place goes to an engineer (spec decision 7). That
+// is every `unplaced` line, and a `shared` line the registry has no row for:
+// shell text with no file behind it cannot be applied mechanically either.
+function goesToEngineer(line) {
+  return line.placement === 'unplaced' || (line.placement === 'shared' && !line.file);
+}
+
+// freezeBatch({ readingPage, draft, submittedAt }) -> { ok, batch, unplaced } | refusal
+//
+// The submit's pure half. Every draft line is re-resolved on the current
+// reading; a refused line (`target_gone`, `ambiguous_target`,
+// `placeholder_mismatch`) refuses the submit, naming each line, and nothing is
+// frozen: the artist fixes those lines and submits again. `batch` is the
+// `page-tweak` block's content without its `unplaced_tasks` (the lifecycle
+// transaction fills those in once the engineer tasks exist). `unplaced` is the
+// lines taken out of it.
+function freezeBatch({ readingPage, draft, submittedAt }) {
+  if (!readingPage || !Array.isArray(readingPage.lines)) return fail('reading_missing');
+  if (!draft || !Array.isArray(draft.lines) || !draft.lines.length) return fail('nothing_to_submit');
+  const refused = [];
+  const placed = [];
+  const unplaced = [];
+  const keys = new Set();
+  for (const d of draft.lines) {
+    const found = locateLine(readingPage.lines, d);
+    if (!found.line) { refused.push({ key: d.key, section: d.section == null ? null : d.section, before: d.before, code: found.code }); continue; }
+    const at = found.line;
+    if (keys.has(at.key)) { refused.push({ key: d.key, section: d.section == null ? null : d.section, before: d.before, code: 'ambiguous_target' }); continue; }
+    keys.add(at.key);
+    const line = { key: at.key, section: at.section == null ? null : at.section, before: at.text, after: d.after, placement: at.placement };
+    if (goesToEngineer(at)) { unplaced.push(line); continue; }
+    const want = placeholderCount(at.text);
+    const got = placeholderCount(d.after);
+    if (want !== got) { refused.push({ key: at.key, section: line.section, before: at.text, code: 'placeholder_mismatch', expected: want, got }); continue; }
+    placed.push({ ...line, file: at.file, line: at.line == null ? null : at.line, string_id: at.string_id == null ? null : at.string_id });
+  }
+  if (refused.length) return fail('lines_refused', { refused });
+  const order = new Map(readingPage.lines.map((l, i) => [l.key, i]));
+  const byOrder = (x, y) => order.get(x.key) - order.get(y.key);
+  return {
+    ok: true,
+    batch: { page_id: readingPage.id, reading_hash: readingPage.reading_hash, submitted_at: submittedAt, lines: placed.sort(byOrder) },
+    unplaced: unplaced.sort(byOrder),
+  };
+}
+
+// The engineer task an unplaced rewrite files (ADR 0341 D4): one per line,
+// keyed so a repeated submit finds the task it already filed.
+function unplacedSourceRef(roundTaskId, key) {
+  return `${UNPLACED_SOURCE}/${roundTaskId}/${key}`;
+}
+
+function clip(text, n) {
+  const s = String(text || '');
+  return s.length > n ? `${s.slice(0, n - 1)}…` : s;
+}
+
+function unplacedTaskTitle(page, line) {
+  return `Place and reword "${clip(line.before, 60)}" (${page.id})`;
+}
+
+function unplacedTaskBody(page, line, roundTaskId) {
+  const where = line.placement === 'shared'
+    ? 'It is shared shell text (it shows on every page of the surface), and the copy registry has no row for it.'
+    : 'The copy registry cannot place it: the string is built somewhere the inventory does not read (data from an API, a string assembled in code, or markup the extractors miss).';
+  return [
+    `An artist rewrote a line on **${String(page.title || page.id)}** (\`${page.id}\`${page.path ? `, ${page.path}` : ''}) that the applier cannot change mechanically, so it comes to an engineer (ADR 0341 D4, spec decision 7).`,
+    '',
+    where,
+    '',
+    `- Section: ${line.section == null ? '(none)' : line.section}`,
+    `- Line: ${line.key} in the page reading`,
+    `- It says now: ${JSON.stringify(line.before)}`,
+    `- The artist's wording: ${JSON.stringify(line.after)}`,
+    '',
+    `Find where this text is rendered and change it to the artist's wording, or make it a string the copy registry can place so the next tweak can change it directly. The page's tweak round (task ${roundTaskId}) does not wait for this.`,
+  ].join('\n');
+}
+
 module.exports = {
   SCHEMA,
   SOURCE,
@@ -235,4 +425,14 @@ module.exports = {
   parseSentBackBlocks,
   blockPresence,
   roundOpenForWriting,
+  MAX_LINE_CHARS,
+  MAX_DRAFT_LINES,
+  UNPLACED_SOURCE,
+  replaceBlock,
+  resolveDraft,
+  sameDraft,
+  freezeBatch,
+  unplacedSourceRef,
+  unplacedTaskTitle,
+  unplacedTaskBody,
 };

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;`.
@@ -841,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');