@bongos/core 1.21.106 → 1.21.108

package/modules/hall-ui/public/paintbrush.js

@@ -13,6 +13,14 @@
 // Owner, 2026-10-04: the edits are REAL wording changes (the page-tweak path),
 // kept apart from the palette's feedback docs.
 //
+// Owner, 2026-10-09 (task 1004696): an artist can also recommend REMOVING a
+// line ("Remove this line" on the line they are in, or by emptying it). A
+// removal is saved as { key, remove: true } and, being a code change, goes to
+// an engineer when the page is sent. And the artist review (the palette's
+// sheet, page-notes.js) is one press away while editing and again once the
+// words are sent, so the words and the look are reviewed in one sitting. This
+// file only opens that sheet; it still never writes a feedback doc itself.
+//
 // Taking the page is the copy desk's claim: artists only, one at a time, and
 // the page shows as being tweaked while it is held. The walls are the server's
 // (modules/copy-desk); this file only draws. A word the page fills in for
@@ -23,6 +31,8 @@
   var API = '/api/bongos/copy-desk/pages/';
   var SAVE_MS = 700;
   var HOLE = '{…}';
+  // The artist review's own words for itself (page-notes.js), on the button that opens it.
+  var NOTES_TITLE = 'Write what this page should look like; each point becomes an idea';
   // Never made editable: form controls, code, drawings, and the hall's own chrome.
   var SKIP = 'script, style, svg, textarea, input, select, option, button, code, pre, [contenteditable="false"], #paintbrush';
   var SCRIPT_V = (function () {
@@ -40,6 +50,7 @@
   }
   function tidy(s) { return String(s == null ? '' : s).replace(/\s+/g, ' ').trim(); }
   function plural(n, one, many) { return n + ' ' + (n === 1 ? one : many); }
+  function clip(s, n) { s = tidy(s); return s.length > n ? s.slice(0, n - 1) + '…' : s; }
   // The page's id in the readings (docs/page-readings.json): builders:<data-page>.
   function pageId() {
     var b = document.body || { dataset: {} };
@@ -109,16 +120,32 @@
         '<button class="pb__btn pb__btn--go" type="button" data-pb-take data-pb-focus>Take this page</button>' +
       '</div>';
   }
+  // The line the artist is in, and what can be done with it: remove it, or keep
+  // a removed one after all. Nothing until a line has been clicked or focused.
+  function currentHtml() {
+    var line = st.current ? lineOf(st.current) : null;
+    if (!line) return '';
+    var gone = removed(line);
+    return '<div class="pb__current">' +
+      '<span class="pb__current-words">' + (gone ? '<span class="pb__tag">Remove</span> ' : '') + esc(clip(line.text, 70)) + '</span>' +
+      (gone
+        ? '<button class="pb__btn pb__btn--quiet" type="button" data-pb-keep>Keep this line</button>'
+        : '<button class="pb__btn pb__btn--quiet" type="button" data-pb-remove>Remove this line</button>') +
+    '</div>';
+  }
   function editingHtml() {
     var changed = changes().length;
     var save = st.save === 'saving' ? 'saving…' : st.save === 'failed' ? 'not saved' : 'saved';
     var rest = st.unreached;
     return '<p class="pb__line" aria-live="polite"><strong>' + esc(plural(changed, 'change', 'changes')) + '</strong> · ' + esc(save) +
       (st.error ? ' · <span class="pb__error-inline">' + esc(st.error) + '</span>' : '') + '</p>' +
-      '<p class="pb__hint">Click any underlined words and type over them.' +
+      '<p class="pb__hint">Click any underlined words and type over them, or remove a line the page does not need.' +
         (rest ? ' ' + esc(plural(rest, 'other line', 'other lines')) + ' of this page ' + (rest === 1 ? 'is' : 'are') + ' in the <a href="' + esc(editorHref(st.id)) + '">tweak editor</a>.' : '') + '</p>' +
+      currentHtml() +
+      '<p class="pb__error" role="alert">' + esc(st.notesError || '') + '</p>' +
       '<div class="pb__actions">' +
         '<button class="pb__btn" type="button" data-pb-stop>Stop editing</button>' +
+        '<button class="pb__btn" type="button" data-pb-notes title="' + esc(NOTES_TITLE) + '">Artist review</button>' +
         '<button class="pb__btn pb__btn--go" type="button" data-pb-review' + (changed ? '' : ' disabled') + '>Review ' + esc(plural(changed, 'change', 'changes')) + '</button>' +
       '</div>';
   }
@@ -126,13 +153,20 @@
     var rows = changes();
     return '<p class="pb__line"><strong>Your changes to this page</strong></p>' +
       '<ol class="pb__changes">' + rows.map(function (c) {
+        if (c.remove) {
+          return '<li class="pb__change pb__change--remove">' +
+            '<span class="pb__where">' + esc(c.section || 'this page') + '</span>' +
+            '<span class="pb__was"><span class="pb__tag">Remove</span> ' + esc(c.was) + '</span>' +
+          '</li>';
+        }
         return '<li class="pb__change">' +
           '<span class="pb__where">' + esc(c.section || 'this page') + '</span>' +
           '<span class="pb__was"><span class="pb__tag">Was</span> ' + esc(c.was) + '</span>' +
           '<span class="pb__now"><span class="pb__tag">Now</span> ' + esc(c.now) + '</span>' +
         '</li>';
       }).join('') + '</ol>' +
-      '<p class="pb__hint">Sending submits the page: an engineer applies the new words, and they come back to you to approve before anyone sees them.</p>' +
+      '<p class="pb__hint">Sending submits the page: an engineer applies the new words, and they come back to you to approve before anyone sees them.' +
+        (rows.some(function (c) { return c.remove; }) ? ' A line you remove goes to an engineer to take out.' : '') + '</p>' +
       '<p class="pb__error" role="alert">' + esc(err || '') + '</p>' +
       '<div class="pb__actions">' +
         '<button class="pb__btn" type="button" data-pb-back>Keep editing</button>' +
@@ -140,13 +174,29 @@
       '</div>';
   }
 
