@bongos/core 1.21.108 → 1.21.110

package/modules/hall-ui/public/craft-review.js

@@ -0,0 +1,64 @@
+// craft-review.js — the scribble wall of artist review mode (task 1004686,
+// goal 1000095). Loaded on demand by craft-mode.js, only while an artist is
+// reviewing an experience: wallHtml() returns small doodles a pen scribbles,
+// one after another, into the top bar's empty space, so the reviewer can see
+// at a glance that the hall they are looking at is under review.
+//
+// The doodles are drawn in the sky's hand (thinking.css, ADR 0331): hairlines,
+// small stars, dashed orbits and constellations, in ink alone — black on the
+// light bar, white on the dark one (owner, 2026-10-09: "small black white
+// graffiti scribbling", not the first cut's big painted tags).
+//
+// Markup only, and decorative (the wall is aria-hidden; the Review button and
+// its menu say the state in words). Every motion is CSS in craft-review.css:
+// no motion in JavaScript (DESIGN.md, the Kill Switch Rule), so a reader who
+// asks for reduced motion sees three finished doodles standing still.
+(function () {
+  'use strict';
+
+  var H = 24;
+
+  // The six doodles, in the order they are scribbled. Each is { w, wide, svg }:
+  // `wide` ones fold away when the wall is too tight for them.
+  var DOODLES = [
+    // A constellation: five stars joined by a hairline, one with a halo.
+    { w: 56, wide: true, svg:
+      '<path class="gx-ln gx-ln--soft" d="M3 17 16 8l12 5 13-9 12 7"/>' +
+      '<circle class="gx-pt" cx="3" cy="17" r="1.5"/><circle class="gx-pt" cx="16" cy="8" r="1.5"/>' +
+      '<circle class="gx-pt" cx="28" cy="13" r="1.5"/><circle class="gx-pt" cx="53" cy="11" r="1.5"/>' +
+      '<circle class="gx-pt" cx="41" cy="4" r="2"/><circle class="gx-halo" cx="41" cy="4" r="4.5"/>' },
+    // A ringed protostar on a dashed orbit, a moon riding it.
+    { w: 40, svg:
+      '<circle class="gx-ln" cx="20" cy="12" r="5"/>' +
+      '<ellipse class="gx-ln gx-ln--dash" cx="20" cy="12" rx="16" ry="4.5" transform="rotate(-16 20 12)"/>' +
+      '<circle class="gx-pt" cx="35" cy="6" r="1.3"/>' },
+    // A shooting star: a scribbled trail and a four-point head.
+    { w: 52, wide: true, svg:
+      '<path class="gx-ln gx-ln--soft" d="M2 21c9-2 18-6 31-12"/><path class="gx-ln gx-ln--soft" d="M10 22c6-1.5 12-4 19-7.5"/>' +
+      '<path class="gx-ln" d="M42 1.5v9M37.5 6h9"/><circle class="gx-pt" cx="42" cy="6" r="1.4"/>' },
+    // A crescent and a spark beside it.
+    { w: 32, svg:
+      '<path class="gx-ln" d="M16 3.5a8.5 8.5 0 1 0 9.5 12.6A7 7 0 0 1 16 3.5z"/>' +
+      '<path class="gx-ln" d="M27 2.5v5M24.5 5h5"/>' },
+    // A scribbled orbit loop, the pen going round and round.
+    { w: 40, svg:
+      '<path class="gx-ln" d="M3 15c3-8 11-9 13-4s-5 8-7 4 4-9 11-8 10 6 7 9-8 1-5-4 9-6 13 0"/>' },
+    // A cluster of sparks, big to small.
+    { w: 30, svg:
+      '<path class="gx-ln" d="M8 2.5v11M2.5 8h11"/><path class="gx-ln gx-ln--soft" d="M21 13v7M17.5 16.5h7"/>' +
+      '<circle class="gx-pt" cx="27" cy="5" r="1.2"/><circle class="gx-pt" cx="14" cy="20" r="1"/>' },
+  ];
+
+  function wallHtml() {
+    return DOODLES.map(function (d, i) {
+      return '<span class="gx-tag gx-tag--' + (i + 1) + (d.wide ? ' gx-tag--wide' : '') + '" style="--gx-w:' + d.w + 'px">' +
+        '<span class="gx-win"><span class="gx-ink">' +
+          '<svg class="gx-svg" viewBox="0 0 ' + d.w + ' ' + H + '" width="' + d.w + '" height="' + H + '" aria-hidden="true">' + d.svg + '</svg>' +
+        '</span></span>' +
+        '<span class="gx-track"><span class="gx-nib"></span></span>' +
+      '</span>';
+    }).join('');
+  }
+
+  window.OTBCraftReview = { wallHtml: wallHtml, COUNT: DOODLES.length };
+})();

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

