@bongos/core 1.21.106 → 1.21.108

package/migrations/core_275_claims_auto_pickup.sql

@@ -0,0 +1,24 @@
+-- core_275 a claim can carry the auto_pickup mark
+-- Applied under task 1004677 (BV2.TW19a, ADR 0371 D5/D6).
+--
+-- WHY. The Autobongos tweak lane picks up a submitted page round with nobody at a
+-- terminal, and each pickup costs the project a grade nobody chose to spend. So the
+-- lane claims with a mark, and the SERVER counts marked claims at claim time:
+-- tweak.autopickup_monthly_cap per calendar month, and at most two per round. The
+-- count is read from these rows (the ledger), never from a stored counter.
+--
+-- SHAPE. One nullable boolean. NULL and false both mean "an ordinary claim"; only
+-- true is counted. Nullable with no default, so the column is additive and an
+-- older release that never names it keeps inserting exactly as before.
+--
+-- The partial index serves the two counts (this month's marked claims, and one
+-- round's marked claims), and stays tiny: only marked rows are in it.
+
+ALTER TABLE claims ADD COLUMN IF NOT EXISTS auto_pickup boolean;
+
+CREATE INDEX IF NOT EXISTS idx_claims_auto_pickup
+  ON claims (claimed_at, task_id)
+  WHERE auto_pickup IS TRUE;
+
+INSERT INTO schema_migrations (version) VALUES ('core_275_claims_auto_pickup')
+  ON CONFLICT (version) DO NOTHING;

package/modules/copy-desk/docx.js

@@ -82,6 +82,8 @@ const COMMENT_TEXT = Object.freeze({
   shared: 'changes this on every page',
   unplaced: 'goes to an engineer',
 });
+// A line the draft removes (task 1004696): a comment, but no style of its own.
+const REMOVED_COMMENT = 'marked to be removed: an engineer takes it out. Rewrite it here to keep it';
 const NOTE_TEXT = 'Rewrite any line where it stands, then upload this file back into the editor. '
   + 'Keep one paragraph per line: a paragraph added, removed or moved is refused. '
   + 'Keep each {…} as it is: the page fills in a value there.';
@@ -368,16 +370,25 @@ function textOf(el) {
 // The lines as the file shows them: the draft's `after` where the draft is on
 // this very reading, else the page's current text. A draft saved on an older
 // reading is not shown: its keys may name other lines now.
+//
+// A line the draft removes (task 1004696) shows the page's words with a margin
+// comment saying so: an empty paragraph is not a line, so blanking it would
+// break the file's one-paragraph-per-line shape. Rewriting it in Word keeps it.
 function shownLines(readingPage, draft) {
   const after = new Map();
+  const removed = new Set();
   if (draft && draft.reading_hash === readingPage.reading_hash) {
-    for (const l of draft.lines || []) after.set(l.key, l.after);
+    for (const l of draft.lines || []) {
+      if (l.remove) removed.add(l.key);
+      else after.set(l.key, l.after);
+    }
   }
   return (readingPage.lines || []).map((l) => ({
     key: l.key,
     section: l.section == null ? '' : String(l.section),
     placement: l.placement,
     text: after.has(l.key) ? after.get(l.key) : l.text,
+    ...(removed.has(l.key) ? { removed: true } : {}),
   }));
 }
 
@@ -413,8 +424,8 @@ function documentXml({ title, lines }) {
       current = l.section;
       body.push(styledPara(STYLE.heading, run(l.section)));
     }
-    const note = COMMENT_TEXT[l.placement];
-    const style = note ? STYLE[l.placement] : null;
+    const style = COMMENT_TEXT[l.placement] ? STYLE[l.placement] : null;
+    const note = l.removed ? REMOVED_COMMENT : COMMENT_TEXT[l.placement];
     const sdt = `<w:sdt><w:sdtPr><w:tag w:val="${escapeXml(l.key)}"/><w:id w:val="${idx + 1}"/><w:text/></w:sdtPr>`
       + `<w:sdtContent>${run(l.text)}</w:sdtContent></w:sdt>`;
     let inner = sdt;
@@ -853,10 +864,18 @@ function mapUpload({ readingPage, upload }) {
 // file is the whole intended state. The lines go to pages.resolveDraft, the
 // autosave's own resolver, which drops unchanged lines and takes every target
 // from the reading.
+//
+// A line the draft removes (task 1004696) was shown with the page's words, so
+// those are what the file is compared with: left alone, it stays a removal
+// ({ key, remove: true }); rewritten in Word, the rewrite wins.
 function mergeUpload({ readingPage, texts, baseline, draft }) {
   const draftAfter = new Map();
+  const removed = new Set();
   if (draft && draft.reading_hash === readingPage.reading_hash) {
-    for (const l of draft.lines || []) draftAfter.set(l.key, l.after);
+    for (const l of draft.lines || []) {
+      if (l.remove) removed.add(l.key);
+      else draftAfter.set(l.key, l.after);
+    }
   }
   const same = (a, b) => foldQuotes(tidy(a)) === foldQuotes(tidy(b));
   const lines = [];
@@ -867,9 +886,10 @@ function mergeUpload({ readingPage, texts, baseline, draft }) {
     const uploaded = texts.has(l.key) ? tidy(pageQuotes(l.text, texts.get(l.key))) : current;
     const changedInFile = baseline && baseline.has(l.key) ? !same(uploaded, baseline.get(l.key)) : !same(uploaded, current);
     const after = changedInFile ? uploaded : current;
-    if (changedInFile && !same(after, current)) fromFile.push(l.key);
-    else if (draftAfter.has(l.key)) kept.push(l.key);
-    lines.push({ key: l.key, after });
+    const tookFile = changedInFile && !same(after, current);
+    if (tookFile) fromFile.push(l.key);
+    else if (draftAfter.has(l.key) || removed.has(l.key)) kept.push(l.key);
+    lines.push(removed.has(l.key) && !tookFile ? { key: l.key, remove: true } : { key: l.key, after });
   }
   return { lines, from_file: fromFile, kept_from_draft: kept };
 }

package/modules/copy-desk/page-status.js

@@ -587,7 +587,9 @@ function composeEditor({ page, readingPage, round, builderId }) {
         draft = {
           reading_hash: d.draft.reading_hash,
           saved_at: d.draft.saved_at || null,
-          lines: d.draft.lines.filter((l) => keys.has(l.key)).map((l) => ({ key: l.key, after: l.after })),
+          // A removal (task 1004696) reads as an empty `after` plus `remove`,
+          // which is how every editor holds it.
+          lines: d.draft.lines.filter((l) => keys.has(l.key)).map((l) => (l.remove ? { key: l.key, after: '', remove: true } : { key: l.key, after: l.after })),
         };
       } else {
         olderReading = true;

package/modules/copy-desk/pages.js

@@ -115,7 +115,9 @@ function composeDraftBlock(d) {
     page_id: d.page_id,
     reading_hash: d.reading_hash,
     saved_at: d.saved_at,
-    lines: (d.lines || []).map((l) => ({ key: l.key, section: l.section, before: l.before, after: l.after, placement: l.placement })),
+    // `remove` is written only on a removal (task 1004696), so every draft
+    // that removes nothing keeps its bytes.
+    lines: (d.lines || []).map((l) => ({ key: l.key, section: l.section, before: l.before, after: l.after, placement: l.placement, ...(l.remove ? { remove: true } : {}) })),
   });
 }
 
@@ -266,6 +268,12 @@ function replaceBlock(markdown, fence, block) {
 // 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).
+//
+// A line sent as { key, remove: true } is the artist recommending the page stop
+// showing it (task 1004696). It is stored with `after` empty and `remove: true`;
+// an empty `after` WITHOUT the flag is still line_empty, so no client removes a
+// line by accident. Removing words is a code change, so the submit hands every
+// removal to an engineer (freezeBatch).
 function resolveDraft({ readingPage, body, savedAt }) {
   if (!readingPage || !Array.isArray(readingPage.lines)) return fail('reading_missing');
   const b = body || {};
@@ -282,11 +290,19 @@ function resolveDraft({ readingPage, body, savedAt }) {
   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 });
+    const remove = !!raw && raw.remove === true;
+    const malformed = !LINE_KEY_RE.test(key)
+      || (raw.remove !== undefined && typeof raw.remove !== 'boolean')
+      || (remove ? (raw.after !== undefined && tidy(raw.after) !== '') : typeof raw.after !== 'string');
+    if (malformed) 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; }
+    if (remove) {
+      out.push({ key, section: at.section == null ? null : at.section, before: at.text, after: '', placement: at.placement, remove: true });
+      continue;
+    }
     const after = tidy(raw.after);
     if (after === tidy(at.text)) continue;
     if (!after) { empty.push(key); continue; }
@@ -307,7 +323,7 @@ function resolveDraft({ readingPage, body, savedAt }) {
 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])]);
