@bongos/core 1.19.1057 → 1.19.1059

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

@@ -188,15 +188,65 @@ await test('the JS enums match the migration CHECK constraints exactly', async (
   const url = await import('node:url');
   const path = await import('node:path');
   const here = path.dirname(url.fileURLToPath(import.meta.url));
-  const sql = fs.readFileSync(path.join(here, '..', 'migrations', 'copy_desk_001_flags.sql'), 'utf8');
+  // Every migration, oldest first: a later one may widen a CHECK (TW06's
+  // copy_desk_002 widens scope), and the LAST definition is the one in force.
+  const dir = path.join(here, '..', 'migrations');
+  const sql = fs.readdirSync(dir).filter((x) => x.endsWith('.sql')).sort()
+    .map((x) => fs.readFileSync(path.join(dir, x), 'utf8')).join('\n');
   for (const [name, list] of [['kind', flags.KINDS], ['scope', flags.SCOPES], ['status', flags.STATUSES]]) {
-    const m = new RegExp(`CHECK \\(${name} IN \\(([^)]*)\\)\\)`).exec(sql);
+    const all = [...sql.matchAll(new RegExp(`CHECK \\(${name} IN \\(([^)]*)\\)\\)`, 'g'))];
+    const m = all[all.length - 1];
     assert.ok(m, `migration has no CHECK for ${name}`);
     const inSql = m[1].split(',').map((s) => s.trim().replace(/'/g, ''));
     assert.deepEqual(inSql.sort(), [...list].sort(), `${name} enum drifted between flags.js and the migration`);
   }
 });
 
+// ---------------------------------------------------------------------------
+// Page asks (task 1004317 / TW06, ADR 0341 D6).
+// ---------------------------------------------------------------------------
+
+console.log('copy-desk: page asks');
+
+await test('the flag route refuses scope page and points at the ask route', () => {
+  const r = ok({ scope: 'page', surface: 'landing', reason: GOOD_REASON });
+  assert.equal(r.ok, false);
+  assert.equal(r.code, 'bad_scope');
+  assert.deepEqual([...r.detail.allowed], ['string', 'surface']);
+  assert.ok(/asks/.test(r.detail.why));
+});
+
+await test('a page ask carries the flag reason floor', () => {
+  const thin = flags.normalizePageAsk({ reason: '  do it  ' }, 'landing:index');
+  assert.equal(thin.ok, false);
+  assert.equal(thin.code, 'reason_too_thin');
+  const long = flags.normalizePageAsk({ reason: 'x'.repeat(flags.MAX_REASON_CHARS + 1) }, 'landing:index');
+  assert.equal(long.code, 'reason_too_long');
+});
+
+await test('a page ask is scope page, points at the page twice, and holds no text', () => {
+  const r = flags.normalizePageAsk({ reason: GOOD_REASON }, 'builders:studio');
+  assert.equal(r.ok, true);
+  assert.equal(r.value.scope, 'page');
+  assert.equal(r.value.page_id, 'builders:studio');
+  // surface = page id: what makes 001's one-open-per-target index mean one
+  // open ask per (builder, page), and what copy_desk_flags_page_surface_chk pins.
+  assert.equal(r.value.surface, 'builders:studio');
+  assert.equal(r.value.string_id, null);
+  assert.equal(r.value.text_at_flag, null);
+});
+
+await test('the migration pins the page target both ways and ties surface to the page', async () => {
+  const fs = await import('node:fs');
+  const url = await import('node:url');
+  const path = await import('node:path');
+  const here = path.dirname(url.fileURLToPath(import.meta.url));
+  const sql = fs.readFileSync(path.join(here, '..', 'migrations', 'copy_desk_002_page_asks.sql'), 'utf8');
+  assert.ok(/\(scope = 'page'\) = \(page_id IS NOT NULL\)/.test(sql), 'page_id present exactly for scope page');
+  assert.ok(/\(scope = 'string'\) = \(string_id IS NOT NULL\)/.test(sql), 'the string half of the target rule survives the widening');
+  assert.ok(/scope <> 'page' OR surface = page_id/.test(sql), 'a page ask keeps surface = page_id');
+});
+
 // ---------------------------------------------------------------------------
 // Closing a flag.
 // ---------------------------------------------------------------------------

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

@@ -59,9 +59,15 @@ const stripComments = (src) => src
   .replace(/^\s*\/\/.*$/gm, ' ')
   .replace(/--[^\n]*/g, ' ');
 
+// Every file of the module's request path. TW05 (task 1004316) added the page
+// reads: pages.js (the page-tweak block format), page-status.js (the derived
+// status, drift and tally) and page-data.js (the read side of the page
+// inventory and readings). They are held to the same two rules as the rest.
+const MODULE_FILES = ['registry.js', 'flags.js', 'proposals.js', 'pages.js', 'page-status.js', 'page-data.js', 'routes/copy-desk.js'];
+
 console.log('copy-desk: NO LIVE CMS');
 
-await test('the write surface is exactly the three verbs the module defines', () => {
+await test('the write surface is exactly the verbs the module defines', () => {
   const src = stripComments(read('routes/copy-desk.js'));
   const found = [...src.matchAll(/router\.(post|put|patch|delete)\(\s*'([^']+)'/g)]
     .map((m) => `${m[1].toUpperCase()} ${m[2]}`)
@@ -69,12 +75,21 @@ await test('the write surface is exactly the three verbs the module defines', ()
   assert.deepEqual(found, [
     'POST /copy-desk/flags',
     'POST /copy-desk/flags/:id/close',
+    // TW06 (task 1004317, ADR 0341 D5, D6, D11): the page claim opens or takes a
+    // TASK and a web claim through the lifecycle port; the page ask writes one
+    // flag row whose target is a page id. Neither stores wording.
+    'POST /copy-desk/pages/:pageId/asks',
+    'POST /copy-desk/pages/:pageId/claim',
     'POST /copy-desk/proposals',
   ], 'a new write route on this module must be a deliberate, reviewed change to this list');
 });
 
+// Every migration this module ships, oldest first (the list is pinned below).
+const MIGRATION_FILES = ['copy_desk_001_flags.sql', 'copy_desk_002_page_asks.sql'];
+const allMigrationSql = () => MIGRATION_FILES.map((f) => stripComments(read(`migrations/${f}`))).join('\n');
+
 await test('no column on copy_desk_flags could hold replacement text', () => {
-  const sql = stripComments(read('migrations/copy_desk_001_flags.sql'));
+  const sql = allMigrationSql();
   // The names a "just store the suggested wording" column would plausibly take.
   const forbidden = /\b(new_text|proposed_text|suggested_text|replacement|replacement_text|new_copy|proposed_copy|override_text|value_text)\b/i;
   const hit = forbidden.exec(sql);
@@ -82,22 +97,26 @@ await test('no column on copy_desk_flags could hold replacement text', () => {
     `copy_desk_flags must carry a judgement and a pointer, never replacement copy (found "${hit && hit[0]}")`);
 });
 
-await test('R03 added no migration — a proposal is a task, not a row here', () => {
+await test('the module has exactly its two migrations — a proposal and a page round are tasks, not rows here', () => {
   // The load-bearing one. R03's obvious-but-wrong implementation is a
   // `copy_desk_proposals` table, which is the forbidden column with extra steps:
   // once the wording lives in this module's schema, one plausible read of it
   // turns the module into the copy source. The proposal lives on the TASK.
   const migrations = fs.readdirSync(path.join(MODULE_DIR, 'migrations')).sort();
-  assert.deepEqual(migrations, ['copy_desk_001_flags.sql'],
-    'a second migration in this module needs a hard look at whether it stores copy');
+  // TW06 (task 1004317) added the second, deliberately: copy_desk_002_page_asks
+  // widens the flag to a page scope and adds one POINTER column, page_id. It
+  // stores no wording; a page round, like a proposal, is a task.
+  assert.deepEqual(migrations, MIGRATION_FILES,
+    'another migration in this module needs a hard look at whether it stores copy');
 });
 
 await test('the only text column is the historical snapshot, and it is never the live source', () => {
-  const sql = stripComments(read('migrations/copy_desk_001_flags.sql'));
-  const textish = [...sql.matchAll(/^\s{2}(\w+)\s+text\b/gm)].map((m) => m[1]);
-  assert.deepEqual(textish.sort(), [
-    'file_at_flag', 'kind', 'reason', 'resolution_note', 'scope', 'status', 'string_id', 'surface', 'text_at_flag',
-  ], 'a new text column here needs a deliberate look at whether it is copy');
+  const sql = allMigrationSql();
+  const created = [...sql.matchAll(/^\s{2}(\w+)\s+text\b/gm)].map((m) => m[1]);
+  const added = [...sql.matchAll(/ADD\s+COLUMN\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)\s+text\b/gi)].map((m) => m[1]);
+  assert.deepEqual([...created, ...added].sort(), [
+    'file_at_flag', 'kind', 'page_id', 'reason', 'resolution_note', 'scope', 'status', 'string_id', 'surface', 'text_at_flag',
+  ], 'a new text column here needs a deliberate look at whether it is copy (page_id, TW06, is a page pointer)');
 
   // And the live read path is the registry, not the row: annotateFlag fills
   // `current` from the registry index every time.
@@ -110,7 +129,7 @@ await test('this module never writes to the surfaces it inventories', () => {
   // The registry is generated by R01 and committed. If this module ever gained a
   // write to docs/copy-registry.json — or to any surface file — the inventory
   // would stop describing the tree and start describing itself.
-  for (const rel of ['registry.js', 'flags.js', 'proposals.js', 'routes/copy-desk.js']) {
+  for (const rel of MODULE_FILES) {
     const src = stripComments(read(rel));
     assert.equal(/fs\.(writeFile|writeFileSync|appendFile|appendFileSync|rm|unlink|mkdir)/.test(src), false,
       `${rel} performs a filesystem WRITE — this module reads the registry and never writes it`);
@@ -121,16 +140,24 @@ await test('the proposal domain holds no path to a renderer — it composes text
   // proposals.js is the file that handles replacement wording, so it is the file
   // most able to become a copy source by accident. It must be PURE: no fs, no
   // DB, no network. Its output goes into a task description and nowhere else.
-  const src = stripComments(read('proposals.js'));
-  for (const forbidden of ['require(', 'fs.', 'pool', 'fetch(']) {
-    assert.equal(src.includes(forbidden), false,
-      `proposals.js must stay pure — it must not reach for ${forbidden}`);
+  // pages.js joins it (ADR 0341 D4): it holds a page batch's replacement
+  // wording, the same material at page scale.
+  for (const rel of ['proposals.js', 'pages.js']) {
+    const src = stripComments(read(rel));
+    for (const forbidden of ['require(', 'fs.', 'pool', 'fetch(']) {
+      assert.equal(src.includes(forbidden), false,
+        `${rel} must stay pure — it must not reach for ${forbidden}`);
+    }
   }
 });
 
 await test('the proposal route creates a TASK and does not write a string anywhere', () => {
   const src = stripComments(read('routes/copy-desk.js'));
-  const route = src.slice(src.indexOf("router.post('/copy-desk/proposals'"));
+  // Bounded to THIS handler: the slice ends where the next route begins, so a
+  // later route (the page ask does call insertFlag) is not read as this one.
+  const start = src.indexOf("router.post('/copy-desk/proposals'");
+  const next = src.indexOf('router.', start + 1);
+  const route = src.slice(start, next === -1 ? undefined : next);
   assert.ok(/lifecycle\.createTask\(/.test(route),
     'the proposal path must land in the ledger via lifecycle.createTask');
   // No INSERT/UPDATE of this module's own tables on the proposal path — the
@@ -139,6 +166,25 @@ await test('the proposal route creates a TASK and does not write a string anywhe
     'the proposal path must not write a row in this module — the task IS the record');
 });
 
+await test('the page claim creates a TASK through the port and writes no row here; the ask writes a pointer', () => {
+  const src = stripComments(read('routes/copy-desk.js'));
+  const handler = (path) => {
+    const start = src.indexOf(`router.post('${path}'`);
+    assert.ok(start >= 0, `${path} is mounted`);
+    const next = src.indexOf('router.', start + 1);
+    return src.slice(start, next === -1 ? undefined : next);
+  };
+  const claim = handler('/copy-desk/pages/:pageId/claim');
+  assert.ok(/lifecycle\.webClaimPageTweak\(/.test(claim), 'the page claim must land in the ledger via the lifecycle port');
+  assert.equal(/insertFlag|closeFlag|INSERT INTO|UPDATE |description:\s*req\.body/i.test(claim), false,
+    'the page claim must write no row in this module and take no wording from the request');
+  const ask = handler('/copy-desk/pages/:pageId/asks');
+  assert.ok(/normalizePageAsk\(/.test(ask) && /insertFlag\(/.test(ask), 'the ask files through the validated flag write');
+  // The round's description is composed by pages.js from the INVENTORY page,
+  // never from anything a caller sent.
+  assert.ok(/roundTaskBody\(page, n\)/.test(claim), 'the round body comes from pages.roundTaskBody over the inventory page');
+});
+
 await test('the module manifest declares no seam another module could write copy through', () => {
   const manifest = JSON.parse(read('module.json'));
   assert.deepEqual(manifest.provides, [], 'a provided port here would be a copy write path for every other module');
@@ -160,7 +206,7 @@ await test('the applier is the only writer, it lives outside the request path, a
   //    exact line to run, and that instruction is the whole handoff. What must
   //    not exist is a require/import edge, which would put a file write one
   //    function call away from a request handler.
-  for (const rel of ['registry.js', 'flags.js', 'proposals.js', 'routes/copy-desk.js']) {
+  for (const rel of MODULE_FILES) {
     const src = stripComments(read(rel));
     assert.equal(/(?:require|import)\s*\(?\s*['"][^'"]*copy-apply/.test(src), false,
       `${rel} must not IMPORT the applier — it runs under a claim, not under a request`);

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

@@ -0,0 +1,240 @@
+// modules/copy-desk/tests/copy_page_status.mjs — Tweak Mode's three reads, pure
+// (task 1004316 / BV2.TW05, ADR 0341 D7 and D8).
+//
+// The done-when: all three reads are correct for a fixture with an UNTWEAKED
+// page, a page TWEAKED TWICE, and a tweaked page whose TEXT CHANGED afterwards.
+// The fixture (fixtures/page-tweak.cjs) holds exactly those, plus an open round
+// and an abandoned one, which are the two ways a count could be wrong.
+//
+// The whole path (the lifecycle port's SQL rows through the real routes) is
+// tests/copy_desk_page_reads.mjs.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const pages = require('../pages.js');
+const status = require('../page-status.js');
+const F = require('./fixtures/page-tweak.cjs');
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.stack || err.message}`); }
+}
+
+const list = () => status.composePages({ inventory: F.INVENTORY, readings: F.READINGS, tasks: F.TASKS });
+const byId = (out, id) => out.pages.find((p) => p.id === id);
+const detail = (id, over = {}) => status.composePage({
+  page: F.INVENTORY.pages.find((p) => p.id === id),
+  tasks: F.TASKS,
+  readingPage: F.READINGS.pages.find((p) => p.id === id),
+  readingsOk: true,
+  ships: [],
+  ...over,
+});
+
+console.log('copy-desk: page tweak status, Artist Review Status and the tally');
+
+// ---------------------------------------------------------------------------
+// The block format: one writer, one reader, each tested against the other.
+// ---------------------------------------------------------------------------
+
+await test('each block round-trips through its writer and its reader', () => {
+  const batch = { page_id: 'landing:index', reading_hash: 'h', submitted_at: 't', lines: [{ key: 'L0001', section: 's', before: 'a', after: 'b', placement: 'placed', file: 'f', line: 3, string_id: 'x' }], unplaced_tasks: [9] };
+  const b = pages.parseBatchBlock(pages.composeBatchBlock(batch));
+  assert.equal(b.ok, true);
+  assert.deepEqual(b.batch.lines, batch.lines);
+  assert.deepEqual(b.batch.unplaced_tasks, [9]);
+  assert.equal('kind' in b.batch, false, 'a text batch carries no kind');
+
+  const d = pages.parseDraftBlock(pages.composeDraftBlock({ page_id: 'landing:index', reading_hash: 'h', saved_at: 't', lines: [{ key: 'L0001', section: 's', before: 'a', after: 'b', placement: 'placed' }] }));
+  assert.equal(d.ok, true);
+  assert.equal(d.draft.lines[0].after, 'b');
+
+  const a = pages.parseAppliedBlock(pages.composeAppliedBlock({ page_id: 'landing:index', applied_at: 't', reading_hash_after: 'h2', lines_after: ['b'], refused: [{ key: 'L0002', code: 'target_gone' }] }));
+  assert.equal(a.ok, true);
+  assert.deepEqual(a.applied.lines_after, ['b']);
+  assert.deepEqual(a.applied.refused, [{ key: 'L0002', code: 'target_gone' }]);
+
+  const two = [pages.composeSentBackBlock({ at: '2026-09-01T00:00:00Z', by: '7', note: 'the heading is wrong' }), pages.composeSentBackBlock({ at: '2026-09-02T00:00:00Z', by: '8', note: 'still the heading' })].join('\n\n');
+  assert.equal(pages.parseSentBackBlocks(two).length, 2, 'send-backs append, and every one is read');
+});
+
+await test('a draft is never read as a batch: the fence name must end its line', () => {
+  const md = pages.composeDraftBlock({ page_id: 'landing:index', reading_hash: 'h', saved_at: 't', lines: [] });
+  assert.equal(pages.parseBatchBlock(md).code, 'no_block');
+  assert.equal(pages.blockPresence(md).batch, false);
+  assert.equal(pages.blockPresence(md).draft, true);
+});
+
+await test('a second batch is a named refusal, not a coin flip', () => {
+  const one = pages.composeBatchBlock({ page_id: 'landing:index', reading_hash: 'h', submitted_at: 't', lines: [] });
+  assert.equal(pages.parseBatchBlock(`${one}\n\n${one}`).code, 'multiple_blocks');
+});
+
+await test('the round ref parses, and anything else belongs to no page', () => {
+  assert.deepEqual(pages.parseRoundRef('page-tweak/landing:index/r12'), { page_id: 'landing:index', round: 12 });
+  for (const bad of ['page-tweak/landing/r1', 'page-tweak/landing:index/r0', 'cascade-x', null, 'page-tweak-unplaced/5/L0001']) {
+    assert.equal(pages.parseRoundRef(bad), null, String(bad));
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Read 1: per page.
+// ---------------------------------------------------------------------------
+
+await test('UNTWEAKED: an abandoned round counts for nothing, and no round at all reads the same', () => {
+  const out = list();
+  for (const id of ['landing:index', 'status:explore']) {
+    const p = byId(out, id);
+    assert.equal(p.count, 0, id);
+    assert.equal(p.status, 'Untweaked', id);
+    assert.equal(p.status_label, 'Untweaked', id);
+    assert.equal(p.open_round, null, `${id}: an abandoned round is closed`);
+    assert.equal(p.drift.changed, false, id);
+  }
+  const d = detail('landing:index');
+  assert.deepEqual(d.changelog, []);
+  assert.deepEqual(d.drift.ships, []);
+});
+
+await test('TWEAKED TWICE: the count is 2, the label says so, and the UI count is reserved at 0', () => {
+  const p = byId(list(), 'landing:projects');
+  assert.equal(p.count, 2);
+  assert.equal(p.text_count, 2);
+  assert.equal(p.ui_count, 0);
+  assert.equal(p.status, 'Text tweaked');
+  assert.equal(p.status_label, 'Text tweaked 2x');
+  assert.equal(p.drift.known, true);
+  assert.equal(p.drift.changed, false, 'the page says exactly what the last round left');
+  assert.equal(p.drift.since_task_id, '102', 'drift is measured from the LATEST shipped round');
+});
+
+await test('TWEAKED TWICE: the changelog is one entry per shipped round, newest first, with artist, date and lines', () => {
+  const d = detail('landing:projects');
+  assert.deepEqual(d.changelog.map((c) => [c.task_id, c.round, c.artist && c.artist.login, c.line_count]), [
+    ['102', 2, 'bob', 2],
+    ['101', 1, 'alice', 1],
+  ]);
+  assert.equal(d.changelog[0].shipped_at, '2026-09-25T10:00:00.000Z');
+  assert.deepEqual(d.changelog[1].lines, [{ key: 'L0002', section: 'list', before: 'All projects', after: 'Every projekt' }]);
+});
+
+await test('CHANGED AFTERWARDS: a tweaked page keeps its count and names the lines that moved', () => {
+  const p = byId(list(), 'builders:studio');
+  assert.equal(p.count, 1, 'drift never lowers the count');
+  assert.equal(p.status_label, 'Text tweaked 1x');
+  assert.equal(p.drift.known, true);
+  assert.equal(p.drift.changed, true);
+  assert.equal(p.drift.changed_count, 1, 'the shared shell title changed too, and must not count');
+  assert.equal(p.drift.removed_count, 1);
+  assert.equal('changed_lines' in p.drift, false, 'the list carries counts; the lines are the detail read');
+
+  const d = detail('builders:studio', { ships: F.STUDIO_SHIPS });
+  assert.deepEqual(d.drift.changed_lines, [{ key: 'L0002', section: 'greeting', text: 'Welcome back' }]);
+  assert.deepEqual(d.drift.removed_lines, ['Welcome home']);
+  assert.deepEqual(d.drift.ships, [{ task_id: '555', title: 'Reword the studio greeting', shipped_at: '2026-09-22T09:00:00.000Z' }]);
+  assert.equal(d.drift.since, '2026-09-20T10:00:00.000Z');
+  assert.equal(status.lastRoundShippedAt(F.TASKS, 'builders:studio'), d.drift.since, 'the route reads ships from the same instant drift is measured from');
+  assert.equal(status.lastRoundShippedAt(F.TASKS, 'landing:index'), null, 'an untweaked page has no since');
+});
+
+await test('drift is a MULTISET compare: a page that loses one of two identical lines has drifted', () => {
+  const rounds = [F.row({ id: '1', status: 'shipped', source_ref: 'page-tweak/landing:index/r1', shipped_at: '2026-09-01T00:00:00Z',
+    description: F.describe({ pageId: 'landing:index', submittedAt: 't', lines: [], appliedAt: 't', linesAfter: ['Save', 'Save'] }) })];
+  const indexed = status.indexRounds(rounds).get('landing:index');
+  const d = status.driftFor({ lines: [{ key: 'L0001', text: 'Save', placement: 'placed' }] }, indexed, true);
+  assert.equal(d.changed, true);
+  assert.deepEqual(d.removed_lines, ['Save']);
+});
+
+await test('drift says it does not know, rather than guessing, when a reading or an applied block is missing', () => {
+  const noReadings = status.composePages({ inventory: F.INVENTORY, readings: null, tasks: F.TASKS });
+  const studio = byId(noReadings, 'builders:studio');
+  assert.equal(studio.drift.known, false);
+  assert.equal(studio.drift.reason, 'readings_missing');
+  assert.equal(studio.count, 1, 'status and count come from the ledger and still read true');
+  assert.equal(byId(noReadings, 'landing:index').drift.known, true, 'an untweaked page has nothing to drift from');
+
+  const noPage = detail('builders:studio', { readingPage: null });
+  assert.equal(noPage.drift.reason, 'page_not_read');
+
+  const bare = F.TASKS.map((t) => (t.id === '201' ? { ...t, description: 'no blocks' } : t));
+  assert.equal(detail('builders:studio', { tasks: bare }).drift.reason, 'no_applied_block');
+});
+
+await test('a batch of kind ui counts as UI, and text plus ui reads Both', () => {
+  const ui = F.row({ id: '9', status: 'shipped', source_ref: 'page-tweak/landing:index/r2', shipped_at: '2026-09-02T00:00:00Z',
+    description: pages.composeBatchBlock({ page_id: 'landing:index', reading_hash: 'h', submitted_at: 't', kind: 'ui', lines: [] }) });
+  const text = F.row({ id: '8', status: 'shipped', source_ref: 'page-tweak/landing:index/r1', shipped_at: '2026-09-01T00:00:00Z', description: '' });
+  assert.equal(status.countsFor(status.indexRounds([ui]).get('landing:index')).status_label, 'UI tweaked 1x');
+  const both = status.countsFor(status.indexRounds([ui, text]).get('landing:index'));
+  assert.deepEqual([both.text_count, both.ui_count, both.status_label], [1, 1, 'Both 2x']);
+});
+
+// ---------------------------------------------------------------------------
+// The open round's state (D7).
+// ---------------------------------------------------------------------------
+
+await test('the open round and its holder are named: a web claim is the artist writing', () => {
+  const d = detail('builders:studio');
+  assert.deepEqual(d.open_round, { task_id: '202', round: 2, status: 'active', state: 'writing', holder: { id: '8', login: 'bob' } });
+});
+
+await test('every row of the D7 state table', () => {
+  const batch = F.describe({ pageId: 'landing:index', submittedAt: 't', lines: [] });
+  const draft = F.describe({ pageId: 'landing:index', submittedAt: 't', lines: [], draft: true });
+  const sentBackAfterApply = F.describe({ pageId: 'landing:index', submittedAt: 't', lines: [], appliedAt: '2026-09-01T00:00:00Z', linesAfter: [],
+    sentBack: [{ at: '2026-09-02T00:00:00Z', by: '7', note: 'the heading is wrong' }] });
+  const applied = F.describe({ pageId: 'landing:index', submittedAt: 't', lines: [], appliedAt: '2026-09-03T00:00:00Z', linesAfter: [] });
+  const cases = [
+    [{ status: 'active', holder_id: '7', holder_worktree: false }, 'writing'],
+    [{ status: 'active', holder_id: '7', holder_worktree: true }, 'applying'],
+    [{ status: 'ready', description: draft }, 'draft'],
+    [{ status: 'ready', description: batch }, 'submitted'],
+    [{ status: 'ready', description: sentBackAfterApply }, 'submitted'],
+    [{ status: 'ready', description: applied }, 'unknown'],
+    [{ status: 'completed', grade_passed: true }, 'waiting_for_artist'],
+    [{ status: 'completed', grade_passed: false }, 'applying'],
+    [{ status: 'confirmed' }, 'landing'],
+  ];
+  for (const [over, want] of cases) assert.equal(status.roundState(F.row(over)), want, JSON.stringify(over));
+});
+
+// ---------------------------------------------------------------------------
+// Read 2: per surface, Artist Review Status.
+// ---------------------------------------------------------------------------
+
+await test('Artist Review Status: N of M per surface, in the mock order, and drift does not lower N', () => {
+  const out = list();
+  assert.deepEqual(out.surfaces.map((s) => [s.id, s.label, s.line]), [
+    ['landing', 'Landing', '1 of 2 tweaked'],
+    ['builders', 'Builders hall', '1 of 1 tweaked'],
+    ['status', 'Status', '0 of 1 tweaked'],
+  ]);
+  assert.equal(out.totals.line, '2 of 4 pages tweaked');
+});
+
+// ---------------------------------------------------------------------------
+// Read 3: per artist, the tally.
+// ---------------------------------------------------------------------------
+
+await test('the tally sums only tweak.page_approved rows, and this week is the trailing seven days', () => {
+  const t = status.composeTally({ builderId: '7', tasks: F.TASKS, creditRows: F.CREDIT_ROWS, now: F.NOW });
+  assert.equal(t.credits, 60, 'the task.shipped row is another stream');
+  assert.equal(t.this_week, 30, 'the September 1 row is outside the week');
+  assert.equal(t.pages_tweaked, 2, 'alice authored r1 of Projects and r1 of Studio');
+  assert.equal(t.week_since, '2026-09-20T12:00:00.000Z');
+});
+
+await test('no payout rows yet (TW13 unbuilt) reads 0 credits, while pages tweaked still counts', () => {
+  const bob = status.composeTally({ builderId: '8', tasks: F.TASKS, creditRows: [], now: F.NOW });
+  assert.deepEqual([bob.credits, bob.this_week, bob.pages_tweaked], [0, 0, 1], 'an open round is not a page tweaked');
+  const carol = status.composeTally({ builderId: '9', tasks: F.TASKS, creditRows: [], now: F.NOW });
+  assert.deepEqual([carol.credits, carol.this_week, carol.pages_tweaked], [0, 0, 0], 'an abandoned round is not a page tweaked');
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);

package/modules/copy-desk/tests/fixtures/page-tweak.cjs

@@ -0,0 +1,154 @@
+// modules/copy-desk/tests/fixtures/page-tweak.cjs — one small world for the
+// Tweak Mode reads (task 1004316 / BV2.TW05). The done-when's three cases:
+//
+//   UNTWEAKED            landing:index. Its only round was abandoned, so it has
+//                        no count, and status:explore has no round at all.
+//   TWEAKED TWICE        landing:projects, r1 by alice then r2 by bob; the page
+//                        still says exactly what r2 left, so no drift.
+//   TWEAKED, THEN MOVED  builders:studio, r1 by alice; a later ship reworded one
+//                        line ("Welcome home" -> "Welcome back") and the shared
+//                        shell title changed too, which drift must ignore. A
+//                        second round is open, held by bob on a web claim.
+//
+// The task rows are in the exact column shape of the lifecycle port's
+// listPageTweakTasks() SELECT, so the same rows feed the pure tests and the
+// whole-path route test's fake pool.
+
+'use strict';
+
+const pages = require('../../pages.js');
+
+const NOW = new Date('2026-09-27T12:00:00.000Z');
+const ALICE = { id: '7', login: 'alice' };
+const BOB = { id: '8', login: 'bob' };
+const NOBODY = { id: '9', login: 'carol' };
+
+const STUDIO_FILES = ['modules/hall-ui/public/studio.html', 'modules/hall-ui/public/shell.js'];
+
+const INVENTORY = {
+  schema: 1,
+  surfaces: [
+    { id: 'builders', pages: 1 },
+    { id: 'landing', pages: 2 },
+    { id: 'status', pages: 1 },
+  ],
+  pages: [
+    { id: 'builders:studio', surface: 'builders', title: 'Studio', path: '/studio', files: STUDIO_FILES },
+    { id: 'landing:index', surface: 'landing', title: 'Home', path: '/', files: ['modules/public-landing/public/index.html'] },
+    { id: 'landing:projects', surface: 'landing', title: 'Projects', path: '/projects', files: ['modules/public-landing/public/projects.html'] },
+    { id: 'status:explore', surface: 'status', title: 'Explore', path: '/explore', files: ['modules/status-ui/public/explore.html'] },
+  ],
+};
+
+const line = (key, section, text, placement = 'placed') => ({ key, section, text, placement });
+
+const READINGS = {
+  schema: 1,
+  pages: [
+    { id: 'builders:studio', reading_hash: 'studio-now', lines: [
+      line('L0001', 'top bar', 'Studio, renamed', 'shared'),
+      line('L0002', 'greeting', 'Welcome back'),
+      line('L0003', 'greeting', 'Resume'),
+    ] },
+    { id: 'landing:index', reading_hash: 'index-now', lines: [
+      line('L0001', 'skip link', 'Skip to content', 'shared'),
+      line('L0002', 'hero', 'Build here'),
+    ] },
+    { id: 'landing:projects', reading_hash: 'projects-now', lines: [
+      line('L0001', 'skip link', 'Skip to content', 'shared'),
+      line('L0002', 'list', 'Every project'),
+      line('L0003', 'list', 'Start one'),
+    ] },
+    { id: 'status:explore', reading_hash: 'explore-now', lines: [line('L0001', 'hero', 'Explore')] },
+  ],
+};
+
+function describe({ pageId, submittedAt, lines, appliedAt, linesAfter, draft, sentBack }) {
+  const parts = [`Tweak ${pageId}.`];
+  if (draft) parts.push(pages.composeDraftBlock({ page_id: pageId, reading_hash: 'h', saved_at: submittedAt, lines }));
+  if (!draft) {
+    parts.push(pages.composeBatchBlock({
+      page_id: pageId, reading_hash: 'h', submitted_at: submittedAt,
+      lines: lines.map((l) => ({ ...l, placement: 'placed', file: 'x.html', line: 1, string_id: 'abc' })),
+    }));
+  }
+  if (appliedAt) parts.push(pages.composeAppliedBlock({ page_id: pageId, applied_at: appliedAt, reading_hash_after: 'h2', lines_after: linesAfter, refused: [] }));
+  for (const s of sentBack || []) parts.push(pages.composeSentBackBlock(s));
+  return parts.join('\n\n');
+}
+
+function row(over) {
+  return {
+    id: null, status: 'ready', title: 'Tweak', description: '', source_ref: null, touches: [],
+    shipped_at: null, created_at: new Date('2026-08-01T00:00:00Z'), updated_at: new Date('2026-08-01T00:00:00Z'),
+    grade_passed: null, holder_id: null, holder_login: null, holder_worktree: false,
+    artist_id: null, artist_login: null,
+    ...over,
+  };
+}
+
+const TASKS = [
+  row({
+    id: '101', status: 'shipped', source_ref: pages.roundSourceRef('landing:projects', 1),
+    shipped_at: new Date('2026-09-01T10:00:00Z'), grade_passed: true,
+    artist_id: ALICE.id, artist_login: ALICE.login,
+    description: describe({
+      pageId: 'landing:projects', submittedAt: '2026-08-30T10:00:00Z',
+      lines: [{ key: 'L0002', section: 'list', before: 'All projects', after: 'Every projekt' }],
+      appliedAt: '2026-08-31T10:00:00Z', linesAfter: ['Every projekt', 'Begin'],
+    }),
+  }),
+  row({
+    id: '102', status: 'shipped', source_ref: pages.roundSourceRef('landing:projects', 2),
+    shipped_at: new Date('2026-09-25T10:00:00Z'), grade_passed: true,
+    artist_id: BOB.id, artist_login: BOB.login,
+    description: describe({
+      pageId: 'landing:projects', submittedAt: '2026-09-24T10:00:00Z',
+      lines: [
+        { key: 'L0002', section: 'list', before: 'Every projekt', after: 'Every project' },
+        { key: 'L0003', section: 'list', before: 'Begin', after: 'Start one' },
+      ],
+      appliedAt: '2026-09-24T18:00:00Z', linesAfter: ['Every project', 'Start one'],
+    }),
+  }),
+  row({
+    id: '201', status: 'shipped', source_ref: pages.roundSourceRef('builders:studio', 1),
+    shipped_at: new Date('2026-09-20T10:00:00Z'), grade_passed: true, touches: STUDIO_FILES,
+    artist_id: ALICE.id, artist_login: ALICE.login,
+    description: describe({
+      pageId: 'builders:studio', submittedAt: '2026-09-19T10:00:00Z',
+      lines: [{ key: 'L0002', section: 'greeting', before: 'Welcome', after: 'Welcome home' }],
+      appliedAt: '2026-09-19T18:00:00Z', linesAfter: ['Welcome home', 'Resume'],
+    }),
+  }),
+  row({
+    id: '202', status: 'active', source_ref: pages.roundSourceRef('builders:studio', 2),
+    holder_id: BOB.id, holder_login: BOB.login, holder_worktree: false,
+    artist_id: BOB.id, artist_login: BOB.login,
+    description: describe({
+      pageId: 'builders:studio', submittedAt: '2026-09-26T10:00:00Z', draft: true,
+      lines: [{ key: 'L0002', section: 'greeting', before: 'Welcome back', after: 'Good to see you' }],
+    }),
+  }),
+  row({
+    id: '301', status: 'abandoned', source_ref: pages.roundSourceRef('landing:index', 1),
+    artist_id: NOBODY.id, artist_login: NOBODY.login,
+    description: 'Tweak landing:index.',
+  }),
+];
+
+// The later ship that reworded the studio greeting, for drift attribution.
+const STUDIO_SHIPS = [
+  { id: '555', title: 'Reword the studio greeting', shipped_at: new Date('2026-09-22T09:00:00Z') },
+];
+
+// credit_log rows (economy's creditLedger shape). One of alice's is outside the
+// trailing week and one is inside; the task.shipped row is another stream and
+// must never reach the tally.
+const CREDIT_ROWS = [
+  { id: 1, builder_id: 7, delta: 30, reason: 'tweak.page_approved:101', task_id: 101, recorded_at: new Date('2026-09-01T10:00:00Z') },
+  { id: 2, builder_id: 7, delta: 30, reason: 'tweak.page_approved:201', task_id: 201, recorded_at: new Date('2026-09-24T10:00:00Z') },
+  { id: 3, builder_id: 7, delta: 50, reason: 'task.shipped', task_id: 555, recorded_at: new Date('2026-09-26T10:00:00Z') },
+];
+
+module.exports = { NOW, ALICE, BOB, NOBODY, STUDIO_FILES, INVENTORY, READINGS, TASKS, STUDIO_SHIPS, CREDIT_ROWS, describe, row };

package/modules/lifecycle/lifecycle.js

@@ -24,6 +24,8 @@ const helpRequests = require('./help-requests');
 const taskRecommendations = require('./task-recommendations');
 const activity = require('./activity');
 const mingle = require('./mingle');
+const pageTweakReads = require('./page-tweak-reads');
+const pageTweakClaim = require('./page-tweak-claim');
 
 module.exports = {
   // --- retired doorway leaks (ADR 0093 §3) ---------------------------------
@@ -104,6 +106,18 @@ module.exports = {
   // core POST /tasks vector does, so a double-submitted proposal resolves to the
   // task it already made instead of littering the board with twins.
   findTaskBySourceRef: (...a) => db.findTaskBySourceRef(...a),
+  // Tweak Mode's ledger reads (task 1004316 / BV2.TW05, ADR 0341 D8): every
+  // page-tweak task with its grade, active claim and artist, and the ships that
+  // touched a page since its last round. copy-desk derives status, changelog,
+  // drift and the tally from these; there is no status table.
+  listPageTweakTasks: (...a) => pageTweakReads.listPageTweakTasks(...a),
+  shippedTasksTouchingSince: (...a) => pageTweakReads.shippedTasksTouchingSince(...a),
+  // The page claim (task 1004317 / BV2.TW06, ADR 0341 D2, D5): find or create a
+  // page's open tweak round and web-claim it, in one transaction under an
+  // advisory lock on the page. ADR 0341 D11 names this port entry webClaimTask;
+  // it is page-shaped because the find-or-create has to share the claim's
+  // transaction. See modules/lifecycle/page-tweak-claim.js.
+  webClaimPageTweak: (...a) => pageTweakClaim.webClaimPageTweak(...a),
   listVersions: (...a) => db.listVersions(...a),
   versionProgress: (...a) => db.versionProgress(...a),
   recentShippedTasks: (...a) => db.recentShippedTasks(...a),