+  // After sending: the words are on their way, and the look is one press away.
+  function sentHtml(n) {
+    return '<p class="pb__line" role="status">Sent for approval: ' + esc(plural(n, 'change', 'changes')) + '. An engineer applies the new words, and they come back to you in the studio to approve.</p>' +
+      '<p class="pb__line"><strong>Review how this page looks too?</strong> Write what you would change about it, and each point becomes an idea under your name.</p>' +
+      '<p class="pb__error" role="alert">' + esc(st.notesError || '') + '</p>' +
+      '<div class="pb__actions">' +
+        '<button class="pb__btn" type="button" data-pb-close>Not now</button>' +
+        '<button class="pb__btn pb__btn--go" type="button" data-pb-notes data-pb-focus>Start an artist review</button>' +
+      '</div>';
+  }
+
   // ---------- the words ----------
   // Every line the artist has changed, in the page's reading order.
+  // A removal is a line whose words were emptied (the lib's rule, task 1004696).
   function changes() {
     if (!st || !st.lines) return [];
-    return st.lines.filter(function (l) { return st.lib.editor.isChanged(l, st.values[l.key]) && String(st.values[l.key]).trim(); })
-      .map(function (l) { return { key: l.key, section: l.section, was: l.text, now: String(st.values[l.key]).replace(/\s+/g, ' ').trim() }; });
+    return st.lines.filter(function (l) { return st.lib.editor.isChanged(l, st.values[l.key]); })
+      .map(function (l) {
+        if (removed(l)) return { key: l.key, section: l.section, was: l.text, remove: true };
+        return { key: l.key, section: l.section, was: l.text, now: String(st.values[l.key]).replace(/\s+/g, ' ').trim() };
+      });
   }
+  function removed(line) { return !!line && st.lib.editor.isRemoved(line, st.values[line.key]); }
   // The elements on the page whose words are one reading line: a leaf holding
   // text, inside the page's main content, not a control and not shared chrome.
   function candidates() {
@@ -178,14 +228,12 @@
       var line = byText[tidy(el.textContent)] || null;
       if (!line || used[line.key]) return;
       used[line.key] = true;
-      st.els.push({ el: el, key: line.key, original: el.textContent });
-      el.textContent = st.values[line.key];
-      el.setAttribute('contenteditable', 'plaintext-only');
-      if (el.contentEditable !== 'plaintext-only') el.setAttribute('contenteditable', 'true');
+      var en = { el: el, key: line.key, original: el.textContent };
+      st.els.push(en);
       el.setAttribute('spellcheck', 'false');
       el.setAttribute('data-pb-key', line.key);
       el.classList.add('pb-word');
-      el.classList.toggle('pb-word--changed', st.lib.editor.isChanged(line, st.values[line.key]));
+      paintLine(en);
     });
     // A hint, not a ledger: a line the page shows twice is edited once (the
     // first), and its second showing is counted in neither number.
@@ -198,14 +246,44 @@
     document.addEventListener('keydown', onPageKey, true);
     document.addEventListener('paste', onPaste, true);
     document.addEventListener('focusout', onBlur, true);
+    document.addEventListener('focusin', onFocus, true);
     window.addEventListener('pagehide', flush);
     if (!st.els.length) {
       note('None of this page\'s words can be edited where they stand. <a href="' + esc(editorHref(st.id)) + '">Rewrite them in the tweak editor</a>.');
       return;
     }
+    // The first line is the one the bar offers to remove until another is
+    // chosen; set here, since a window without focus fires no focusin.
+    st.current = st.els[0].key;
     paint(editingHtml());
     st.els[0].el.focus();
   }
