@bongos/core 1.19.1063 → 1.19.1065

package/tests/task_visual_slots.mjs

@@ -0,0 +1,161 @@
+// tests/task_visual_slots.mjs — task visuals widened to NAMED slots, and the
+// eight page-tweak renders attached to them (task 1004322 / BV2.TW11;
+// lifecycle_013; ADR 0341 D7, builder pick 9).
+//
+// Drives the real routes/visuals.js router with the slot queries stubbed at the
+// module boundary and a temp store, then the pure halves of tweak-renders.js and
+// its attach step against a fake client. No DB, no network, no browser.
+//
+// Run:  node tests/task_visual_slots.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'tw11-slots-'));
+process.env.TASK_VISUALS_DIR = path.join(TMP, 'store');
+
+const express = require('express');
+const api = require('../src/module-api.js');
+const visualDb = require('../modules/lifecycle/task-visual-db.js');
+const visuals = require('../modules/lifecycle/task-visuals.js');
+const renders = require('../scripts/gds/tweak-renders.js');
+
+const { test, summary } = makeRunner();
+
+// A 1x1 PNG, real enough for the magic-byte sniff.
+const PNG = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==', 'base64');
+
+const slots = new Map(); // `${task}|${slot}` -> row
+visualDb.getTaskVisualAccess = async (id) => ({ id, status: 'completed', security_sensitive: false, visual_url: null });
+visualDb.setTaskVisualSlot = async ({ taskId, slot, visualUrl, visualAlt }) => {
+  const k = `${taskId}|${slot}`;
+  const prev = slots.get(k);
+  slots.set(k, { slot, visual_url: visualUrl, visual_alt: visualAlt, updated_at: 't' });
+  return { slot, visual_url: visualUrl, visual_alt: visualAlt, replaced_url: prev ? prev.visual_url : null };
+};
+visualDb.deleteTaskVisualSlot = async ({ taskId, slot }) => { const k = `${taskId}|${slot}`; const p = slots.get(k); slots.delete(k); return p ? p.visual_url : null; };
+visualDb.listTaskVisualSlots = async (taskId) => [...slots.entries()].filter(([k]) => k.startsWith(`${taskId}|`)).map(([, v]) => v).sort((a, b) => (a.slot < b.slot ? -1 : 1));
+let rank = 'archon';
+api.requireBuilder = (req, res, next) => { req.builder = { id: 1, rank, github_login: 'x' }; next(); };
+
+const app = express();
+app.use((req, res, next) => { res.fail = (code, status, extra) => res.status(typeof status === 'number' ? status : (status && status.status) || 500).json({ error: code, ...(extra || {}) }); next(); });
+app.use(require('../modules/lifecycle/routes/visuals.js')());
+const server = http.createServer(app);
+await new Promise((r) => server.listen(0, '127.0.0.1', r));
+const base = `http://127.0.0.1:${server.address().port}`;
+const call = async (method, url, body) => {
+  const res = await fetch(base + url, { method, headers: { 'Content-Type': 'application/json' }, body: body ? JSON.stringify(body) : undefined });
+  return { status: res.status, body: await res.json() };
+};
+const png = { image_b64: PNG.toString('base64'), content_type: 'image/png' };
+const stored = () => fs.existsSync(process.env.TASK_VISUALS_DIR) ? fs.readdirSync(process.env.TASK_VISUALS_DIR) : [];
+
+await test('the eight render slots are declared once: before/after x desktop/phone x light/dark', () => {
+  assert.equal(visuals.TWEAK_RENDER_SLOTS.length, 8);
+  assert.equal(new Set(visuals.TWEAK_RENDER_SLOTS).size, 8);
+  for (const s of visuals.TWEAK_RENDER_SLOTS) assert.ok(visuals.isSafeSlot(s), s);
+  assert.deepEqual(visuals.TWEAK_RENDER_DEVICES, { desktop: 1440, phone: 390 }, 'the spec widths: 1440 and 390');
+  const sql = fs.readFileSync(new URL('../modules/lifecycle/migrations/lifecycle_013_task_visual_slots.sql', import.meta.url), 'utf8');
+  const re = new RegExp(/slot ~ '([^']+)'/.exec(sql)[1]);
+  for (const s of visuals.TWEAK_RENDER_SLOTS) assert.ok(re.test(s), `the column CHECK admits ${s}`);
+  for (const bad of ['', 'Before', '../x', 'a b', 'x'.repeat(49), 'a--b']) assert.equal(visuals.isSafeSlot(bad), false, JSON.stringify(bad));
+});
+
+await test('POST a named slot stores the image and lists it; the one ship-time visual is untouched', async () => {
+  const r = await call('POST', '/tasks/5001/visuals/after-phone-dark', png);
+  assert.equal(r.status, 201, JSON.stringify(r.body));
+  assert.equal(r.body.slot, 'after-phone-dark');
+  assert.match(r.body.visual_url, /^\/api\/bongos\/task-visuals\/task-5001-[0-9a-f]{16}\.png$/, 'the same store and serve path as the one visual');
+  const l = await call('GET', '/tasks/5001/visuals');
+  assert.deepEqual(l.body.slots.map((x) => x.slot), ['after-phone-dark']);
+  assert.equal(stored().length, 1);
+});
+
+await test('attaching a slot again REPLACES it and unlinks the superseded file', async () => {
+  const before = stored();
+  const r = await call('POST', '/tasks/5001/visuals/after-phone-dark', png);
+  assert.equal(r.status, 201);
+  const after = stored();
+  assert.equal(after.length, 1, 'one file per slot on disk');
+  assert.notDeepEqual(after, before);
+});
+
+await test('a bad slot name is refused before any byte is stored; a non-image is refused', async () => {
+  const n = stored().length;
+  assert.equal((await call('POST', '/tasks/5001/visuals/Not%20A%20Slot', png)).status, 400);
+  const r = await call('POST', '/tasks/5001/visuals/before-desktop-light', { image_b64: Buffer.from('<svg/>').toString('base64'), content_type: 'image/png' });
+  assert.equal(r.status, 400);
+  assert.equal(stored().length, n);
+});
+
+await test('only the claim holder or an Archon may attach (the one visual\'s own gate)', async () => {
+  rank = 'thetes';
+  const routes = require('../modules/lifecycle/routes/tasks.js');
+  const src = fs.readFileSync(require.resolve('../modules/lifecycle/routes/visuals.js'), 'utf8');
+  const post = src.slice(src.indexOf("router.post('/tasks/:id/visuals/:slot'"), src.indexOf("router.delete('/tasks/:id/visuals/:slot'"));
+  const del = src.slice(src.indexOf("router.delete('/tasks/:id/visuals/:slot'"), src.indexOf("router.get('/tasks/:id/visuals'"));
+  for (const body of [post, del]) assert.match(body, /gateTaskOwnership\(req, res, id\)/);
+  assert.ok(routes.gateTaskOwnership, 'the shared gate is the one used');
+  rank = 'archon';
+});
+
+await test('DELETE a slot removes its row and its file, and is idempotent', async () => {
+  const r = await call('DELETE', '/tasks/5001/visuals/after-phone-dark');
+  assert.equal(r.status, 200);
+  assert.equal(stored().length, 0);
+  assert.equal((await call('DELETE', '/tasks/5001/visuals/after-phone-dark')).status, 200);
+  assert.deepEqual((await call('GET', '/tasks/5001/visuals')).body.slots, []);
+});
+server.close();
+
+// ---- tweak-renders.js -------------------------------------------------------
+
+await test('shotsFor names one file per slot; a page pinning one mode is shot in it for both mode slots', () => {
+  const free = renders.shotsFor('before', { pinnedMode: null });
+  assert.deepEqual(free.map((s) => s.slot), visuals.TWEAK_RENDER_SLOTS.filter((s) => s.startsWith('before-')));
+  assert.deepEqual(free.map((s) => s.renderMode), ['light', 'dark', 'light', 'dark']);
+  const pinned = renders.shotsFor('after', { pinnedMode: 'dark' });
+  assert.deepEqual(pinned.map((s) => s.renderMode), ['dark', 'dark', 'dark', 'dark']);
+  assert.throws(() => renders.shotsFor('during', {}));
+});
+
+await test('planForPage reads the real inventory: an unknown page is refused, a known one has a url', () => {
+  const reader = require('../scripts/gds/page-reader.js');
+  const inventory = JSON.parse(fs.readFileSync(new URL('../docs/page-inventory.json', import.meta.url), 'utf8'));
+  assert.equal(renders.planForPage('nope:nope', { inventory, planRenders: reader.planRenders }).code, 'unknown_page');
+  const p = renders.planForPage(inventory.pages[0].id, { inventory, planRenders: reader.planRenders });
+  assert.equal(p.ok, true);
+  assert.ok(typeof p.plan.url === 'string' && p.plan.url.startsWith('/'));
+});
+
+await test('attach uploads every slot file in the directory to its NAMED slot, and names the missing ones', async () => {
+  const dir = path.join(TMP, 'shots');
+  fs.mkdirSync(dir, { recursive: true });
+  const present = visuals.TWEAK_RENDER_SLOTS.slice(0, 6);
+  for (const s of present) fs.writeFileSync(path.join(dir, `${s}.png`), PNG);
+  const posts = [];
+  const client = { tasks: { postTasksIdVisualsSlot: async (a) => { posts.push(a); return { ok: true, status: 201 }; } } };
+  const errs = [];
+  const origErr = console.error, origLog = console.log;
+  console.error = (m) => errs.push(String(m)); console.log = () => {};
+  let code;
+  try { code = await renders.attach({ taskId: 5001, dir }, { client }); } finally { console.error = origErr; console.log = origLog; }
+  assert.deepEqual(posts.map((p) => p.slot), present);
+  assert.ok(posts.every((p) => p.id === 5001 && p.body.content_type === 'image/png'));
+  assert.equal(code, 1, 'a missing slot is not a success');
+  assert.ok(errs.some((m) => m.includes('after-phone-light') && m.includes('after-phone-dark')), 'the missing slots are named');
+  for (const s of visuals.TWEAK_RENDER_SLOTS.slice(6)) fs.writeFileSync(path.join(dir, `${s}.png`), PNG);
+  console.log = () => {};
+  try { code = await renders.attach({ taskId: 5001, dir }, { client }); } finally { console.log = origLog; }
+  assert.equal(code, 0, 'all eight attached');
+});
+
+fs.rmSync(TMP, { recursive: true, force: true });
+summary();

