@bongos/core 1.19.1057 → 1.19.1058

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

@@ -45,6 +45,9 @@ const api = require('../../../src/module-api');
 const flags = require('../flags');
 const registry = require('../registry');
 const proposals = require('../proposals');
+const pageData = require('../page-data');
+const pageStatus = require('../page-status');
+const pages = require('../pages');
 
 const { validateOrRespond } = api;
 
@@ -106,6 +109,67 @@ function registryOrFail(res) {
   return loaded;
 }
 
+// ---------------------------------------------------------------------------
+// Tweak Mode's reads (task 1004316 / BV2.TW05, ADR 0341 D8 and D11).
+//
+// The page inventory is REQUIRED: without it there is no page to speak of, so
+// its absence is a named 503 carrying the generator command, the registry's own
+// rule. The page readings are OPTIONAL: status, count and changelog come from
+// the ledger and read true without them, so a missing readings file only marks
+// drift unknown (`readings_missing`). Both files ship in the publish manifest
+// (ADR 0341 D1); these branches are for an instance on an older core or a
+// checkout that has not run the generators.
+// ---------------------------------------------------------------------------
+
+function inventoryOrFail(res) {
+  const loaded = pageData.loadInventory();
+  if (!loaded.ok) {
+    res.fail(loaded.code, 503, {
+      ...loaded.detail,
+      what_this_means: 'Tweak Mode keys every record on a page from the committed page inventory. Without it there is no list of pages to report on.',
+    });
+    return null;
+  }
+  return loaded;
+}
+
+function readingsState() {
+  const loaded = pageData.loadReadings();
+  return loaded.ok
+    ? { data: loaded.data, info: { ok: true, at: loaded.at } }
+    : { data: null, info: { ok: false, code: loaded.code, run: loaded.detail.run } };
+}
+
+// The ledger reads come through the lifecycle port. copy-desk consumes
+// lifecycle, so the port is always there on a booted instance; the check is for
+// a core whose lifecycle predates these reads.
+function pageReadsOrFail(res) {
+  const lifecycle = api.resolveOptional && api.resolveOptional('lifecycle');
+  if (!lifecycle || typeof lifecycle.listPageTweakTasks !== 'function') {
+    res.fail('lifecycle_unavailable', 503, {
+      what_this_means: 'Page status is derived from the task ledger, and this instance cannot read it.',
+    });
+    return null;
+  }
+  return lifecycle;
+}
+
+// Every `tweak.page_approved:` credit row the caller has, through the reward
+// port (credit_log is economy's table). No reward port, or no rows yet (TW13
+// has not built the payout), reads as none: a tally of 0 is the truth then.
+//
+// ONE bounded query. An approved page books one row, so the cap is thousands of
+// pages for one artist; past it the tally says `truncated` (creditLedger's
+// `total` is the unpaginated count) rather than paging in a loop.
+const TALLY_ROW_CAP = 5000;
+async function tallyCreditRows(builderId) {
+  const reward = api.resolveOptional && api.resolveOptional('reward');
+  if (!reward || typeof reward.creditLedger !== 'function') return { rows: [], truncated: false };
+  const { rows, total } = await reward.creditLedger(builderId, { reasonPrefix: pageStatus.TALLY_REASON_PREFIX, limit: TALLY_ROW_CAP });
+  const list = rows || [];
+  return { rows: list, truncated: Number(total) > list.length };
+}
+
 module.exports = function buildCopyDeskRouter() {
   const router = express.Router();
 
@@ -449,5 +513,96 @@ module.exports = function buildCopyDeskRouter() {
     }
   });
 