+  // One line as its state says: its words, editable; or, marked to be removed,
+  // the page's own words struck through, focusable but not typed into, until
+  // "Keep this line" puts it back. Never called mid-typing: the caret would jump.
+  function paintLine(en) {
+    var line = lineOf(en.key);
+    var el = en.el;
+    var gone = removed(line);
+    if (gone) {
+      el.textContent = en.original;
+      el.removeAttribute('contenteditable');
+      el.setAttribute('tabindex', '0');
+      el.setAttribute('aria-label', 'Marked to be removed: ' + tidy(line.text));
+    } else {
+      el.textContent = st.values[en.key];
+      el.setAttribute('contenteditable', 'plaintext-only');
+      if (el.contentEditable !== 'plaintext-only') el.setAttribute('contenteditable', 'true');
+      el.removeAttribute('tabindex');
+      el.removeAttribute('aria-label');
+    }
+    el.classList.toggle('pb-word--removed', gone);
+    el.classList.toggle('pb-word--changed', !gone && !!line && st.lib.editor.isChanged(line, st.values[en.key]));
+  }
+  function entryByKey(key) {
+    for (var i = 0; i < st.els.length; i++) if (st.els[i].key === key) return st.els[i];
+    return null;
+  }
   function entryOf(el) {
     var host = el && el.closest ? el.closest('[data-pb-key]') : null;
     if (!host) return null;
@@ -216,7 +294,10 @@
     var en = entryOf(e.target);
     if (!en) return;
     st.values[en.key] = en.el.textContent;
+    st.current = en.key;
     var line = lineOf(en.key);
+    // Emptied, it stays editable while the artist is still in it: they may be
+    // retyping. Leaving it empty marks it to be removed (onBlur).
     en.el.classList.toggle('pb-word--changed', !!line && st.lib.editor.isChanged(line, st.values[en.key]));
     if (!st.reviewing) paint(editingHtml());
     clearTimeout(st.timer);
@@ -243,7 +324,41 @@
     var text = ((e.clipboardData && e.clipboardData.getData('text/plain')) || '').replace(/\s+/g, ' ');
     document.execCommand('insertText', false, text);
   }
-  function onBlur(e) { if (entryOf(e.target)) save(); }
+  function onBlur(e) {
+    var en = entryOf(e.target);
+    if (!en) return;
+    if (removed(lineOf(en.key)) && en.el.hasAttribute('contenteditable')) {
+      paintLine(en);
+      if (!st.reviewing) paint(editingHtml());
+    }
+    save();
+  }
+  // The line the artist is in is the one "Remove this line" acts on.
+  function onFocus(e) {
+    var en = entryOf(e.target);
+    if (!en || st.current === en.key) return;
+    st.current = en.key;
+    if (!st.reviewing) paint(editingHtml());
+  }
+  function removeLine() {
+    var en = st.current ? entryByKey(st.current) : null;
+    if (!en) return;
+    st.values[en.key] = '';
+    paintLine(en);
+    st.focusBar = true;
+    paint(editingHtml());
+    save();
+  }
+  function keepLine() {
+    var en = st.current ? entryByKey(st.current) : null;
+    var line = en && lineOf(en.key);
+    if (!line) return;
+    st.values[en.key] = line.text;
+    paintLine(en);
+    paint(editingHtml());
+    en.el.focus();
+    save();
+  }
 
   // The WHOLE draft each time (every changed line, the ones typed here and any
   // the editor saved), one save in flight at a time.
@@ -277,7 +392,9 @@
       en.el.removeAttribute('contenteditable');
       en.el.removeAttribute('spellcheck');
       en.el.removeAttribute('data-pb-key');
-      en.el.classList.remove('pb-word', 'pb-word--changed');
+      en.el.removeAttribute('tabindex');
+      en.el.removeAttribute('aria-label');
+      en.el.classList.remove('pb-word', 'pb-word--changed', 'pb-word--removed');
     });
     st.els = [];
     st.editing = false;
@@ -287,6 +404,7 @@
     document.removeEventListener('keydown', onPageKey, true);
     document.removeEventListener('paste', onPaste, true);
     document.removeEventListener('focusout', onBlur, true);
+    document.removeEventListener('focusin', onFocus, true);
     window.removeEventListener('pagehide', flush);
   }
 
@@ -352,7 +470,26 @@
       restore();
       st.reviewing = false;
       st.focusBar = true;
