@bongos/core 1.21.167 → 1.21.169

package/modules/autonomy/governor-docket.js

@@ -46,7 +46,9 @@ function fenceDocketMatters(project, mayManage) {
   return [{
     id: 'fence',
     rule: 'decide',
-    state: mayManage ? 'needs' : 'settled',
+    // a standing state, not a to-do (owner, 2026-10-23): the switch lives on the
+    // Automation switchboard (automation.switch desk), so it never counts as on you
+    state: 'settled',
     title,
     short: 'the switch',
     where,
@@ -77,11 +79,14 @@ const PAUSE_REASONS = Object.freeze([
 
 // The Automation desks (task 1004559): rows the holder of autonomy.fence.manage
 // acts on in place. Pure; exported for tests.
-// The switch when it is on and has goals (otherwise the fence matter carries it).
+// The switch, in either position: the Automation switchboard's master row.
 function switchDeskRows(project) {
-  const goals = Array.isArray(project && project.goals) ? project.goals : [];
-  if (!project || project.enabled === false || !goals.length) return [];
-  return [{ id: 'switch', name: 'The switch', fact: `on · ${goals.length} ${goals.length === 1 ? 'goal' : 'goals'}`, facts: ['unattended building is on'], opened_at: project.updated_at || null, ref: { type: 'autonomy_fence', id: 'project' }, acts: [{ key: 'switch_off', options: OFF_REASONS }] }];
+  if (!project) return [];
+  const goals = Array.isArray(project.goals) ? project.goals : [];
+  if (project.enabled === false) {
+    return [{ id: 'switch', name: 'The switch', fact: 'off', facts: [project.paused_reason ? String(project.paused_reason).trim() : 'AI building: off'], opened_at: project.updated_at || null, ref: { type: 'autonomy_fence', id: 'project' }, acts: [{ key: 'switch_on' }] }];
+  }
+  return [{ id: 'switch', name: 'The switch', fact: `on · ${goals.length} ${goals.length === 1 ? 'goal' : 'goals'}`, facts: [goals.length ? 'AI building: on' : 'AI building: on, but no goal is allowed yet'], opened_at: project.updated_at || null, ref: { type: 'autonomy_fence', id: 'project' }, acts: [{ key: 'switch_off', options: OFF_REASONS }] }];
 }
 // One row per allowed goal (first in line, or not allowed any more), and one to
 // allow another of the open goals the screen already reads.

package/modules/builder-settings/builder-needs.js

@@ -245,7 +245,32 @@ function mingleIntroductionsNeed(ctx) {
   };
 }
 
-const NEEDS = [artKeyNeed, helpRequestsNeed, taskRecommendationsNeed, boardVotesNeed, mingleIntroductionsNeed];
+// task 1004777: a page tweak that has sat too long, one line PER PAGE. The
+// copy-desk port (copy-desk.stuckPageTweaksFor) has already chosen who is told:
+// a review left waiting goes to its artist, everything else to Metic+. Each item
+// says where the page is and for how long, and links to the Studio.
+// ctx.stuckPageTweaks — [{ page_id, title, state_word, days }]; absent = none.
+function stuckPageTweakNeeds(ctx) {
+  const list = Array.isArray(ctx.stuckPageTweaks) ? ctx.stuckPageTweaks : [];
+  return list.map((s) => {
+    // A templated title ({{productName}}…) falls back to the page id. The same
+    // sniff sits in copy-desk page-status.js stuckDigestText, duplicated on
+    // purpose: this module cannot require copy-desk (ADR 0093).
+    const name = String(s.title || '').includes('{{') ? s.page_id : (s.title || s.page_id);
+    const days = Number.isFinite(Number(s.days)) && s.days != null ? Number(s.days) : null;
+    return {
+      id: `page_tweak_stuck:${s.page_id}`,
+      title: `Page tweak stuck: ${name}`,
+      what: 'A page tweak has sat in one place longer than it should.',
+      state: 'action_needed',
+      severity: 'info',
+      message: `${s.state_word}${days != null ? ` for ${days} day${days === 1 ? '' : 's'}` : ''}.`,
+      action: { label: 'Open the Studio', href: '/studio' },
+    };
+  });
+}
+
+const NEEDS = [artKeyNeed, helpRequestsNeed, taskRecommendationsNeed, boardVotesNeed, mingleIntroductionsNeed, stuckPageTweakNeeds];
 
 // Priority WITHIN a state bucket (task 1003738). computeNeeds used to sort by
 // state alone with a stable sort, so the NEEDS array order silently decided
@@ -275,6 +300,7 @@ const NEED_PRIORITY = {
   art_key: 2,
   task_recommendations: 3,
   mingle_introductions: 4,
+  // page_tweak_stuck:<page> ids carry no weight entry and sort last in their bucket.
 };
 
 // ---- founding grace (task 1002739 / direction §5.6, idea 1000701) -----------
@@ -333,7 +359,7 @@ function foundingWelcomeNeed(ctx) {
 // drop. Home's "From the system" inbox does exactly that.
 function computeNeeds(ctx = {}) {
   const grace = foundingGraceActive(ctx);
-  let items = NEEDS.map((fn) => fn(ctx)).filter(Boolean);
+  let items = NEEDS.flatMap((fn) => fn(ctx)).filter(Boolean);
   if (grace) {
     items = items.map((n) => n.state !== 'action_needed' ? n : {
       ...n,
@@ -359,7 +385,7 @@ module.exports = {
   computeNeeds,
   // exported for tests / direct reuse
   artKeyNeed,
-  helpRequestsNeed, taskRecommendationsNeed, boardVotesNeed, mingleIntroductionsNeed,
+  helpRequestsNeed, taskRecommendationsNeed, boardVotesNeed, mingleIntroductionsNeed, stuckPageTweakNeeds,
   foundingGraceActive,
   FOUNDING_GRACE_DAYS,
   SETTINGS_PATH,

package/modules/copy-desk/guarded-lines.js

@@ -0,0 +1,89 @@
+'use strict';
+
+// guarded-lines.js — page lines that must keep their meaning (task 1004776).
+//
+// WHY. Some page lines carry a promise the product must keep: the Account page's
+// Private option must say the page is hidden from everyone, its owner included
+// (tests/account_privacy_flags.mjs asserts it). An artist rewrote it to "you are a
+// ninja." and only found out after approving, when CI went red. So the editor says
+// so WHILE they write: the line carries its "must still say" sentence, and a
+// submit whose new text drops what the note requires is WARNED — never refused,
+// the artist may have a better wording — and the warning rides into the batch, so
+// the applier and the Approval queue show it too.
+//
+// The list is guarded-lines.json beside this file. A guarded line is found on its
+// page by its FILE plus every must_contain phrase (case-insensitive), not by a
+// reading key or string id: both of those move when the line is rewritten, and a
+// rewrite that keeps the promise must keep the guard. Pure; the JSON is read once.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const LIST_PATH = path.join(__dirname, 'guarded-lines.json');
+let cached = null;
+function loadList() {
+  if (!cached) {
+    try { cached = JSON.parse(fs.readFileSync(LIST_PATH, 'utf8')); } catch { cached = { lines: [] }; }
+  }
+  return cached;
+}
+
+const lower = (s) => String(s == null ? '' : s).toLowerCase();
+
+function missingPhrases(entry, text) {
+  const t = lower(text);
+  return (entry.must_contain || []).filter((p) => !t.includes(lower(p)));
+}
+
+// The guard entries for one page.
+function guardsFor(pageId, list = loadList()) {
+  return ((list && list.lines) || []).filter((e) => e && e.page_id === pageId);
+}
+
+// guardForLine(pageId, line) -> entry | null. `line` is a reading line
+// ({ text, file }); a line with no file matches on its text alone.
+function guardForLine(pageId, line, list = loadList()) {
+  if (!line) return null;
+  for (const e of guardsFor(pageId, list)) {
+    if (e.file && line.file && e.file !== line.file) continue;
+    if (!missingPhrases(e, line.text).length) return e;
+  }
+  return null;
+}
+
+// guardWarnings({ pageId, readingPage, lines }) -> [{ key, must_still_say, missing, guarded_by }]
+// `lines` are the submitted lines ({ key, after, remove? }); each is looked up on
+// the CURRENT reading by key, and warned when that reading line is guarded and the
+// new text drops a required phrase (a removal drops all of them).
+function guardWarnings({ pageId, readingPage, lines }, list = loadList()) {
+  const byKey = new Map(((readingPage && readingPage.lines) || []).map((l) => [l.key, l]));
+  const out = [];
+  for (const l of lines || []) {
+    const at = byKey.get(l.key);
+    const g = at ? guardForLine(pageId, at, list) : null;
+    if (!g) continue;
+    const missing = l.remove ? (g.must_contain || []).slice() : missingPhrases(g, l.after);
+    if (missing.length) out.push({ key: l.key, must_still_say: g.must_still_say, missing, guarded_by: g.guarded_by || null });
+  }
+  return out;
+}
+
+// checkList(readings) -> [{ page_id, problem }] — every entry must find exactly
+// one line on its page in docs/page-readings.json (the honesty check).
+function checkList(readings, list = loadList()) {
+  const pages = new Map(((readings && readings.pages) || []).map((p) => [p.id, p]));
+  const problems = [];
+  for (const e of (list && list.lines) || []) {
+    const page = pages.get(e.page_id);
+    if (!page) { problems.push({ page_id: e.page_id, problem: 'no such page in docs/page-readings.json' }); continue; }
+    if (!e.must_still_say || !Array.isArray(e.must_contain) || !e.must_contain.length) { problems.push({ page_id: e.page_id, problem: 'needs must_still_say and at least one must_contain phrase' }); continue; }
+    const hits = new Set(page.lines.filter((l) => guardForLine(e.page_id, l, { lines: [e] })).map((l) => l.text));
+    if (hits.size !== 1) problems.push({ page_id: e.page_id, problem: `matches ${hits.size} distinct lines (want exactly 1): ${e.must_contain.join(' + ')}` });
+  }
+  return problems;
+}
+
+// Test seam: a fixture list for the route-level tests; null goes back to the file.
+function _setList(list) { cached = list; }
+
+module.exports = { _setList, LIST_PATH, loadList, guardsFor, guardForLine, guardWarnings, checkList, missingPhrases };

package/modules/copy-desk/guarded-lines.json

@@ -0,0 +1,14 @@
+{
+  "schema": 1,
+  "task": 1004776,
+  "how": "Page lines that carry a promise the product must keep. A line is found on its page by its file plus every must_contain phrase (case-insensitive), so a rewrite that keeps the promise keeps the guard. The tweak editor shows must_still_say under the line, and a submit whose new text drops a phrase is warned (never refused). guarded_by names the test that asserts the meaning. tests/copy_guarded_lines.mjs checks every entry still finds exactly one line in docs/page-readings.json.",
+  "lines": [
+    {
+      "page_id": "landing:account",
+      "file": "modules/public-landing/public/account.html",
+      "must_contain": ["Private hides the page from everyone", "including you"],
+      "must_still_say": "Private hides the page from everyone, including its owner.",
+      "guarded_by": "tests/account_privacy_flags.mjs"
+    }
+  ]
+}

package/modules/copy-desk/module.json

@@ -7,7 +7,7 @@
   "category": { "parent": "quality" },
   "default": true,
   "maintenance": { "status": "core-maintained" },
-  "contributes": { "routes": ["copy-desk", "copy-desk-artist"], "migrations": true, "skills": ["tweak"] },
-  "provides": ["copy-desk.artistStats"],
+  "contributes": { "routes": ["copy-desk", "copy-desk-artist"], "migrations": true, "skills": ["tweak"], "pollers": ["stuck-page-digest"] },
+  "provides": ["copy-desk.artistStats", "copy-desk.stuckPageTweaksFor"],
   "consumes": ["lifecycle"]
 }

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

@@ -33,6 +33,7 @@
 'use strict';
 
 const pages = require('./pages');
+const guarded = require('./guarded-lines');
 
 const TERMINAL = new Set(['shipped', 'abandoned']);
 
@@ -277,7 +278,8 @@ function orderedSurfaces(inventory) {
 // (applied rounds only) stayed empty: the artist's finished work looked lost.
 // This is every page with an open round, where it is, since when (the round's
 // last update), and whether it has sat there too long. Waiting for review is
-// the artist's own move and a draft is theirs to finish, so neither is stuck;
+// the artist's own move and a draft is theirs to finish; a draft is never stuck,
+// and a review is stuck only after 3 days (task 1004777, so its artist is told);
 // a state the reads cannot name always needs a look.
 // ---------------------------------------------------------------------------
 
@@ -287,7 +289,8 @@ const IN_FLIGHT = Object.freeze({
   writing: { word: 'Being written', stuck_after: null },
   submitted: { word: 'Submitted, waiting to be applied', stuck_after: 3 * DAY_MS },
   applying: { word: 'Being applied', stuck_after: DAY_MS },
-  waiting_for_artist: { word: 'Waiting for your review', stuck_after: null },
+  // task 1004777: a review left 3 days is stuck too, so its artist is told on Home.
+  waiting_for_artist: { word: 'Waiting for your review', stuck_after: 3 * DAY_MS },
   landing: { word: 'Approved, going live', stuck_after: DAY_MS },
   unknown: { word: 'Needs a look', stuck_after: 0 },
 });
@@ -313,12 +316,64 @@ function inFlightFor(list, byPage, nowMs) {
       since,
       stuck: kind.stuck_after != null && (kind.stuck_after === 0 || (age != null && age > kind.stuck_after)),
       holder: o.holder,
+      artist_id: r.artist_id != null ? String(r.artist_id) : null,
     });
   }
   const rank = (s) => { const i = IN_FLIGHT_ORDER.indexOf(s); return i === -1 ? 0 : i; };
   return out.sort((a, b) => (b.stuck - a.stuck) || rank(a.state) - rank(b.state) || String(a.since || '').localeCompare(String(b.since || '')));
 }
 
+// ---------------------------------------------------------------------------
+// Stuck page tweaks, told to someone (task 1004777). The Studio's in-flight list
+// marks a stuck round, but only for whoever opens the Studio, and 11 rounds sat
+// from late September unseen. The SAME list and stuck rule, derived from the
+// ledger (no status table), now feeds two pushes: a Needs-attention line on Home
+// for the person it waits on, and a once-a-day Discord digest.
+//
+// Who it waits on: a round waiting for review waits on ITS ARTIST; every other
+// stuck state (submitted and not applied, being applied, approved but not live,
+// a state the reads cannot name) waits on the builders who can apply and land
+// work, Metic and up.
+// ---------------------------------------------------------------------------
+
+const APPLIER_RANKS = new Set(['metic', 'archon']);
+
+function stuckPageTweaks({ inventory, tasks, now = Date.now() }) {
+  const { in_flight: inFlight } = composePages({ inventory, readings: null, tasks, now });
+  const nowMs = now instanceof Date ? now.getTime() : Number(now);
+  return inFlight.filter((f) => f.stuck).map((f) => {
+    const ms = f.since ? nowMs - Date.parse(f.since) : null;
+    return {
+      page_id: f.page_id,
+      title: f.title,
+      task_id: f.task_id,
+      state: f.state,
+      state_word: f.state_word,
+      since: f.since,
+      days: ms == null ? null : Math.max(0, Math.floor(ms / DAY_MS)),
+      waits_on: f.state === 'waiting_for_artist' ? 'artist' : 'appliers',
+      artist_id: f.artist_id,
+    };
+  });
+}
+
+// The stuck tweaks one builder should be told about on Home.
+function stuckPageTweaksFor({ builderId, rank, stuck }) {
+  const applier = APPLIER_RANKS.has(String(rank || '').toLowerCase());
+  return (stuck || []).filter((s) => (s.waits_on === 'artist'
+    ? s.artist_id != null && String(s.artist_id) === String(builderId)
+    : applier));
+}
+
+// The Discord digest: page names and where each sits, never the words.
+function stuckDigestText(stuck) {
+  if (!stuck || !stuck.length) return null;
+  const plain = (s) => String(s || '').replace(/\{\{[^}]*\}\}/g, '').replace(/[`*_~|<>@]/g, '').replace(/\s+/g, ' ').trim();
+  const name = (s) => (String(s.title || '').includes('{{') ? s.page_id : plain(s.title) || s.page_id);
+  const lines = stuck.map((s) => `- ${name(s)}: ${s.state_word.toLowerCase()}${s.days != null ? `, ${s.days} day${s.days === 1 ? '' : 's'}` : ''}`);
+  return [`Page tweaks stuck (${stuck.length}). Open the Studio to move them:`, ...lines].join('\n');
+}
+
 // GET /copy-desk/pages — every page's status, count and drift, plus the
 // per-surface rollup (Artist Review Status) and the pages in flight.
 function composePages({ inventory, readings, tasks, now = Date.now() }) {
@@ -605,9 +660,12 @@ function composeNext({ inventory, readings, tasks, asks, builderId, alternatives
 // The margin note a line carries in the editor (ADR 0341 D4, TW10): shared
 // shell text changes on every page, and a line the applier cannot place goes
 // to an engineer at submit (pages.goesToEngineer, the submit's own rule).
-const EDITOR_NOTES = Object.freeze({ shared: 'changes this on every page', engineer: 'goes to an engineer' });
+// task 1004776: a third kind, `guarded` — the line carries a promise the product
+// must keep (guarded-lines.json); the line also carries `must_still_say`.
+const EDITOR_NOTES = Object.freeze({ shared: 'changes this on every page', engineer: 'goes to an engineer', guarded: 'must still say' });
 
-function editorNote(line) {
+function editorNote(line, pageId) {
+  if (pageId && guarded.guardForLine(pageId, line)) return 'guarded';
   if (pages.goesToEngineer(line)) return 'engineer';
   return line.placement === 'shared' ? 'shared' : null;
 }
@@ -622,9 +680,13 @@ function editorNote(line) {
 // page has not been read); `round` is the page's open round as the lifecycle
 // port lists it, or null.
 function composeEditor({ page, readingPage, round, builderId }) {
-  const lines = ((readingPage && readingPage.lines) || []).map((l) => ({
-    key: l.key, section: l.section, text: l.text, placement: l.placement, note: editorNote(l),
-  }));
+  const lines = ((readingPage && readingPage.lines) || []).map((l) => {
+    const g = guarded.guardForLine(page.id, l);
+    return {
+      key: l.key, section: l.section, text: l.text, placement: l.placement, note: editorNote(l, page.id),
+      ...(g ? { must_still_say: g.must_still_say, must_contain: (g.must_contain || []).slice() } : {}),
+    };
+  });
   const readingHash = readingPage ? readingPage.reading_hash || null : null;
   let draft = null;
   let olderReading = false;
@@ -693,6 +755,9 @@ function approvalFor({ page, pageId, rounds, round, builderId, isArtist }) {
   if (applied.ok) for (const r of applied.applied.refused || []) if (r && r.key) refusedBy.set(String(r.key), String(r.code || 'refused'));
   const pinnedBy = new Map();
   if (applied.ok) for (const p of applied.applied.pinned_tests || []) if (p && p.key && Array.isArray(p.tests)) pinnedBy.set(String(p.key), p.tests.map(String));
+  // task 1004776: the submit's guarded-line warnings, by line.
+  const warnedBy = new Map();
+  if (batch.ok) for (const w of batch.batch.warnings || []) if (w && w.key) warnedBy.set(String(w.key), String(w.must_still_say || ''));
   const lines = batch.ok ? batch.batch.lines.map((l) => ({
     key: l.key,
     section: l.section == null ? null : l.section,
@@ -701,6 +766,7 @@ function approvalFor({ page, pageId, rounds, round, builderId, isArtist }) {
     placement: l.placement || null,
     refused: refusedBy.get(String(l.key)) || null,
     ...(pinnedBy.has(String(l.key)) ? { pinned_by: pinnedBy.get(String(l.key)) } : {}),
+    ...(warnedBy.has(String(l.key)) ? { must_still_say: warnedBy.get(String(l.key)) } : {}),
   })) : [];
   const shipped = (rounds || []).filter((r) => r.status === 'shipped');
   const now = countsFor(rounds);
@@ -823,4 +889,8 @@ module.exports = {
   lastRoundShippedAt,
   composeTally,
   composeArtistStats,
+  // task 1004777: stuck page tweaks, pushed to Home and Discord.
+  stuckPageTweaks,
+  stuckPageTweaksFor,
+  stuckDigestText,
 };

package/modules/copy-desk/pages.js

@@ -145,6 +145,10 @@ function composeBatchBlock(b) {
     file: l.file == null ? null : l.file, line: l.line == null ? null : l.line, string_id: l.string_id == null ? null : l.string_id,
   }));
   out.unplaced_tasks = Array.isArray(b.unplaced_tasks) ? b.unplaced_tasks : [];
+  // task 1004776: a guarded line whose new text drops what it must still say.
+  if (Array.isArray(b.warnings) && b.warnings.length) {
+    out.warnings = b.warnings.map((w) => ({ key: w.key, must_still_say: w.must_still_say, missing: (w.missing || []).map(String), guarded_by: w.guarded_by || null }));
+  }
   return fenceBlock(FENCES.batch, out);
 }
 

package/modules/copy-desk/pollers/stuck-page-digest.js

@@ -0,0 +1,34 @@
+'use strict';
+
+// modules/copy-desk/pollers/stuck-page-digest.js — the once-a-day Discord digest
+// of stuck page tweaks (task 1004777). Loader-started (contributes.pollers); the
+// rule and the post live in ../stuck-tweaks.js. Checks hourly; posts at most once
+// per UTC day, after COPY_STUCK_DIGEST_HOUR_UTC (default 9), and only when a page
+// is stuck. Best-effort: a failed read or post logs and waits for tomorrow.
+// COPY_STUCK_DIGEST_DISABLED=1 turns it off.
+
+const api = require('../../../src/module-api');
+const stuck = require('../stuck-tweaks');
+
+const log = api.logger('copy-desk');
+const INTERVAL_MS = Number(process.env.COPY_STUCK_DIGEST_MS) || 60 * 60_000;
+const state = { lastDay: null };
+let timer = null;
+
+function tick() {
+  stuck.runDigest({ state })
+    .then((r) => { if (r.posted) log.info(`[stuck-page-digest] posted ${r.text.split('\n').length - 1} stuck page tweak(s)`); })
+    .catch((e) => log.error(e, '[stuck-page-digest] digest failed'));
+}
+
+module.exports = {
+  start() {
+    if (process.env.COPY_STUCK_DIGEST_DISABLED === '1' || timer) return;
+    timer = setInterval(tick, INTERVAL_MS);
+    if (timer.unref) timer.unref();
+  },
+  stop() {
+    if (timer) clearInterval(timer);
+    timer = null;
+  },
+};

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

@@ -60,6 +60,7 @@ const proposals = require('../proposals');
 const pageData = require('../page-data');
 const pageStatus = require('../page-status');
 const pages = require('../pages');
+const guarded = require('../guarded-lines');
 const docx = require('../docx');
 const { waitingRoundOrFail, refuseDecision, nextWaiting } = require('../page-decisions');
 const { tallyCreditRows, readArtistStats } = require('../artist-stats');
@@ -231,6 +232,7 @@ function alreadySubmitted(round, builderId, 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) })),
+    warnings: b.batch.warnings || [],
     next: { path: '/copy-desk/next' },
   };
 }
@@ -371,6 +373,8 @@ module.exports = function buildCopyDeskRouter() {
   if (!api.hasProvider('copy-desk.artistStats')) {
     api.registerProvider('copy-desk.artistStats', readArtistStats);
   }
+  // task 1004777: Home's Needs-attention reads stuck page tweaks through this port.
+  if (!api.hasProvider('copy-desk.stuckPageTweaksFor')) api.registerProvider('copy-desk.stuckPageTweaksFor', require('../stuck-tweaks').readStuckFor);
 
   // Page asks resolve when the page's tweak ships (ADR 0341 D6). Re-registered
   // on every router build (tests rebuild it), never stacked.
@@ -1299,6 +1303,9 @@ module.exports = function buildCopyDeskRouter() {
           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;
+          // task 1004776: warn (never refuse) on a guarded line that drops its promise;
+          // the warning rides in the batch so the applier and the Approval queue see it.
+          f.batch.warnings = guarded.guardWarnings({ pageId, readingPage, lines: d.draft.lines });
           const probe = pages.replaceBlock(task.description, pages.FENCES.batch, '');
           if (!probe.ok) return probe;
           frozen = f;
@@ -1323,6 +1330,7 @@ module.exports = function buildCopyDeskRouter() {
             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 },
+            warnings: frozen.batch.warnings || [],
             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' },

package/modules/copy-desk/stuck-tweaks.js

@@ -0,0 +1,79 @@
+'use strict';
+
+// stuck-tweaks.js — a page tweak that sits too long tells someone (task 1004777).
+//
+// The composer is page-status.js (stuckPageTweaks: the Studio's in-flight list
+// and its stuck rule, derived from the ledger, no status table). This file is the
+// I/O around it, kept out of routes/copy-desk.js, which sits at its line ratchet:
+//
+//   • readStuckFor(builderId, rank) — the `copy-desk.stuckPageTweaksFor` port the
+//     kernel /me route reads for the Home Needs-attention inbox. Fails soft ([]).
+//   • the daily digest — at most one post per UTC day to the Discord ship channel
+//     (the `discord.post` port; no Discord, no post), page names only, never copy.
+
+const api = require('../../src/module-api');
+const pageData = require('./page-data');
+const pageStatus = require('./page-status');
+
+const DIGEST_CHANNEL = 'ship_feed';
+const DIGEST_HOUR_UTC = Number(process.env.COPY_STUCK_DIGEST_HOUR_UTC) || 9;
+
+async function readStuck({ now = Date.now(), resolve = (k) => (api.resolveOptional ? api.resolveOptional(k) : null) } = {}) {
+  const inv = pageData.loadInventory();
+  if (!inv.ok) return [];
+  const lifecycle = resolve('lifecycle');
+  if (!lifecycle || typeof lifecycle.listPageTweakTasks !== 'function') return [];
+  const tasks = await lifecycle.listPageTweakTasks();
+  return pageStatus.stuckPageTweaks({ inventory: inv.data, tasks, now });
+}
+
+// The stuck list is the same for every builder and only the audience filter is
+// per builder, while GET /me (the hall's busiest boot read) asks on every page
+// load. So the list is read at most once per CACHE_MS across ALL builders and
+// requests (the modules/lifecycle/sky.js precedent): a stuck rule measured in
+// days loses nothing to a minute of staleness, and one in-flight read is shared
+// by concurrent callers rather than repeated.
+const CACHE_MS = Number(process.env.COPY_STUCK_CACHE_MS) || 60_000;
+let cache = { at: 0, p: null };
+function readStuckCached({ nowMs = Date.now(), read = readStuck } = {}) {
+  if (!cache.p || nowMs - cache.at >= CACHE_MS) {
+    const p = read({ now: nowMs }).catch(() => []);
+    cache = { at: nowMs, p };
+  }
+  return cache.p;
+}
+function _resetCache() { cache = { at: 0, p: null }; }
+
+async function readStuckFor(builderId, rank, opts = {}) {
+  try {
+    return pageStatus.stuckPageTweaksFor({ builderId, rank, stuck: await readStuckCached(opts) });
+  } catch (_) {
+    return [];
+  }
+}
+
+// The digest's once-a-day rule, pure: post when it is past the digest hour and
+// nothing has been posted on this UTC day. `lastDay` is the day key last posted.
+function digestDue({ nowMs, lastDay, hour = DIGEST_HOUR_UTC }) {
+  const d = new Date(nowMs);
+  const day = d.toISOString().slice(0, 10);
+  return { due: d.getUTCHours() >= hour && lastDay !== day, day };
+}
+
+// One digest attempt. Returns what happened, so the poller and the tests read
+// the same outcome. A page that is not stuck produces nothing; no stuck page,
+// no post.
+async function runDigest({ nowMs = Date.now(), state, post, readStuckImpl = readStuck } = {}) {
+  const { due, day } = digestDue({ nowMs, lastDay: state.lastDay });
+  if (!due) return { posted: false, reason: 'not_due' };
+  const stuck = await readStuckImpl({ now: nowMs });
+  state.lastDay = day; // checked once a day, posted or not
+  const text = pageStatus.stuckDigestText(stuck);
+  if (!text) return { posted: false, reason: 'nothing_stuck' };
+  const port = post || (api.resolveOptional ? api.resolveOptional('discord.post', null) : null);
+  if (typeof port !== 'function') return { posted: false, reason: 'no_discord' };
+  const r = await port({ channel: DIGEST_CHANNEL, text });
+  return { posted: !!(r && r.posted), reason: r && r.reason, text };
+}
+
+module.exports = { DIGEST_CHANNEL, DIGEST_HOUR_UTC, CACHE_MS, readStuck, readStuckCached, readStuckFor, digestDue, runDigest, _resetCache };

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

@@ -300,7 +300,12 @@ await test('the module manifest declares no seam another module could write copy
   // profile's artist numbers. Anything more provided here would be a seam
   // another module could reach copy through, so the list is pinned exactly and
   // the provider is held to returning no wording below.
-  assert.deepEqual(manifest.provides, ['copy-desk.artistStats'], 'a provided port here would be a copy write path for every other module');
+  // task 1004777 adds a second READ: copy-desk.stuckPageTweaksFor, the stuck
+  // page tweaks for Home's Needs-attention. It returns page ids, titles, state
+  // words and day counts, never a line of copy, and writes nothing.
+  assert.deepEqual(manifest.provides, ['copy-desk.artistStats', 'copy-desk.stuckPageTweaksFor'], 'a provided port here would be a copy write path for every other module');
+  const stuckSrc = stripComments(read('stuck-tweaks.js'));
+  assert.equal(/writeFile|\.query\(|UPDATE |INSERT /.test(stuckSrc), false, 'the stuck-tweaks port writes nothing');
   const stats = read('artist-stats.js');
   assert.equal(/\b(pool|query|writeFile|appendFile|INSERT|UPDATE|DELETE)\b/.test(stats.replace(/\/\/.*$/gm, '')), false,
     'the artist-stats port reads through other ports and writes nothing');

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

@@ -263,10 +263,10 @@ await test('in_flight: every open round, its plain state, how long, and stuck wh
     ['landing:c', 'landing', 'Approved, going live', true],
     ['status:h', 'applying', 'Being applied', true],
     ['landing:a', 'submitted', 'Submitted, waiting to be applied', true],
+    ['builders:d', 'waiting_for_artist', 'Waiting for your review', true],
     ['landing:b', 'submitted', 'Submitted, waiting to be applied', false],
-    ['builders:d', 'waiting_for_artist', 'Waiting for your review', false],
     ['builders:e', 'writing', 'Being written', false],
-  ], 'a shipped round is not in flight; waiting for review and writing are never stuck');
+  ], 'a shipped round is not in flight; writing is never stuck, and a review left 20 days is (task 1004777)');
   assert.equal(out.in_flight[1].since, ago(17));
   assert.equal(out.in_flight[1].task_id, '3');
   assert.equal(out.pages.find((p) => p.id === 'landing:a').status_label, 'Untweaked', 'the status still counts only what shipped');

package/modules/government/asks-db.js

@@ -18,7 +18,9 @@ const asks = require('./asks');
 const MAX_READ = 500;
 
 // Store (or replace) one matter's ask. `ask` is checkAsk's stored form.
-async function saveAsk({ matterId, ask, builderId }) {
+// A rewrite closes the matter's reword flag (government_032); a pass to
+// another seat keeps the words, so it passes resolveFlag: false.
+async function saveAsk({ matterId, ask, builderId, resolveFlag = true }) {
   if (!asks.isMatterId(matterId)) throw Object.assign(new Error('bad matter id'), { code: 'BAD_MATTER_ID' });
   const { rows } = await pool.query(
     `INSERT INTO government_asks
@@ -33,6 +35,7 @@ async function saveAsk({ matterId, ask, builderId }) {
     [matterId, ask.question, JSON.stringify(ask.options), ask.recommend.key, ask.recommend.why,
       ask.waits_on, ask.if_nobody_answers, ask.detail || null, builderId == null ? null : builderId],
   );
+  if (resolveFlag) await pool.query('UPDATE government_ask_flags SET resolved_at = now() WHERE matter_id = $1 AND resolved_at IS NULL', [matterId]);
   return asks.fromRow(rows[0]);
 }
 
@@ -51,4 +54,37 @@ async function asksFor(matterIds) {
   return out;
 }
 
-module.exports = { saveAsk, asksFor, MAX_READ };
+// ---------- the reword list (government_032, owner 2026-10-23) ----------
+// A reader pressed "?" on a card: this matter's words did not make sense.
+// Flagging again reopens a resolved flag and counts the time.
+async function flagUnclear({ matterId, builderId, note }) {
+  if (!asks.isMatterId(matterId)) throw Object.assign(new Error('bad matter id'), { code: 'BAD_MATTER_ID' });
+  const text = typeof note === 'string' && note.trim() ? note.trim().slice(0, 500) : null;
+  const { rows } = await pool.query(
+    `INSERT INTO government_ask_flags (matter_id, flagged_by, note)
+     VALUES ($1, $2, $3)
+     ON CONFLICT (matter_id) DO UPDATE
+        SET flagged_by = EXCLUDED.flagged_by, flagged_at = now(), resolved_at = NULL,
+            note = COALESCE(EXCLUDED.note, government_ask_flags.note),
+            times = government_ask_flags.times + 1
+     RETURNING matter_id, flagged_at, note, times`,
+    [matterId, builderId == null ? null : builderId, text],
+  );
+  return rows[0];
+}
+
+// The OPEN flags of these matters → Map(matter_id → { flagged_at, note, times }).
+async function unclearFor(matterIds) {
+  const ids = [...new Set((Array.isArray(matterIds) ? matterIds : []).filter(asks.isMatterId))].slice(0, MAX_READ);
+  const out = new Map();
+  if (!ids.length) return out;
+  const { rows } = await pool.query(
+    `SELECT matter_id, flagged_at, note, times FROM government_ask_flags
+      WHERE resolved_at IS NULL AND matter_id = ANY($1::text[])`,
+    [ids],
+  );
+  for (const r of rows) out.set(r.matter_id, { flagged_at: r.flagged_at, note: r.note, times: r.times });
+  return out;
+}
+
+module.exports = { saveAsk, asksFor, flagUnclear, unclearFor, MAX_READ };

package/modules/government/catalog.js

@@ -230,7 +230,7 @@ const PERMISSIONS = [
   { key: 'module.assessment.rerun', system: false, floor: 'metic', guards: 'POST /store/modules/:key/versions/:version/reassess' },
   // Take a module out of the store (task 1003797, ADR 0338 D2). Stops new installs,
   // versions and downloads; never reaches an instance that already holds it.
-  { key: 'module.delist', system: false, floor: 'metic', guards: 'POST /store/modules/:key/delist' },
+  { key: 'module.delist', system: false, floor: 'metic', guards: 'POST /store/modules/:key/delist, POST /store/modules/:key/versions/:version/release (a version the promotion gate held on tester — task 1003804)' },
   { key: 'security.report.file', system: false, floor: 'metic', guards: 'POST /security/reports, GET /security/adr' },
   { key: 'llm_cache.use', system: false, floor: 'metic', guards: 'POST /llm-cache/{lookup,store}' },
   { key: 'backup.manage', system: false, floor: 'metic', guards: 'GET /backup/status, POST /backup/trigger' },