+  // -------------------------------------------------------------------------
+  // GET /copy-desk/pages — every page's status, count and drift, plus the
+  // per-surface rollup, Artist Review Status ("N of M tweaked").
+  //
+  // rank: any signed-in builder. Page status is a work list, like the queue;
+  // an artist is a craft, not a rank.
+  // -------------------------------------------------------------------------
+  router.get('/copy-desk/pages', api.requireBuilder, async (req, res) => {
+    try {
+      const inv = inventoryOrFail(res);
+      if (!inv) return;
+      const lifecycle = pageReadsOrFail(res);
+      if (!lifecycle) return;
+      const readings = readingsState();
+      const tasks = await lifecycle.listPageTweakTasks();
+      const out = pageStatus.composePages({ inventory: inv.data, readings: readings.data, tasks });
+      out.inventory = { at: inv.at };
+      out.readings = readings.info;
+      res.set('Cache-Control', 'no-store');
+      res.json(out);
+    } catch (err) {
+      log.error({ err }, 'GET /copy-desk/pages failed');
+      if (!res.headersSent) res.fail('copy_pages_failed', 500);
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // GET /copy-desk/pages/:pageId — one page: status, changelog, the lines
+  // changed since its last tweak and the ships that changed them, and the open
+  // round with its state (ADR 0341 D7).
+  //
+  // An id the inventory does not know is `unknown_page` (ADR 0341 D1).
+  // -------------------------------------------------------------------------
+  router.get('/copy-desk/pages/:pageId', api.requireBuilder, async (req, res) => {
+    try {
+      const pageId = String(req.params.pageId || '');
+      if (!pages.PAGE_ID_RE.test(pageId)) {
+        return res.fail('unknown_page', 404, { page_id: pageId, what_this_means: 'A page id is <surface>:<page>, for example landing:index.' });
+      }
+      const inv = inventoryOrFail(res);
+      if (!inv) return;
+      const page = (inv.data.pages || []).find((p) => p && p.id === pageId);
+      if (!page) {
+        return res.fail('unknown_page', 404, { page_id: pageId, what_this_means: 'The page inventory has no page with that id.' });
+      }
+      const lifecycle = pageReadsOrFail(res);
+      if (!lifecycle) return;
+      const readings = readingsState();
+      const readingPage = readings.data ? (readings.data.pages || []).find((p) => p && p.id === pageId) : null;
+      const tasks = await lifecycle.listPageTweakTasks();
+      // The ships since the page's last round are read first, so the page is
+      // composed once with everything it shows.
+      const since = pageStatus.lastRoundShippedAt(tasks, pageId);
+      const ships = since && typeof lifecycle.shippedTasksTouchingSince === 'function'
+        ? await lifecycle.shippedTasksTouchingSince({ files: page.files, since })
+        : [];
+      const out = pageStatus.composePage({ page, tasks, readingPage, readingsOk: !!readings.data, ships });
+      out.readings = readings.info;
+      res.set('Cache-Control', 'no-store');
+      res.json(out);
+    } catch (err) {
+      log.error({ err }, 'GET /copy-desk/pages/:pageId failed');
+      if (!res.headersSent) res.fail('copy_page_failed', 500);
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // GET /copy-desk/tally — the caller's corner tally in the studio: credits
+  // from approved pages, pages tweaked, and this week's gain (trailing 7 days).
+  //
+  // Always the CALLER's own tally; there is no builder parameter to widen it.
+  // Needs no inventory: it reads the ledger only.
+  // -------------------------------------------------------------------------
+  router.get('/copy-desk/tally', api.requireBuilder, async (req, res) => {
+    try {
+      const lifecycle = pageReadsOrFail(res);
+      if (!lifecycle) return;
+      const [tasks, credit] = await Promise.all([
+        lifecycle.listPageTweakTasks(),
+        tallyCreditRows(req.builder.id),
+      ]);
+      const out = pageStatus.composeTally({ builderId: req.builder.id, tasks, creditRows: credit.rows, now: new Date() });
+      out.truncated = credit.truncated;
+      res.set('Cache-Control', 'no-store');
+      res.json(out);
+    } catch (err) {
+      log.error({ err }, 'GET /copy-desk/tally failed');
+      if (!res.headersSent) res.fail('copy_tally_failed', 500);
+    }
+  });
+
   return router;
 };

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

@@ -59,6 +59,12 @@ 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', () => {
@@ -110,7 +116,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,10 +127,14 @@ 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}`);
+    }
   }
 });
 
@@ -160,7 +170,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,7 @@ const helpRequests = require('./help-requests');
 const taskRecommendations = require('./task-recommendations');
 const activity = require('./activity');
 const mingle = require('./mingle');
+const pageTweakReads = require('./page-tweak-reads');
 
 module.exports = {
   // --- retired doorway leaks (ADR 0093 §3) ---------------------------------
@@ -104,6 +105,12 @@ 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),
   listVersions: (...a) => db.listVersions(...a),
   versionProgress: (...a) => db.versionProgress(...a),
   recentShippedTasks: (...a) => db.recentShippedTasks(...a),