-      note('Sent for approval: ' + esc(plural(n, 'change', 'changes')) + '. An engineer applies the new words, and they come back to you in the studio to approve.');
+      st.sent = n;
+      paint(sentHtml(n));
+    });
+  }
+  // The artist review (the palette's sheet) for this same page, opened from the
+  // editing bar (the words are saved first, and editing carries on under it)
+  // or from the sent view (whose work is then done, so the bar closes).
+  function openNotes() {
+    var btn = bar && bar.querySelector('[data-pb-notes]');
+    if (btn) btn.disabled = true;
+    st.notesError = '';
+    var ready = st.editing ? save() : Promise.resolve(true);
+    ready.then(function () { return loadScript('page-notes.js', 'OTBPageNotes'); }).then(function (notes) {
+      if (st && !st.editing) close();
+      else if (btn) btn.disabled = false;
+      notes.open();
+    }, function () {
+      if (!st || !bar) return;
+      st.notesError = 'The artist review could not open. Press Review in the top bar instead.';
+      paint(st.editing ? editingHtml() : sentHtml(st.sent));
     });
   }
   function stop() {
@@ -374,6 +511,9 @@
     else if (btn.hasAttribute('data-pb-back')) back();
     else if (btn.hasAttribute('data-pb-send')) send();
     else if (btn.hasAttribute('data-pb-stop')) stop();
+    else if (btn.hasAttribute('data-pb-remove')) removeLine();
+    else if (btn.hasAttribute('data-pb-keep')) keepLine();
+    else if (btn.hasAttribute('data-pb-notes')) openNotes();
   }
   function close() {
     if (st && st.editing) { stop(); return; }

package/modules/hall-ui/public/studio.js

@@ -844,7 +844,9 @@
       const line = (el === greetEl && lib.matchLine(servedGreeting, wedit.lines)) || lib.matchLine(el.textContent, wedit.lines);
       if (!line) { el.setAttribute('data-unread', ''); continue; }
       wedit.keys.set(el, line.key);
-      el.textContent = wedit.values[line.key];
+      // A line marked to be removed (an empty value, task 1004696) keeps its
+      // words on screen; the removal stays in the draft until it is typed over.
+      el.textContent = wedit.values[line.key] || line.text;
       el.setAttribute('contenteditable', 'true');
       el.setAttribute('spellcheck', 'false');
       el.setAttribute('aria-label', `The studio's words: ${line.text}`);

package/modules/hall-ui/public/style.css

@@ -1670,6 +1670,22 @@ html.pb-editing main { padding-bottom: 180px; }
 .pb-word:hover { background: color-mix(in srgb, var(--craft, var(--accent)) 8%, transparent); }
 .pb-word:focus, .pb-word:focus-visible { background: color-mix(in srgb, var(--craft, var(--accent)) 12%, transparent); box-shadow: 0 0 0 2px color-mix(in srgb, var(--craft, var(--accent)) 55%, transparent); }
 .pb-word--changed { background: color-mix(in srgb, var(--craft, var(--accent)) 14%, transparent); text-decoration-style: solid; }
+/* A line marked to be removed (task 1004696): the page's words, struck through
+   and faded, still clickable so "Keep this line" can put it back. */
+.pb-word--removed {
+  cursor: pointer;
+  opacity: .55;
+  text-decoration: line-through solid var(--ink-soft);
+  text-decoration-thickness: 1px;
+}
+/* The line the artist is in, with its one action: remove it, or keep it. */
+.pb__current {
+  display: flex; align-items: center; justify-content: space-between; gap: 10px;
+  padding: 8px 8px 8px 12px; border-radius: var(--radius-sm); background: var(--glass);
+}
+.pb__current-words { min-width: 0; font-size: 13.5px; color: var(--ink-soft); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.pb__btn--quiet { flex-shrink: 0; min-height: 32px; padding: 0 14px; font-size: 13px; }
+.pb__change--remove .pb__was { color: var(--ink); }
 @media (max-width: 640px) {
   .pb { bottom: calc(10px + env(safe-area-inset-bottom, 0px)); width: calc(100% - 20px); border-radius: 16px; }
   .pb__inner { padding: 12px 14px 14px; max-height: 64vh; }

package/modules/hall-ui/public/tweak-editor-lib.js

@@ -9,10 +9,12 @@
 //   sectionsOf(lines)      consecutive runs of one section, as the page shows
 //                          them (a section that recurs gets its heading again —
 //                          the Word download's own rule, docx.js)
-//   noteFor(line, value)   the margin note: shared and engineer lines carry
-//                          theirs, a changed line carries "was: <old words>"
-//   draftBody(...)         the WHOLE draft the autosave PUTs: every changed,
-//                          non-empty line as { key, after }
+//   noteFor(line, value)   the margin note: an emptied line is marked to be
+//                          removed, shared and engineer lines carry theirs, a
+//                          changed line carries "was: <old words>"
+//   draftBody(...)         the WHOLE draft the autosave PUTs: every changed
+//                          line as { key, after }, an emptied one as
+//                          { key, remove: true }
 //   counterText(...)       "2 of 75 rewritten · saved"
 //   liveUrl(url, loc)      the page's live address, {apex} resolved from the
 //                          hall's own host (shell.js APEX_ORIGIN's rule)
@@ -42,27 +44,36 @@
   }
 
   // The mock's rule: a shared or engineer line always shows its own note, and
-  // any other changed line shows the words it replaced.
+  // any other changed line shows the words it replaced. An emptied line says it
+  // will be removed first, since that is what sending it now does.
   function noteFor(line, value, notes) {
     const n = notes || NOTES;
+    if (isRemoved(line, value)) return { kind: 'removed', text: `to be removed · goes to an engineer · was: ${line.text}` };
     if (line.note === 'shared') return { kind: 'shared', text: n.shared || NOTES.shared };
     if (line.note === 'engineer') return { kind: 'engineer', text: n.engineer || NOTES.engineer };
     if (isChanged(line, value)) return { kind: 'was', text: `was: ${line.text}` };
     return null;
   }
 
-  // An empty box is not a rewrite: removing words from a page is a code change
-  // (the server's line_empty), so an emptied line is left out of the save and
-  // the page keeps its words until the artist types new ones.
+  // An empty box is not a rewrite to nothing: it is the artist recommending the
+  // page stop showing the line (task 1004696). Removing words is a code change,
+  // so it is saved as { key, remove: true } (an empty `after` alone is the
+  // server's line_empty) and the submit hands it to an engineer. A draft line
+  // the server holds as a removal reads back as an empty value, so every editor
+  // carries it through its next save.
   function isEmpty(value) {
     return !String(value == null ? '' : value).trim();
   }
+  function isRemoved(line, value) {
+    return isChanged(line, value) && isEmpty(value);
+  }
 
   function draftBody(readingHash, lines, values) {
     const out = [];
     for (const l of lines || []) {
       const v = values[l.key];
-      if (isChanged(l, v) && !isEmpty(v)) out.push({ key: l.key, after: v });
+      if (isRemoved(l, v)) out.push({ key: l.key, remove: true });
+      else if (isChanged(l, v)) out.push({ key: l.key, after: v });
     }
     return { reading_hash: readingHash, lines: out };
   }
@@ -76,11 +87,12 @@
     return `${changed} of ${total} rewritten · ${SAVE_WORDS[save] || SAVE_WORDS.saved}`;
   }
 
-  // The editor's starting words: the page's own, with the saved draft laid over.
+  // The editor's starting words: the page's own, with the saved draft laid over
+  // (a removal as an empty value).
   function initialValues(lines, draft) {
     const values = {};
     for (const l of lines || []) values[l.key] = l.text;
-    for (const d of (draft && draft.lines) || []) if (d && Object.prototype.hasOwnProperty.call(values, d.key)) values[d.key] = d.after;
+    for (const d of (draft && draft.lines) || []) if (d && Object.prototype.hasOwnProperty.call(values, d.key)) values[d.key] = d.remove ? '' : d.after;
     return values;
   }
 
@@ -248,7 +260,7 @@
     return null;
   }
 