@@ -57,6 +57,7 @@
    body declaration beats an inherited :root value at every width and a token
    tier that carries a breakpoint silently defeats its own media query. */
 @import url("page-notes.css");
+@import url("craft-review.css");
 
 :root {
   color-scheme: light;

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

@@ -57,3 +57,11 @@ Covers: every shelled hall page (`craft-mode.js`, `shell.js`, `style.css`), and
 - **The panel lists the ideas already filed from this page** (`GET /page-notes/ideas?page_path=`): open and promoted ideas whose body carries the page's link, from the lightbulb (`](/page)`) or the palette (`](/page?note=`). That link is the only record of where an idea came from, so `notes.pageLinks` and the two idea bodies are pinned together in `tests/lightbulb.mjs`.
 - **Unsent text waits in this browser only**, per page (`localStorage 'hall-lightbulb:<path>'`), and is forgotten once it files.
 - `tests/lightbulb.mjs` runs the real routes and the real script over a small DOM.
+
+## Artist review mode (task 1004686)
+
+- **Review is a split pill** (owner, 2026-10-09): pressing Review still opens the feedback doc; hovering it with a mouse, or pressing its chevron, opens a menu: "Write feedback on this page", then the four experiences in the owner's order and words (Ideator, Governing, Building, Artistry experience), then "Stop reviewing" while a review is on. Hover is asked of the pointer (`pointerType === 'mouse'`), never `(hover: hover)`: a touch laptop can report no hover at all. On a phone (<=640px) the chevron folds away and a tap on Review opens the menu.
+- **Picking one makes the hall wear that mode** (`html[data-craft]`, so its tabs, look, eyebrow and tallies follow) and stamps `html[data-craft-review]`. The artist's own mode stays Artistry: `sessionStorage['hall-craft-review']` holds the experience for the session only, and is ignored unless the mode is Artistry. Choosing any mode from the switch or the picker ends it. The artist keeps Review and Edit words; the experience's own tools follow them, marked `craft-tool--guest` so a phone under 360px can fold them away (three tools pushed 320px 36px sideways; Artistry alone overflows 4px there today, before and after).
+- **The scribble wall** (`craft-review.js`, loaded on demand; `craft-review.css`, imported by `style.css`): a flexible box in the top bar's empty space where a pen tip scribbles six small doodles in the sky's hand (thinking.css: hairlines, stars, a dashed orbit, a constellation, a crescent, a shooting star, a looped scribble, sparks), each at its own spot and height, a new one every 5s of a 30s round and each up about 10s, so two or three show at once. **Ink alone** (owner, 2026-10-09, after a first cut of big painted colour tags: "small black white graffiti scribbling"): every mark is `--ink`, black on the light bar and white on the dark, with the sky's fainter ladder for trails and orbits; the test holds the wall section to that one token. No doodle is wider than 56px or taller than 24px; the two widest fold away on a wall under 58px (Governing at 1440px keeps about 60), all of them under 34px and on a phone. The wipe is two opposite `translateX` moves, so every motion is transform or opacity in CSS, and the kill switch leaves three doodles standing, finished, with no pen. A doodle not yet begun keeps its pen unseen (`gx-track` starts at opacity 0), or each waiting tip shows as a stray dot.
+- **An @import lands before style.css's own rules**, so a rule in `craft-review.css` that restyles `.craft-tool` needs two classes, or `.craft-tool` silently wins (it did, for the reviewing wash and the guest fold, until measured).
+- `tests/craft_review_mode.mjs` runs the real `craft-mode.js` and `craft-review.js` over a small DOM, and reads the sheet's motion rules.

package/modules/lifecycle/autopickup-files.js

@@ -0,0 +1,140 @@
+'use strict';
+
+// modules/lifecycle/autopickup-files.js — an automatic page tweak may change only
+// its own page (task 1004678 / BV2.TW19b, ADR 0371 D7, D8).
+//
+// The Autobongos tweak lane claims a round with the auto_pickup mark (task
+// 1004677) and runs `/tweak --page <id> --unattended` with nobody watching. The
+// skill tells the worker to stay inside the page; this file is why the server
+// does not have to TRUST that. At publish, the route asks `autoPickupFileRefusal`
+// for the task; when the round's latest claim carries the mark, the server reads
+// the pull request's files itself (GitHub, never the client's list) and refuses
+// the publish if any path is
+//
+//   - outside the page's own files (docs/page-inventory.json `files` +
+//     `states_files`) and not one of the files a ship regenerates anyway, or
+//   - a protected path (ADR 0043's matcher, the same one decideTask runs).
+//
+// FAIL CLOSED. A page id that does not parse, a page the inventory does not know,
+// a file read that throws, or a list at GitHub's cap (it stops at 300 and says
+// nothing) all refuse: an unattended round that cannot be checked is a round a
+// person applies. An UNMARKED claim is never read here, so every other publish is
+// unchanged.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const api = require('../../src/module-api');
+const githubPush = require('./github-push');
+const { PR_FILES_CAP } = require('./ship-files');
+const { isPageTweak } = require('./page-tweak-hold');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const INVENTORY_REL = 'docs/page-inventory.json';
+
+// What a /tweak ship writes besides the page's own files: copy-apply regenerates
+// the copy registry and re-reads the page, and ship.js refreshes the generated
+// maps. Not CLAUDE.md: it is protected, and its §13 snippet moves only when the
+// branch adds a session-log file, which the unattended mode never writes. A path
+// here still runs through the protected-path matcher.
+const SHIP_WRITES = Object.freeze([
+  'docs/copy-registry.json',
+  'docs/copy-inventory.md',
+  'docs/page-readings.json',
+  'docs/repo-map.md',
+  'docs/file-map.md',
+]);
+
+// 'page-tweak/landing:index/r2' -> 'landing:index' (copy-desk's parseRoundRef,
+// restated: a module never requires another module).
+function pageIdFromRef(sourceRef) {
+  const m = /^page-tweak\/([a-z0-9-]+:[a-z0-9-]+)\/r[1-9][0-9]*$/.exec(String(sourceRef || ''));
+  return m ? m[1] : null;
+}
+
+function readInventory(root = REPO_ROOT) {
+  return JSON.parse(fs.readFileSync(path.join(root, INVENTORY_REL), 'utf8'));
+}
+
+function pageFiles(inventory, pageId) {
+  const page = ((inventory && inventory.pages) || []).find((p) => p && p.id === pageId);
+  if (!page) return null;
+  return [...(page.files || []), ...(page.states_files || [])];
+}
+
+// PURE. The verdict over one round's changed paths: null when every path may
+// change, else { code, page_id, outside[], protected[] }.
+function decideFiles({ pageId, allowed, changed, truncated = false, matchProtected }) {
+  if (!pageId || !Array.isArray(allowed)) {
+    return { code: 'auto_pickup_page_unknown', page_id: pageId || null, outside: [], protected: [] };
+  }
+  if (truncated) return { code: 'auto_pickup_files_unreadable', page_id: pageId, outside: [], protected: [] };
+  const ok = new Set([...allowed, ...SHIP_WRITES]);
+  const outside = changed.filter((p) => !ok.has(p));
+  const prot = (matchProtected(changed) || []).map((m) => (m && m.file) || m);
+  if (!outside.length && !prot.length) return null;
+  return { code: 'auto_pickup_outside_page', page_id: pageId, outside, protected: prot };
+}
+
+// The round as the check needs it, in ONE read: its source, its ref, and whether
+// its latest claim (released or not: a publish runs after the ship resolved it)
+// carried the mark. A read that FAILS answers null and the publish goes on as
+// usual: an ordinary publish must not depend on this read, and a worker cannot
+// make the database fail to see its own claim.
+const ROUND_SQL = `
+  SELECT t.id, t.source, t.source_ref,
+         (SELECT c.auto_pickup FROM claims c WHERE c.task_id = t.id
+           ORDER BY c.claimed_at DESC, c.id DESC LIMIT 1) AS auto_pickup
+    FROM tasks t WHERE t.id = $1`;
+async function readRound(taskId, exec = api.pool) {
+  try {
+    const { rows } = await exec.query(ROUND_SQL, [taskId]);
+    return rows[0] || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+// The route's one call. Returns null (publish as usual) or the refusal.
+// `deps` is the test seam.
+async function autoPickupFileRefusal({ taskId, prNumber }, deps = {}) {
+  const round = await (deps.readRound || readRound)(taskId);
+  if (!isPageTweak(round) || round.auto_pickup !== true) return null;
+  const pageId = pageIdFromRef(round.source_ref);
+  let allowed = null;
+  try { allowed = pageId ? pageFiles((deps.readInventory || readInventory)(), pageId) : null; } catch (_) { allowed = null; }
+  let rows;
+  try {
+    rows = await (deps.getPullRequestFiles || ((a) => githubPush.getPullRequestFiles(a)))({ number: Number(prNumber) });
+  } catch (_) {
+    return { code: 'auto_pickup_files_unreadable', page_id: pageId, outside: [], protected: [] };
+  }
+  const list = Array.isArray(rows) ? rows : [];
+  return decideFiles({
+    pageId, allowed,
+    changed: list.map((x) => x && x.path).filter((p) => typeof p === 'string' && p),
+    truncated: list.length >= PR_FILES_CAP,
+    matchProtected: deps.matchProtected || ((files) => api.permissionPathCheck.matchProtected(files)),
+  });
+}
+
+function refusalMessage(r) {
+  const parts = [];
+  if (r.outside && r.outside.length) parts.push(`outside the page: ${r.outside.slice(0, 10).join(', ')}`);
+  if (r.protected && r.protected.length) parts.push(`protected: ${r.protected.slice(0, 10).join(', ')}`);
+  const why = {
+    auto_pickup_outside_page: `An automatic page tweak may change only its own page's files (${parts.join('; ')}).`,
+    auto_pickup_page_unknown: 'An automatic page tweak names a page the inventory does not know, so its files cannot be checked.',
+    auto_pickup_files_unreadable: "The pull request's files could not be read in full, so an automatic round cannot be checked.",
+  }[r.code];
+  return `${why} The pull request was closed; the round waits for a person (ADR 0371 D8).`;
+}
+
+module.exports = {
+  SHIP_WRITES,
+  pageIdFromRef,
+  pageFiles,
+  decideFiles,
+  readRound,
+  autoPickupFileRefusal,
+  refusalMessage,
+};

package/modules/lifecycle/db-ship.js

@@ -1038,7 +1038,8 @@ async function confirmTask({ taskId, builderId }, deps = {}) {
     // degenerate state, e.g. status set directly via SQL) so a legitimate
     // confirm is never refused. Mirrors the #538 fix on the override path.
     const creditedBuilderId = (await mostRecentClaimHolderId(client, taskId)) ?? builderId;
-
+    const { rows: srcRows } = await client.query('SELECT source FROM tasks WHERE id = $1', [taskId]); // ADR 0371 D8 (task 1004678): never past the artist
+    if (isPageTweak(srcRows[0] || null)) throw Object.assign(new Error('a page tweak is confirmed only by its artist'), { code: 'PAGE_TWEAK_NEEDS_ARTIST' });
     const { rows } = await client.query(
       `UPDATE tasks
           SET status = 'confirmed',

package/modules/lifecycle/routes/tasks.js

@@ -36,7 +36,7 @@ const { gradeQualityWhere } = require('../db-shared');
 const { helperJoinSql } = require('../page-tweak-artist'); // task 1004432: a page tweak's applier as a helper
 const auth = api;
 const db = require('../db');
-const pageTweakReads = require('../page-tweak-reads'); const { HELD_NOT_ARMED, prMergeSentence } = require('../page-tweak-hold'); // ADR 0341 D7 (tests stub the read)
+const pageTweakReads = require('../page-tweak-reads'); const { HELD_NOT_ARMED, prMergeSentence } = require('../page-tweak-hold'); const autoPickupFiles = require('../autopickup-files'); const githubPrClose = require('../github-pr-close'); // ADR 0341 D7 (tests stub the read); ADR 0371 D8
 const hierarchy = require('../hierarchy');
 const { suggestCriteria } = require('../criterion-suggest');
 // The orphan-task advisory (task 1002539) — pure, fail-open; see goal-advisory.js.
@@ -696,9 +696,8 @@ module.exports = function buildTasksRouter() {
       const result = await db.confirmTask({ taskId: id, builderId: req.builder.id });
       res.json({ ok: true, ...result });
     } catch (err) {
-      if (err.code === 'TASK_NOT_COMPLETED') {
-        return res.fail('task_not_completed', 409);
-      }
+      if (err.code === 'TASK_NOT_COMPLETED') return res.fail('task_not_completed', 409);
+      if (err.code === 'PAGE_TWEAK_NEEDS_ARTIST') return res.fail('page_tweak_needs_artist', { status: 409, message: `Task #${id} is a page tweak: it is confirmed only when its artist approves it in the studio, or by the owner's override request (ADR 0371 D8).` });
       log.error('[gds] POST /tasks/:id/confirm', err);
       res.fail('confirm_failed', { status: 500, message: 'internal error' });
     }
@@ -1184,6 +1183,7 @@ module.exports = function buildTasksRouter() {
         `Merging triggers .github/workflows/deploy-prod.yml -> ${branding().domains.publicOrigin}. ` +
         prMergeSentence(held);
       const pr = await githubPush.openOrFindPullRequest({ branch, title, body });
+      const apRefusal = await autoPickupFiles.autoPickupFileRefusal({ taskId: id, prNumber: pr.number }); if (apRefusal) { await githubPrClose.closePullRequest({ number: pr.number }).catch(() => null); return res.fail(apRefusal.code, 409, { ...apRefusal, message: autoPickupFiles.refusalMessage(apRefusal) }); } // ADR 0371 D8 (task 1004678)
       // Best-effort by contract (pr-assign.js never rejects); the catch is for a future
       // edit that forgets — an assignment must not be able to fail a pushed ship.
       const assignment = await prAssign.assignPullRequest({ number: pr.number, login: builderLogin })

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.108",
+  "version": "1.21.110",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.21.108",
+      "version": "1.21.110",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.108",
+  "version": "1.21.110",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -9498,5 +9498,25 @@
       "id": "1004696",
       "text": "Artists can now recommend removing a line while editing a page's words: mark it with \"Remove this line\" or just delete its words, see it crossed out, keep it after all, and send it with their rewrites. Each removal goes to an"
     }
+  ],
+  "1.21.109": [
+    {
+      "id": "1004700",
+      "text": "The \"Edit words\" paintbrush now works in the local hall preview instead of saying the page could not be taken."
+    },
+    {
+      "id": "1004675",
+      "text": "Planning sessions now keep the work tied to the design the owner agreed. Each goal's done-when line must carry the agreed model (the named states and rules), and each proof task must describe a scenario a wrong build would fai"
+    }
+  ],
+  "1.21.110": [
+    {
+      "id": "1004686",
+      "text": "Artists can now review the hall through anyone's eyes. In Artistry mode, hovering the Review button opens a menu: Ideator, Governing, Building or Artistry experience. Picking one shows every page the way a builder in that mode"
+    },
+    {
+      "id": "1004678",
+      "text": "The page-tweak helper can now run on its own: given one page, it applies the artist's words without asking anything, and if anything goes wrong it hands the page back with a plain note. The server enforces the safety rules its"
+    }
   ]
 }

package/scripts/gds/copy-apply.js

@@ -32,6 +32,7 @@
 //
 // Run:  node scripts/gds/copy-apply.js --batch            (a PAGE TWEAK round you hold: every line, task 1004322)
 //       node scripts/gds/copy-apply.js --batch --batch-file round.md --dry-run   (a local round; writes nothing)
+//       node scripts/gds/copy-apply.js --batch --page <id> --unattended   (the auto-pickup worker: exit 5 = wrong page; any non-zero exit releases the round, task 1004678)
 //       node scripts/gds/copy-apply.js                    (the task you are HOLDING — the normal call)
 //       node scripts/gds/copy-apply.js --dry-run          (say what would change, write nothing)
 //       node scripts/gds/copy-apply.js --task 1234        (a claim you hold, when you hold more than one)
@@ -518,7 +519,7 @@ async function writeAppliedBlock({ taskId, description, block, api = apiCall })
 
 // The --batch command. `deps` is the test seam: every read, write, re-read and API
 // call can be replaced, so the whole path runs against a fixture round.
-async function batchMain({ taskId, batchFile, dryRun, now = () => new Date().toISOString() }, deps = {}) {
+async function batchMain({ taskId, batchFile, dryRun, pageId = null, now = () => new Date().toISOString() }, deps = {}) {
   const readFile = deps.readFile || ((p) => fs.readFileSync(p, 'utf8'));
   const writeFile = deps.writeFile || ((p, s) => fs.writeFileSync(p, s));
   const api = deps.api || apiCall;
@@ -526,6 +527,12 @@ async function batchMain({ taskId, batchFile, dryRun, now = () => new Date().toI
   const loaded = await loadBatch({ taskId, batchFile, readFile, api });
   if (!loaded.ok) return refuse(loaded);
   const { batch } = loaded;
+  // --page (task 1004678, ADR 0371 D8): the unattended worker names the page it was
+  // given, and a round for any other page is refused before a file is touched.
+  if (pageId && batch.page_id !== pageId) {
+    refuse({ ok: false, code: 'wrong_page', detail: { task: taskId, expected: pageId, round_page: batch.page_id, what_this_means: 'This round belongs to a different page than the one named with --page. Nothing was written.' } });
+    return 5;
+  }
   const registry = deps.registry || JSON.parse(readFile(path.join(REPO_ROOT, 'docs', 'copy-registry.json')));
   const result = applyBatchToSources({ batch, registry, readSource: (rel) => readFile(path.join(REPO_ROOT, rel)) });
 
@@ -590,7 +597,15 @@ async function main() {
       taskId = held.taskId;
       console.log(`copy-apply --batch: the round you are holding — task ${taskId}`);
     }
-    return cliExit(await batchMain({ taskId, batchFile, dryRun }));
+    // --page <id> --unattended (task 1004678, ADR 0371 D8): never asks, and any exit
+    // that is not a clean apply releases the round with a plain note (tweak-halt.js).
+    const pageId = arg('--page') || null;
+    const code = await batchMain({ taskId, batchFile, dryRun, pageId });
+    if (hasFlag('--unattended') && code !== 0 && taskId && !batchFile && !dryRun) {
+      const halt = require('./tweak-halt');
+      halt.releaseWithNote(taskId, halt.haltForCopyApplyExit(code));
+    }
+    return cliExit(code);
   }
 
   if (!taskId && !patchFile) {

package/scripts/gds/tweak-halt.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+// scripts/gds/tweak-halt.js — an unattended /tweak stops, releases its round with a
+// plain note, and exits (task 1004678 / BV2.TW19b, ADR 0371 D8).
+//
+// WHY. `/tweak --page <id> --unattended` runs with nobody to ask. Every halt it can
+// meet must end the same way: the round goes back to the queue with a sentence an
+// artist can read, and the worker exits. Writing that once here means the skill,
+// copy-apply's --unattended path and the runner's lane (TW19c) cannot each word a
+// halt differently, or leave one claimed.
+//
+// Run:  node scripts/gds/tweak-halt.js <task-id> --code <halt-code>
+//
+// The note is fixed vocabulary per code, never free text from the worker: the
+// worker is a model reading pages an artist wrote, so nothing it says rides out
+// onto the round.
+
+'use strict';
+
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+// The halts ADR 0371 D8 names, plus the copy-apply exits that mean "do not ship".
+const HALT_NOTES = Object.freeze({
+  claim_refused: 'The automatic apply could not take this round (the claim was refused). It waits for a person.',
+  nothing_applied: 'The automatic apply placed none of the lines, so there is nothing to show. Each refused line is recorded on the round.',
+  wrong_page: 'The automatic apply was pointed at a different page than this round. Nothing was changed.',
+  registry_mismatch: 'The automatic apply wrote the files but the copy registry did not read the new words back, so it stopped before shipping.',
+  reread_failed: 'The automatic apply could not re-read the page after applying it, so it stopped before shipping.',
+  ship_check_stale: 'The automatic apply stopped because the pre-ship checks named something stale it may not fix by itself.',
+  grader_unavailable: 'The quality review could not run, so the automatic apply stopped. The round waits for the next try or a person.',
+  grade_failed: 'The quality review did not pass the automatic apply. The round waits for a person.',
+  outside_page: 'The automatic apply would have changed a file outside this page, so it stopped.',
+});
+
+function haltNote(code) {
+  return HALT_NOTES[code] || null;
+}
+
+// copy-apply --batch's exit codes, as halts. 0 is not a halt. 2 is "nothing
+// applied" and also every refusal copy-apply names before writing (an unreadable
+// round): in both, nothing reached the page.
+function haltForCopyApplyExit(exit) {
+  if (exit === 0) return null;
+  return { 2: 'nothing_applied', 3: 'registry_mismatch', 4: 'reread_failed', 5: 'wrong_page' }[exit] || 'nothing_applied';
+}
+
+// Release the round with the note. `spawn` is the test seam. Returns the exit.
+function releaseWithNote(taskId, code, { spawn = spawnSync } = {}) {
+  const note = haltNote(code);
+  if (!note) throw new Error(`unknown halt code: ${code}`);
+  const r = spawn(process.execPath, [path.join(__dirname, 'release.js'), String(taskId), '--reason', `[tweak-unattended:${code}] ${note}`], { stdio: 'inherit' });
+  return r && typeof r.status === 'number' ? r.status : 1;
+}
+
+function main(argv = process.argv.slice(2)) {
+  const taskId = argv[0];
+  const i = argv.indexOf('--code');
+  const code = i >= 0 ? argv[i + 1] : null;
+  if (!/^[1-9][0-9]*$/.test(String(taskId || '')) || !haltNote(code)) {
+    console.error(`usage: node scripts/gds/tweak-halt.js <task-id> --code <${Object.keys(HALT_NOTES).join('|')}>`);
+    return 1;
+  }
+  console.log(`tweak-halt: task ${taskId} — ${haltNote(code)}`);
+  return releaseWithNote(taskId, code);
+}
+
+if (require.main === module) process.exitCode = main();
+
+module.exports = { HALT_NOTES, haltNote, haltForCopyApplyExit, releaseWithNote };

package/scripts/hall-preview/server.js

@@ -271,7 +271,18 @@ const app = express();
 app.use((req, res, next) => {
   const m = req.path.match(/^\/api\/(?:gds|bongos)(?:\/v1)?\/(.+)$/);
   if (!m) return next();
-  const apiPath = m[1].replace(/\/$/, '');
+  // Decoded before any matching (task 1004700): the paintbrush sends its page id
+  // through encodeURIComponent, so builders:studio arrives as builders%3Astudio
+  // and every copy-desk fixture and canned write missed. A malformed escape keeps
+  // the raw path, which then simply finds no fixture.
+  let apiPath = m[1].replace(/\/$/, '');
+  try { apiPath = decodeURIComponent(apiPath); } catch { /* keep raw */ }
+  // Decoding can mint a backslash, NUL or `..` segment that the fixture-name
+  // mapper does not neutralise (path.join honours `\` on Windows), so a decoded
+  // path that could leave the fixtures dir is refused outright.
+  if (/[\\\0]|(^|\/)\.\.(\/|$)/.test(apiPath)) {
+    return res.status(400).json({ error: { code: 'bad_path', message: 'path escapes the fixtures' } });
+  }
 
   // SSE live channel: emit one nudge (so "live refresh" paths run once), then
   // keep-alive comments. Pages treat this exactly like prod's stream.

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.108'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.110'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');