+    (d.lines || []).map((l) => [l.key, l.section == null ? null : l.section, l.before, l.after, l.placement, !!l.remove])]);
   return pick(saved) === pick(next);
 }
 
@@ -356,7 +372,8 @@ function goesToEngineer(line) {
 // 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.
+// lines taken out of it: the rewrites the applier cannot place, and every
+// removal (`remove: true`).
 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');
@@ -371,6 +388,9 @@ function freezeBatch({ readingPage, draft, submittedAt }) {
     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 };
+    // A removal is a code change wherever the line lives, so it never joins
+    // the applier's batch (task 1004696).
+    if (d.remove) { unplaced.push({ ...line, after: '', remove: true }); continue; }
     if (goesToEngineer(at)) { unplaced.push(line); continue; }
     const want = placeholderCount(at.text);
     const got = placeholderCount(d.after);
@@ -388,7 +408,8 @@ function freezeBatch({ readingPage, draft, submittedAt }) {
 }
 
 // The engineer task an unplaced rewrite files (ADR 0341 D4): one per line,
-// keyed so a repeated submit finds the task it already filed.
+// keyed so a repeated submit finds the task it already filed. A removal
+// (task 1004696) files the same way, worded as a removal.
 function unplacedSourceRef(roundTaskId, key) {
   return `${UNPLACED_SOURCE}/${roundTaskId}/${key}`;
 }
@@ -399,10 +420,28 @@ function clip(text, n) {
 }
 
 function unplacedTaskTitle(page, line) {
+  if (line.remove) return `Remove "${clip(line.before, 60)}" (${page.id})`;
   return `Place and reword "${clip(line.before, 60)}" (${page.id})`;
 }
 
+function removalTaskBody(page, line, roundTaskId) {
+  const shared = line.placement === 'shared'
+    ? ['It is shared shell text: it shows on every page of the surface, so removing it removes it everywhere.', '']
+    : [];
+  return [
+    `An artist recommends that **${String(page.title || page.id)}** (\`${page.id}\`${page.path ? `, ${page.path}` : ''}) stop showing a line, from the page's tweak round. Removing words from a page is a code change, so it comes to an engineer (task 1004696).`,
+    '',
+    ...shared,
+    `- Section: ${line.section == null ? '(none)' : line.section}`,
+    `- Line: ${line.key} in the page reading`,
+    `- It says now: ${JSON.stringify(line.before)}`,
+    '',
+    `Find where this text is rendered and take it out, along with any element or spacing it would leave empty. If removing it would lose something a reader needs, say so on this task instead. The page's tweak round (task ${roundTaskId}) does not wait for this.`,
+  ].join('\n');
+}
+
 function unplacedTaskBody(page, line, roundTaskId) {
+  if (line.remove) return removalTaskBody(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).';

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

@@ -114,7 +114,8 @@ 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
+// on, and every changed line as { key, after }, or { key, remove: true } for a
+// line the artist recommends removing (task 1004696). 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({
@@ -155,10 +156,10 @@ const PAGE_REFUSAL_STATUS = Object.freeze({
 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_empty: 'A line cannot be rewritten to nothing. To recommend the page stop showing it, send the line as { key, remove: true }: removing text is a code change, so the submit hands it to an engineer.',
   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.',
+  nothing_to_submit: 'The draft has no rewritten or removed lines yet.',
   structure_changed: 'The file\'s lines no longer match the page: a paragraph was added, removed or moved, or a heading changed. Each one is listed. Put them back (one paragraph per line, in the page\'s order) or download the page again, and upload once more; nothing was saved.',
   not_a_docx: 'Upload the .docx file this page downloaded, as the request body. Nothing was saved.',
   upload_too_large: `A page file is at most ${Math.round(docx.MAX_UPLOAD_BYTES / (1024 * 1024))} MB. Nothing was saved.`,

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

@@ -246,6 +246,44 @@ test('a line changed in Word wins over the draft; without the file\'s baseline t
   assert.deepEqual(merged.from_file, ['L0002']);
 });
 
+// ---------------------------------------------------------------------------
+// A line the draft removes (task 1004696).
+// ---------------------------------------------------------------------------
+
+const removal = draftOf([
+  { key: 'L0002', section: 'greeting', before: 'Welcome back', after: 'Hello again', placement: 'placed' },
+  { key: 'L0006', section: 'footer', before: 'Resume', after: '', placement: 'placed', remove: true },
+]);
+
+test('the download shows a removed line with the page\'s words and a margin comment, never as an empty paragraph', () => {
+  const files = unzipAll(download(removal));
+  assert.match(files.get('word/document.xml'), />Resume</);
+  assert.match(files.get('word/comments.xml'), /marked to be removed: an engineer takes it out\. Rewrite it here to keep it/);
+  assert.equal(upload(download(removal)).baseline.get('L0006'), 'Resume', 'the file records the words it showed');
+  assert.doesNotMatch(unzipAll(download()).get('word/comments.xml'), /marked to be removed/, 'no removal, no such comment');
+});
+
+test('a removed line left alone in Word stays a removal through the upload', () => {
+  const edited = resave(download(removal), { document: (xml) => typeInto(xml, 'L0004', wordRuns(['Nothing waits'])) });
+  const { merged } = roundTrip(edited, removal);
+  assert.deepEqual(merged.lines.find((l) => l.key === 'L0006'), { key: 'L0006', remove: true });
+  assert.deepEqual(merged.kept_from_draft, ['L0002', 'L0006']);
+  const resolved = pages.resolveDraft({ readingPage: READING, body: { reading_hash: 'h-now', lines: merged.lines }, savedAt: 't' });
+  assert.equal(resolved.ok, true, JSON.stringify(resolved));
+  assert.deepEqual(resolved.draft.lines.map((l) => [l.key, l.after, !!l.remove]),
+    [['L0002', 'Hello again', false], ['L0004', 'Nothing waits', false], ['L0006', '', true]]);
+  // Without the file's record of what it showed, an unchanged line is still the page's words: the removal stays.
+  const noBaseline = roundTrip(resave(download(removal), { drop: ['customXml/item1.xml'] }), removal).merged;
+  assert.deepEqual(noBaseline.lines.find((l) => l.key === 'L0006'), { key: 'L0006', remove: true });
+});
+
+test('a removed line rewritten in Word becomes that rewrite', () => {
+  const edited = resave(download(removal), { document: (xml) => typeInto(xml, 'L0006', wordRuns(['Pick up where you were'])) });
+  const { merged } = roundTrip(edited, removal);
+  assert.deepEqual(merged.lines.find((l) => l.key === 'L0006'), { key: 'L0006', after: 'Pick up where you were' });
+  assert.deepEqual(merged.from_file, ['L0006']);
+});
+
 // ---------------------------------------------------------------------------
 // Structure changes are refused, by name.
 // ---------------------------------------------------------------------------

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

@@ -198,5 +198,84 @@ test('the engineer task carries the page, the line and the wording, keyed per ro
   }
 });
 
+// ---------------------------------------------------------------------------
+// Removing a line (task 1004696): the artist recommends the page stop showing
+// it. Saved as { key, remove: true }; at submit it goes to an engineer, never
+// into the applier's batch.
+// ---------------------------------------------------------------------------
+
+test('a removal is saved as remove: true with an empty after; an empty after WITHOUT the flag is still line_empty', () => {
+  const r = pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([
+    { key: 'L0006', remove: true },
+    { key: 'L0003', after: 'Build it here', remove: false },
+  ]) });
+  assert.equal(r.ok, true, JSON.stringify(r));
+  assert.deepEqual(r.draft.lines, [
+    { key: 'L0003', section: 'hero', before: 'Build here', after: 'Build it here', placement: 'placed' },
+    { key: 'L0006', section: 'footer', before: 'Resume', after: '', placement: 'placed', remove: true },
+  ]);
+  const code = (lines) => pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body(lines) }).code;
+  assert.equal(code([{ key: 'L0006', after: '' }]), 'line_empty', 'no client removes a line by accident');
+  assert.equal(code([{ key: 'L0006', remove: true, after: 'Keep me' }]), 'line_malformed', 'a removal carries no words');
+  assert.equal(code([{ key: 'L0006', remove: 'yes' }]), 'line_malformed');
+  assert.equal(code([{ key: 'L0099', remove: true }]), 'unknown_line');
+  assert.equal(pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([{ key: 'L0006', remove: true, after: '  ' }]) }).ok, true, 'an empty after beside the flag is the same removal');
+});
+
+test('the stored block keeps a removal, and a draft with none keeps its bytes', () => {
+  const plain = draftOf([{ key: 'L0003', after: 'Build it here' }]);
+  assert.doesNotMatch(pages.composeDraftBlock(plain), /remove/, 'no removal, no new field');
+  const withRemoval = draftOf([{ key: 'L0003', after: 'Build it here' }, { key: 'L0006', remove: true }]);
+  const parsed = pages.parseDraftBlock(pages.composeDraftBlock(withRemoval));
+  assert.equal(parsed.ok, true);
+  assert.deepEqual(parsed.draft.lines[1], { key: 'L0006', section: 'footer', before: 'Resume', after: '', placement: 'placed', remove: true });
+  assert.equal(pages.sameDraft(parsed.draft, withRemoval), true);
+  assert.equal(pages.sameDraft(withRemoval, draftOf([{ key: 'L0003', after: 'Build it here' }, { key: 'L0006', after: 'Resume now' }])), false);
+});
+
+test('at submit a removal goes to an engineer, wherever the line lives, and never into the batch', () => {
+  const draft = draftOf([
+    { key: 'L0001', remove: true },   // shared, with a registry row: the applier could place it, but removing is code
+    { key: 'L0003', after: 'Build it here' },
+    { key: 'L0004', remove: true },   // a line with holes: no placeholder arithmetic for a removal
+  ]);
+  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), ['L0003']);
+  assert.deepEqual(f.unplaced.map((l) => [l.key, l.before, l.after, l.remove]), [
+    ['L0001', 'Skip to content', '', true],
+    ['L0004', '{…} of {…} shipped', '', true],
+  ]);
+});
+
+test('a draft of only removals still submits: its batch is empty and every line goes to an engineer', () => {
+  const f = pages.freezeBatch({ readingPage: READING, draft: draftOf([{ key: 'L0006', remove: true }]), submittedAt: 'S' });
+  assert.equal(f.ok, true, JSON.stringify(f));
+  assert.deepEqual(f.batch.lines, []);
+  assert.deepEqual(f.unplaced.map((l) => l.key), ['L0006']);
+});
+
+test('a removal the page no longer shows is refused target_gone, like any line', () => {
+  const draft = draftOf([{ key: 'L0006', remove: true }]);
+  const moved = { ...READING, reading_hash: 'h-next', lines: READING.lines.filter((l) => l.key !== 'L0006') };
+  const f = pages.freezeBatch({ readingPage: moved, draft, submittedAt: 'S' });
+  assert.equal(f.code, 'lines_refused');
+  assert.deepEqual(f.detail.refused.map((x) => [x.key, x.code]), [['L0006', 'target_gone']]);
+});
+
+test('the removal task is worded as a removal: what to take out, where, and that the round does not wait', () => {
+  const page = { id: 'landing:index', title: 'Home', path: '/' };
+  const line = { key: 'L0006', section: 'footer', before: 'Resume', after: '', placement: 'placed', remove: true };
+  assert.equal(pages.unplacedTaskTitle(page, line), 'Remove "Resume" (landing:index)');
+  const b = pages.unplacedTaskBody(page, line, '5001');
+  for (const want of ['landing:index', 'Home', 'L0006', 'footer', '"Resume"', 'take it out', 'task 5001', 'does not wait']) {
+    assert.ok(b.includes(want), `the body names ${want}`);
+  }
+  assert.doesNotMatch(b, /artist's wording/, 'there is no new wording to apply');
+  const shared = pages.unplacedTaskBody(page, { ...line, placement: 'shared' }, '5001');
+  assert.match(shared, /removes it everywhere/);
+  assert.equal(pages.unplacedSourceRef('5001', 'L0006'), 'page-tweak-unplaced/5001/L0006', 'keyed like any engineer line, so a repeated submit finds it');
+});
+
 console.log(`\ncopy_page_draft: ${passed} passed, ${failed} failed`);
 if (failed) process.exit(1);

package/modules/government/decision-rules.js

@@ -66,6 +66,7 @@ const AREAS = Object.freeze([
     today: 'whoever may change the project settings', acts: Object.freeze([
       'PATCH /project-settings/rot-days',
       'PATCH /project-settings/ship-mode',
+      'PATCH /project-settings/tweak-autopickup',
       'PATCH /work-categories/:id',
     ]) }),
   Object.freeze({ key: 'disputes', name: 'Disputes', gate: 'security.report.adjudicate',