-  const api = { OPEN_WORDS, openChoice, clampSplit, splitFromPointer, splitFromKey, canFrame, FRAME_SIBLINGS, splitWindowFeatures, HINT, nextLineKey, confirmedCount, hintText, confirmStoreKey, parseConfirmed, NOTES, sectionsOf, isChanged, noteFor, draftBody, changedCount, counterText, initialValues, rowsFor, liveUrl, uploadedLabel, uploadRefusal, displayTitle, pageIdFrom };
+  const api = { OPEN_WORDS, openChoice, clampSplit, splitFromPointer, splitFromKey, canFrame, FRAME_SIBLINGS, splitWindowFeatures, HINT, nextLineKey, confirmedCount, hintText, confirmStoreKey, parseConfirmed, NOTES, sectionsOf, isChanged, isRemoved, noteFor, draftBody, changedCount, counterText, initialValues, rowsFor, liveUrl, uploadedLabel, uploadRefusal, displayTitle, pageIdFrom };
   if (typeof window !== 'undefined') window.OTBTweakEditor = api;
   if (typeof module !== 'undefined' && module.exports) module.exports = api;
 })();

package/modules/hall-ui/records/craft-mode.md

@@ -45,6 +45,11 @@ Covers: every shelled hall page (`craft-mode.js`, `shell.js`, `style.css`), and
 - **The top bar fits two tools at 390px** because, at phone width, the side packs to a 4px gap, a tool is 28px, the side and the menu do not shrink, and a long page title trims with an ellipsis instead. All 34 hall pages measure 0px of sideways scroll in Artistry at 390px.
 - `tests/paintbrush.mjs` runs the real script and both shared libs over a small page.
 