package/tests/tweak_batch_apply.mjs

@@ -0,0 +1,265 @@
+// tests/tweak_batch_apply.mjs — copy-apply.js --batch lands a whole page round
+// (task 1004322 / BV2.TW11; ADR 0341 D4).
+//
+// The done-when: "/tweak applies a multi-line page batch ... a refused line is
+// named, not skipped." Two layers:
+//   1. the pure core (applyBatchToSources) over fixture sources and a registry
+//      built by the REAL extractors, so a line is matched exactly the way the
+//      inventory reads it;
+//   2. the whole command (batchMain) on a FIXTURE ROUND: a page-tweak task read
+//      from a fake API, its files from an in-memory tree, the registry
+//      regenerated by the real extractors over the files it wrote, and the
+//      page-tweak-applied block PATCHed back and parsed by the one reader.
+// No DB, no network, no browser (the page re-read is the one stubbed step; the
+// real re-read is page-reader.js --stale, covered by tests/page_reader.mjs).
+//
+// Run:  node tests/tweak_batch_apply.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ci = require('../scripts/gds/copy-inventory.js');
+const pages = require('../modules/copy-desk/pages.js');
+const apply = require('../scripts/gds/copy-apply.js');
+
+const { test, summary } = makeRunner();
+const REPO_ROOT = path.resolve(fileURLToPath(new URL('..', import.meta.url)));
+
+const HTML = 'modules/public-landing/public/fixture-tweak.html';
+const JS = 'modules/hall-ui/public/fixture-tweak.js';
+const OTHER = 'modules/public-landing/public/fixture-other.html';
+const SURFACE_OF = { [HTML]: 'landing', [JS]: 'builders-hall', [OTHER]: 'landing' };
+
+const TREE = () => ({
+  [HTML]: `<!doctype html>
+<html><body>
+<main>
+  <h1>Welcome to the studio</h1>
+  <p>Take a page and rewrite every word of it.</p>
+  <p>Every word counts, and every word is yours.</p>
+  <button>Take next</button>
+</main>
+</body></html>
+`,
+  [JS]: "'use strict';\nfunction render(el, n) {\n  el.innerHTML = `<p>You have ${n} pages waiting for review</p>`;\n}\n",
+  [OTHER]: '<!doctype html>\n<html><body>\n<p>Take next</p>\n</body></html>\n',
+});
+
+// The registry the inventory would write over a tree: the real extractors, the
+// real stable id, the span dropped exactly as buildRegistry drops it.
+function registryOver(tree) {
+  const entries = [];
+  for (const [rel, source] of Object.entries(tree)) {
+    const rows = rel.endsWith('.html') ? ci.fromHtml({ source, rel }) : ci.fromJs({ source, rel });
+    for (const { start, end, ...row } of rows) entries.push({ id: ci.stableId(SURFACE_OF[rel], row.text), surface: SURFACE_OF[rel], ...row });
+  }
+  return { entries, counts: { strings: entries.length } };
+}
+
+const REG = registryOver(TREE());
+const row = (text, file) => REG.entries.find((e) => e.text === text && (!file || e.file === file));
+const line = (key, before, after, file, extra = {}) => {
+  const r = row(extra.registryText || before, file);
+  return { key, section: 'main', before, after, placement: 'placed', file: r ? r.file : file, line: r ? r.line : 1, string_id: r ? r.id : 'ffffffffffff', ...extra.override };
+};
+
+const BATCH = () => ({
+  page_id: 'landing:fixture',
+  reading_hash: 'r-before',
+  submitted_at: '2026-09-28T00:00:00Z',
+  lines: [
+    line('L0001', 'Welcome to the studio', 'Welcome to your studio', HTML),
+    line('L0002', 'Take a page and rewrite every word of it.', 'Take a page and make every word of it yours.', HTML),
+    line('L0003', 'You have {…} pages waiting for review', 'There are {…} pages waiting for you', JS),
+    line('L0004', 'Take next', 'Take the next page', HTML),
+  ],
+});
+
+const readerOf = (tree) => (rel) => { if (!(rel in tree)) throw new Error(`ENOENT ${rel}`); return tree[rel]; };
+
+await test('a multi-line batch applies every line, across files, holes put back', () => {
+  const tree = TREE();
+  const out = apply.applyBatchToSources({ batch: BATCH(), registry: REG, readSource: readerOf(tree) });
+  assert.deepEqual(out.refused, []);
+  assert.deepEqual(out.applied.map((a) => a.key), ['L0001', 'L0002', 'L0003', 'L0004'], 'reported in PAGE order');
+  const html = out.sources.get(HTML);
+  assert.match(html, /<h1>Welcome to your studio<\/h1>/);
+  assert.match(html, /<p>Take a page and make every word of it yours\.<\/p>/);
+  assert.match(html, /<button>Take the next page<\/button>/);
+  assert.match(html, /Every word counts, and every word is yours\./, 'an untouched line is untouched');
+  assert.equal(out.sources.get(JS), "'use strict';\nfunction render(el, n) {\n  el.innerHTML = `<p>There are ${n} pages waiting for you</p>`;\n}\n", 'the ${n} expression is re-injected, not the {…} placeholder');
+  assert.ok(!out.sources.has(OTHER), 'the same sentence in ANOTHER file is left alone: the line names its own file');
+});
+
+await test('a refused line is NAMED, with its code, and the rest of the batch still lands', () => {
+  const b = BATCH();
+  b.lines.push(
+    // the page changed after submit: its string is gone from the registry
+    { key: 'L0005', section: 'main', before: 'A sentence no page shows', after: 'Still not shown', placement: 'placed', file: HTML, line: 9, string_id: '000000000000' },
+    // the rewrite drops the value the page drops in
+    line('L0006', 'You have {…} pages waiting for review', 'Lots of pages are waiting', JS),
+    // a fragment that appears twice inside its string
+    line('L0007', 'word', 'phrase', HTML, { registryText: 'Every word counts, and every word is yours.' }),
+    // a fragment that is not inside its string at all
+    line('L0008', 'nowhere in it', 'still nowhere', HTML, { registryText: 'Every word counts, and every word is yours.' }),
+  );
+  // and a registry row that points outside every surface
+  const reg = { entries: [...REG.entries, { id: 'aaaaaaaaaaaa', surface: 'landing', text: 'Secret', file: 'config/secret.html', line: 1, origin: 'html-text' }] };
+  b.lines.push({ key: 'L0009', section: 'main', before: 'Secret', after: 'Public', placement: 'placed', file: 'config/secret.html', line: 1, string_id: 'aaaaaaaaaaaa' });
+  const out = apply.applyBatchToSources({ batch: b, registry: reg, readSource: readerOf(TREE()) });
+  assert.deepEqual(out.refused.map((x) => [x.key, x.code]), [
+    ['L0005', 'target_gone'],
+    ['L0006', 'placeholder_mismatch'],
+    ['L0007', 'ambiguous_target'],
+    ['L0008', 'no_exact_span'],
+    ['L0009', 'path_outside_surface'],
+  ]);
+  for (const x of out.refused) assert.ok(apply.REFUSAL_CODES.includes(x.code), `${x.code} is a named code`);
+  assert.equal(out.applied.length, 4, 'the four good lines still applied');
+  assert.equal(out.applied.length + out.refused.length, b.lines.length, 'NO line is skipped silently: every line is applied or refused');
+});
+
+await test('two lines inside ONE string compose: the second is resolved against what the first left', () => {
+  const b = { page_id: 'landing:fixture', lines: [
+    line('L0001', 'Every word counts', 'Each word matters', HTML, { registryText: 'Every word counts, and every word is yours.' }),
+    line('L0002', 'is yours', 'belongs to you', HTML, { registryText: 'Every word counts, and every word is yours.' }),
+  ] };
+  const out = apply.applyBatchToSources({ batch: b, registry: REG, readSource: readerOf(TREE()) });
+  assert.deepEqual(out.refused, []);
+  assert.match(out.sources.get(HTML), /<p>Each word matters, and every word belongs to you\.<\/p>/);
+});
+
+await test('a string id shared by two files resolves to the row in the line\'s own file', () => {
+  const r = apply.registryRowFor({ string_id: row('Take next', OTHER).id, file: OTHER, line: 3 }, new Map([[row('Take next', OTHER).id, REG.entries.filter((e) => e.text === 'Take next')]]));
+  assert.equal(r.file, OTHER);
+});
+
+await test('the applied block leaves shared lines out of lines_after and carries each refusal', () => {
+  const block = apply.appliedBlockFor({
+    pageId: 'landing:fixture',
+    appliedAt: '2026-09-28T01:00:00Z',
+    readingPage: { reading_hash: 'r-after', lines: [
+      { key: 'L0001', text: 'Skip to content', placement: 'shared' },
+      { key: 'L0002', text: 'Welcome to your studio', placement: 'placed' },
+      { key: 'L0003', text: 'Something unplaced', placement: 'unplaced' },
+    ] },
+    refused: [{ key: 'L0005', code: 'target_gone', detail: { x: 1 } }],
+  });
+  assert.deepEqual(block.lines_after, ['Welcome to your studio', 'Something unplaced']);
+  assert.deepEqual(block.refused, [{ key: 'L0005', code: 'target_gone' }], 'key and code only');
+  const parsed = pages.parseAppliedBlock(pages.composeAppliedBlock(block));
+  assert.equal(parsed.ok, true);
+  assert.equal(parsed.applied.reading_hash_after, 'r-after');
+});
+
+// ---- the whole command on a fixture round ---------------------------------
+
+function fixtureRound(batch) {
+  const page = { id: batch.page_id, title: 'Fixture' };
+  return [pages.roundTaskBody(page, 1), '', pages.composeBatchBlock({ ...batch, unplaced_tasks: [] })].join('\n');
+}
+
+function harness({ batch, source = 'page-tweak', registryOverride = null, rereadOk = true } = {}) {
+  const tree = TREE();
+  const abs = (rel) => path.join(REPO_ROOT, rel);
+  const files = new Map(Object.entries(tree).map(([rel, s]) => [abs(rel), s]));
+  const writes = [];
+  const calls = [];
+  const task = { id: '5001', source, description: fixtureRound(batch) };
+  const deps = {
+    log: () => {},
+    readFile: (p) => { if (!files.has(p)) throw new Error(`ENOENT ${p}`); return files.get(p); },
+    writeFile: (p, s) => { writes.push(p); files.set(p, s); },
+    registry: REG,
+    regenerateRegistry: () => ({ reg: registryOverride || registryOver(Object.fromEntries(Object.keys(tree).map((rel) => [rel, files.get(abs(rel))]))) }),
+    reread: () => (rereadOk ? { ok: true } : { ok: false, code: 'no_browser' }),
+    readingFor: () => ({ reading_hash: 'r-after', lines: [{ key: 'L0001', text: 'Skip to content', placement: 'shared' }, { key: 'L0002', text: 'Welcome to your studio', placement: 'placed' }] }),
+    api: async (method, url, body) => {
+      calls.push({ method, url, body });
+      if (method === 'GET') return { ok: true, status: 200, data: { task } };
+      if (method === 'PATCH') { task.description = body.description; return { ok: true, status: 200, data: { task } }; }
+      return { ok: false, status: 405 };
+    },
+  };
+  return { deps, files, writes, calls, task, abs };
+}
+
+await test('END TO END: a fixture round is applied, its files written, and the applied block recorded on the task', async () => {
+  const b = BATCH();
+  b.lines.push({ key: 'L0005', section: 'main', before: 'A sentence no page shows', after: 'Still not shown', placement: 'placed', file: HTML, line: 9, string_id: '000000000000' });
+  const h = harness({ batch: b });
+  const code = await apply.batchMain({ taskId: '5001', now: () => '2026-09-28T02:00:00Z' }, h.deps);
+  assert.equal(code, 0);
+  assert.match(h.files.get(h.abs(HTML)), /Welcome to your studio/);
+  assert.match(h.files.get(h.abs(JS)), /There are \$\{n\} pages waiting for you/);
+  assert.deepEqual(h.writes.sort(), [h.abs(HTML), h.abs(JS)].sort(), 'only the files the batch changed are written');
+  const patch = h.calls.find((c) => c.method === 'PATCH');
+  assert.ok(patch, 'the applied block is written back to the round');
+  assert.equal(patch.url, '/api/bongos/tasks/5001');
+  const applied = pages.parseAppliedBlock(patch.body.description);
+  assert.equal(applied.ok, true, 'one applied block, readable by the one reader');
+  assert.deepEqual(applied.applied.refused, [{ key: 'L0005', code: 'target_gone' }], 'the refused line is named on the task, not skipped');
+  assert.equal(applied.applied.reading_hash_after, 'r-after');
+  assert.deepEqual(applied.applied.lines_after, ['Welcome to your studio']);
+  assert.equal(pages.parseBatchBlock(patch.body.description).ok, true, 'the frozen batch is kept beside it');
+  const presence = pages.blockPresence(patch.body.description);
+  assert.equal(presence.applied, true);
+  assert.equal(presence.applied_at, '2026-09-28T02:00:00Z');
+});
+
+await test('a re-apply REPLACES the applied block rather than adding a second', async () => {
+  const h = harness({ batch: BATCH() });
+  await apply.batchMain({ taskId: '5001', now: () => 't1' }, h.deps);
+  const h2 = harness({ batch: BATCH() });
+  h2.task.description = h.task.description;
+  await apply.batchMain({ taskId: '5001', now: () => 't2' }, h2.deps);
+  assert.equal(pages.parseAppliedBlock(h2.task.description).ok, true, 'still exactly one applied block');
+  assert.equal(pages.parseAppliedBlock(h2.task.description).applied.applied_at, 't2');
+});
+
+await test('--dry-run writes no file and no task', async () => {
+  const h = harness({ batch: BATCH() });
+  const code = await apply.batchMain({ taskId: '5001', dryRun: true }, h.deps);
+  assert.equal(code, 0);
+  assert.deepEqual(h.writes, []);
+  assert.ok(!h.calls.some((c) => c.method === 'PATCH'));
+});
+
+await test('every line refused: exit 2, and the refusals are still recorded on the task', async () => {
+  const h = harness({ batch: { page_id: 'landing:fixture', reading_hash: 'r', submitted_at: 't', lines: [
+    { key: 'L0005', section: 'main', before: 'Gone', after: 'Still gone', placement: 'placed', file: HTML, line: 9, string_id: '000000000000' },
+  ] } });
+  const code = await apply.batchMain({ taskId: '5001' }, h.deps);
+  assert.equal(code, 2);
+  const patch = h.calls.find((c) => c.method === 'PATCH');
+  assert.deepEqual(pages.parseAppliedBlock(patch.body.description).applied.refused, [{ key: 'L0005', code: 'target_gone' }]);
+});
+
+await test('the regenerated registry not showing the new wording is a hard stop (exit 3), before any task write', async () => {
+  const h = harness({ batch: BATCH(), registryOverride: REG });
+  const code = await apply.batchMain({ taskId: '5001' }, h.deps);
+  assert.equal(code, 3);
+  assert.ok(!h.calls.some((c) => c.method === 'PATCH'));
+});
+
+await test('a page that cannot be re-read stops before the applied block (exit 4): no block from a stale reading', async () => {
+  const h = harness({ batch: BATCH(), rereadOk: false });
+  assert.equal(await apply.batchMain({ taskId: '5001' }, h.deps), 4);
+  assert.ok(!h.calls.some((c) => c.method === 'PATCH'));
+});
+
+await test('--batch refuses a task that is not a page tweak', async () => {
+  const h = harness({ batch: BATCH(), source: 'copy-proposal' });
+  const logged = [];
+  const origErr = console.error;
+  console.error = (m) => logged.push(String(m));
+  try { assert.equal(await apply.batchMain({ taskId: '5001' }, h.deps), 2); } finally { console.error = origErr; }
+  assert.ok(logged.some((m) => m.includes('not_a_page_tweak')));
+  assert.deepEqual(h.writes, []);
+});
+
+summary();