+### Removing a line, and the artist review alongside (task 1004696)
+
+- **An artist can recommend removing a line** (owner, 2026-10-09: pages carry superfluous subtitles and text). The line the artist is in shows in the bar with **Remove this line**; emptying a line's words and leaving it does the same. A removed line shows the page's own words struck through and faded, is no longer typed into but stays focusable, and **Keep this line** puts it back. Review lists it as its own "Remove" row and says it goes to an engineer. It is saved as `{ key, remove: true }` (the copy desk's rule, `modules/copy-desk/CLAUDE.md`), so the send files an engineer task to take it out.
+- **The artist review is one press away**: **Artist review** in the editing bar saves the words and opens the palette's sheet (`page-notes.js`, loaded on demand like a tool) over the page; editing carries on when it closes. Once the words are sent, the bar asks "Review how this page looks too?" with **Start an artist review** (closes the bar, opens the sheet) and **Not now**. The paintbrush still writes no feedback doc itself: `tests/paintbrush.mjs` allows `page-notes.js` as the only page-notes name in the file.
+
 ## The lightbulb (task 1004498)
 
 - **Ideating carries one tool, the lightbulb** (`lightbulb.js`, a `TOOLS` entry loaded on first press). Its button wears its own note glyph, not the mode's lightbulb, so it is never read as the Ideating pill beside it (owner, 2026-10-04). It is a watered-down palette: the same side sheet and `.pn` styles, text only, no uploads.

package/modules/hall-ui/records/tweak-editor.md

@@ -6,7 +6,7 @@ Files: `tweak-editor.html` (the markup), `tweak-editor.css` (the artboard's inli
 
 - **Which page.** `?page=<page id>` (`landing:index`). With none, the page the caller holds (`GET /copy-desk/next`'s `resume`), and with nothing held, the "is in" panel's next up, so a bare link still leads somewhere. The studio (TW16) links here.
 - **One read opens it.** `GET /copy-desk/pages/:pageId/draft` (added here: `GET /copy-desk/pages/:pageId` carries neither the lines nor the draft) answers every reading line with its margin note, the open round and `held_by_you`, and the saved draft, only on the current reading (`draft_on_older_reading` otherwise). The note is the server's: `engineer` is `pages.goesToEngineer`, the submit's own rule, so a shared line with no registry row says "goes to an engineer", which is what the submit will do with it.
-- **The autosave is the whole draft, debounced (700ms) and on blur**, one save in flight at a time, skipped when the body equals the last accepted one; a last `keepalive` PUT on `pagehide`. An emptied box is not saved (the server's `line_empty`: removing words is a code change), and the counter reads "not saved" with the server's own words above the paper when a save is refused.
+- **The autosave is the whole draft, debounced (700ms) and on blur**, one save in flight at a time, skipped when the body equals the last accepted one; a last `keepalive` PUT on `pagehide`. An emptied box is saved as a removal, `{ key, remove: true }` (task 1004696): its margin note says it is to be removed and goes to an engineer, and the submit files that engineer task (an empty `after` alone is still the server's `line_empty`), and the counter reads "not saved" with the server's own words above the paper when a save is refused.
 - **Holding decides writing.** A page nobody holds is read-only with one button, "take this page" (the claim); another builder's is read-only and names them; a submitted one is frozen. Upload and submit are the holder's only, as their routes are.
 - **Every write is named** (`WRITES`: the draft PUT, the .docx POST, the submit, the claim on a server-given `take.path`), and `tests/hall_tweak_editor.mjs` pins the list. The upload is a raw `fetch` because the generated client JSON-encodes every body.
 - **It opens full screen.** The artboard is the whole window, so the first visit sets the shell's switch (task 1004327) on; after that the shell remembers the artist's choice for this page. In full screen the switch button wears the room's glass, since the stage is dark in both themes.

package/modules/lifecycle/autopickup.js

@@ -0,0 +1,94 @@
+'use strict';
+
+// modules/lifecycle/autopickup.js — the server's half of tweak auto-pickup
+// (task 1004677 / BV2.TW19a, ADR 0371 D3, D5, D6).
+//
+// The Autobongos tweak lane claims a submitted page round with an `auto_pickup`
+// mark (claims.auto_pickup, migration core_275). The runner is a builder's own
+// process, so the limits on it are NOT left to the runner: claimTask calls
+// autoPickupRefusal inside its transaction and the claim is refused when
+//
+//   - the claim is marked but the task is not a page-tweak round  (AUTO_PICKUP_NOT_A_TWEAK)
+//   - the project has tweak.autopickup off                         (AUTO_PICKUP_OFF)
+//   - this calendar month already holds `cap` marked claims        (AUTO_PICKUP_CAP_REACHED)
+//   - this round already has two marked claims                     (AUTO_PICKUP_ROUND_LIMIT)
+//
+// THE LOCK. The count and the claim insert must not interleave with another
+// runner's, or two runners racing for the last slot both read cap-1 and both
+// insert. So the count runs after pg_advisory_xact_lock('page-tweak/autopickup'),
+// one project-wide key, held to the end of claimTask's transaction (the insert
+// commits under it). Only marked claims take the lock; an ordinary claim never
+// waits on it.
+//
+// COUNTED FROM THE LEDGER, never a counter: a stored number drifts the first time
+// a write fails between the claim and the bump. A released claim still counts —
+// the pickup happened and the grade may already have been spent.
+//
+// The mark is a cost brake on a runner the owner chose to run, not a security
+// boundary: a claim without it is an ordinary claim its builder could make by hand.
+
+const api = require('../../src/module-api');
+
+const PAGE_TWEAK_SOURCE = 'page-tweak';
+const LOCK_KEY = 'page-tweak/autopickup';
+// D6.2: one apply plus one try at the artist's note; a round sent back twice is a
+// disagreement a person should read.
+const MAX_AUTO_APPLIES_PER_ROUND = 2;
+
+// The two counts, on any executor (the claim transaction's client, or the pool).
+// Month boundaries are the database's, so every runner and every reader agree.
+const MONTH_COUNT_SQL = `
+  SELECT count(*)::int AS n
+    FROM claims c JOIN tasks t ON t.id = c.task_id
+   WHERE c.auto_pickup IS TRUE
+     AND t.source = '${PAGE_TWEAK_SOURCE}'
+     AND c.claimed_at >= date_trunc('month', now())`;
+const ROUND_COUNT_SQL = `
+  SELECT count(*)::int AS n FROM claims WHERE task_id = $1 AND auto_pickup IS TRUE`;
+
+async function countThisMonth(exec = api.pool) {
+  const { rows } = await exec.query(MONTH_COUNT_SQL);
+  return Number(rows[0] && rows[0].n) || 0;
+}
+
+async function countForRound(exec, taskId) {
+  const { rows } = await exec.query(ROUND_COUNT_SQL, [taskId]);
+  return Number(rows[0] && rows[0].n) || 0;
+}
+
+// autoPickupRefusal(client, task, settings) — null when the marked claim may
+// proceed, else the refusal object claimTask throws. `settings` is the resolved
+// { mode, cap }, read BEFORE the transaction opens (the claimPermissionsFor
+// precedent: a settings read is not part of the claim's consistency).
+async function autoPickupRefusal(client, task, settings) {
+  if (!task || task.source !== PAGE_TWEAK_SOURCE) {
+    return { code: 'AUTO_PICKUP_NOT_A_TWEAK', message: 'Only a page tweak round can be claimed with the auto_pickup mark.' };
+  }
+  const s = settings || {};
+  if (s.mode !== 'on') {
+    return { code: 'AUTO_PICKUP_OFF', message: 'Tweak auto-pickup is off for this project, so a submitted page waits for a person.' };
+  }
+  await client.query('SELECT pg_advisory_xact_lock(hashtext($1))', [LOCK_KEY]);
+  const forRound = await countForRound(client, task.id);
+  if (forRound >= MAX_AUTO_APPLIES_PER_ROUND) {
+    return {
+      code: 'AUTO_PICKUP_ROUND_LIMIT', applied: forRound, limit: MAX_AUTO_APPLIES_PER_ROUND,
+      message: `This page round was already applied automatically ${forRound} times, so it waits for a person.`,
+    };
+  }
+  const used = await countThisMonth(client);
+  if (used >= s.cap) {
+    return {
+      code: 'AUTO_PICKUP_CAP_REACHED', used, cap: s.cap,
+      message: `Auto-pickup has used this month's ${s.cap} rounds, so submitted pages wait for a person until next month.`,
+    };
+  }
+  return null;
+}
+
+module.exports = {
+  LOCK_KEY,
+  MAX_AUTO_APPLIES_PER_ROUND,
+  countThisMonth,
+  autoPickupRefusal,
+};

package/modules/lifecycle/db-claims.js

@@ -37,6 +37,7 @@ const { claimGate, claimPermissionsFor, disambiguateWorktreeName, foldWorktreeNa
 const { sealSessionLog } = require('./db-shared.js');
 const { gatingRebaseTasksForBuilder, shouldRefuseClaimResolve } = require('./db-ship.js');
 const { REWARD_SUGGESTION_CAP, rewardGateAssignment } = require('./db-tasks.js');
+const { autoPickupRefusal } = require('./autopickup.js');
 
 // -------------------------------------------------------------------------
 // Claims (atomic)
@@ -99,8 +100,11 @@ function isRebaseGateExempt(task) {
   return Boolean(task) && task.kind === 'infra' && Number(task.priority) === 1;
 }
 
-async function claimTask({ taskId, builderId, worktreeName, headSha, creatorSessionId, enforceOverlap = false }) {
+async function claimTask({ taskId, builderId, worktreeName, headSha, creatorSessionId, enforceOverlap = false, autoPickup = false }) {
   const heldPermissions = await claimPermissionsFor(builderId); // BV1.R106 — before the tx opens
+  // ADR 0371 D5: a marked claim needs the project's switch and cap, read before the
+  // tx like the permissions above; the COUNT runs inside it, under the lock.
+  const autoPickupSettings = autoPickup ? await api.projectSettings.resolveTweakAutopickup() : null;
   const client = await pool.connect();
   try {
     await client.query('BEGIN');
@@ -142,7 +146,7 @@ async function claimTask({ taskId, builderId, worktreeName, headSha, creatorSess
     }
 
     const { rows: taskRows } = await client.query(
-      `SELECT id, status, touches, newcomer_friendly, requires_rank, needs_migration, module_key, credits_reward, reward_gate_exempt, est_minutes, kind, goal_id FROM tasks WHERE id = $1 FOR UPDATE`,
+      `SELECT id, status, touches, newcomer_friendly, requires_rank, needs_migration, module_key, credits_reward, reward_gate_exempt, est_minutes, kind, goal_id, source FROM tasks WHERE id = $1 FOR UPDATE`,
       [taskId]
     );
     if (taskRows.length === 0) {
@@ -350,6 +354,14 @@ async function claimTask({ taskId, builderId, worktreeName, headSha, creatorSess
       }
     }
 
+    // ADR 0371 D5/D6 (task 1004677): the auto_pickup mark. The cap and the per-round
+    // limit are counted under a project-wide advisory lock that this transaction
+    // holds through the insert below, so two runners cannot both take the last slot.
+    if (autoPickup) {
+      const refusal = await autoPickupRefusal(client, task, autoPickupSettings);
+      if (refusal) throw refusal;
+    }
+
     // Pre-allocate a migration number if the task signals it'll add one.
     // Trigger: the tasks.needs_migration boolean (migration 081, touches[]
     // cleanup [1/8] / task 876). Replaced the old touches[]-contains-'migrations/'
@@ -396,9 +408,11 @@ async function claimTask({ taskId, builderId, worktreeName, headSha, creatorSess
       finalWorktreeName = disambiguateWorktreeName(finalWorktreeName, taken);
     }
 
+    // The column is named only on a marked claim, so an ordinary claim's insert is
+    // byte-identical to before core_275.
     const insertClaim = await client.query(
-      `INSERT INTO claims (task_id, builder_id, worktree_name, requested_worktree_name, head_sha, reserved_migration_number, creator_session_id)
-       VALUES ($1, $2, $3, $4, $5, $6, $7)
+      `INSERT INTO claims (task_id, builder_id, worktree_name, requested_worktree_name, head_sha, reserved_migration_number, creator_session_id${autoPickup ? ', auto_pickup' : ''})
+       VALUES ($1, $2, $3, $4, $5, $6, $7${autoPickup ? ', TRUE' : ''})
        RETURNING id, task_id, builder_id, worktree_name, requested_worktree_name, claimed_at, head_sha, reserved_migration_number`,
       [taskId, builderId, finalWorktreeName, requestedWorktreeName, headSha ?? null, reservedMigrationNumber, creatorSessionId ?? null]
     );

package/modules/lifecycle/routes/claims.js

@@ -276,8 +276,12 @@ module.exports = function buildClaimsRouter() {
       // an interactive single-human claim only WARNS (git merge is the real
       // collision detector — ADR 0017).
       enforce_touches: { type: 'boolean' },
+      // ADR 0371 D5 (task 1004677): the Autobongos tweak lane's mark. The server
+      // counts marked claims against the project's monthly cap and the per-round
+      // limit; see modules/lifecycle/autopickup.js.
+      auto_pickup: { type: 'boolean' },
     })) return;
-    const { task_id: taskId, worktree_name: worktreeName, head_sha: headSha, bind_session: bindSession, enforce_touches: enforceTouches } = req.body || {};
+    const { task_id: taskId, worktree_name: worktreeName, head_sha: headSha, bind_session: bindSession, enforce_touches: enforceTouches, auto_pickup: autoPickup } = req.body || {};
     // Belt-and-braces — task_id must coerce to a finite number. Older calls
     // sent string ints (Number.isFinite passes both); reject NaN/garbage.
     if (!Number.isFinite(Number(taskId))) {
@@ -291,6 +295,7 @@ module.exports = function buildClaimsRouter() {
         headSha: headSha ?? null,
         creatorSessionId: resolveCreatorSessionId(bindSession, req.gdsSession?.session_id),
         enforceOverlap: enforceTouches === true,
+        autoPickup: autoPickup === true,
       });
       const { just_unlocked: justUnlocked, overlap_warning: overlapWarning, sibling_overlap_warning: siblingOverlapWarning, ...claim } = claimResult;
       const task = await db.getTask(Number(taskId));
@@ -375,6 +380,12 @@ module.exports = function buildClaimsRouter() {
           // block, not an authorization refusal). The refusal object already
           // carries `message` + `hint`, so no extra hint-building step needed.
           err.code === 'RELEVANCE_REVIEW_PENDING' ? 409 :
+          // ADR 0371 D5/D6: a marked auto-pickup claim the project's switch, monthly
+          // cap or per-round limit refuses. The round waits for a person.
+          err.code === 'AUTO_PICKUP_NOT_A_TWEAK' ? 409 :
+          err.code === 'AUTO_PICKUP_OFF' ? 409 :
+          err.code === 'AUTO_PICKUP_CAP_REACHED' ? 409 :
+          err.code === 'AUTO_PICKUP_ROUND_LIMIT' ? 409 :
           500;
         // V4.R14 (#952): a TASK_NOT_READY 409 names the way forward instead of
         // leaving the caller to discover the promote route by spelunking (#506).