@bongos/core 1.19.1058 → 1.19.1060

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

@@ -10,6 +10,11 @@
 //   POST /copy-desk/proposals        — propose new wording. Creates a TASK carrying
 //                                 the patch; writes no file and stores no copy.
 //
+// Tweak Mode (ADR 0341) adds the page reads (TW05) and two page writes (TW06,
+// task 1004317): POST /copy-desk/pages/:pageId/claim opens or takes a page's
+// tweak round as a TASK with a web claim, and POST /copy-desk/pages/:pageId/asks
+// files a page ask, a flag row whose target is a page id. Neither stores copy.
+//
 // THE RANK SHAPE, AND WHY IT IS ASYMMETRIC:
 //
 //   FILING is open to every rank, deliberately. "Sourced by everyone else" is the
@@ -31,7 +36,7 @@
 // produce a TASK carrying a patch, never a write. A flag is a work request; a
 // proposal is a work request with a suggested fix attached. Neither reaches a
 // reader. modules/copy-desk/tests/copy_no_cms.mjs pins that by asserting this
-// router's write surface stays exactly these three verbs, that none of them
+// router's write surface stays exactly the listed verbs, that none of them
 // touches the filesystem, and that the one place a proposed wording is allowed
 // to rest is the GDS ledger.
 //
@@ -66,7 +71,7 @@ const log = api.logger('copy-desk');
 // lookups, the scope/string_id coupling — live in flags.normalize*, so the DB
 // constraint, the pure validator and this schema each say one thing once.
 const FLAG_BODY_SCHEMA = Object.freeze({
-  scope:       { type: 'string', enum: [...flags.SCOPES] },
+  scope:       { type: 'string', enum: [...flags.FLAG_SCOPES] },
   surface:     { required: true, type: 'string', maxLength: 128, minLength: 1 },
   string_id:   { type: 'string', maxLength: 64 },
   reason:      { required: true, type: 'string', maxLength: flags.MAX_REASON_CHARS, minLength: 1 },
@@ -90,6 +95,14 @@ const PROPOSAL_BODY_SCHEMA = Object.freeze({
   line:          { type: 'integer', min: 1 },
   flag_id:       { type: 'integer', min: 1 },
 });
+// The page claim (task 1004317 / TW06) takes nothing: who claims is the
+// session and what is claimed is the path. Strict, so a caller cannot smuggle
+// a builder, a version or a round in.
+const CLAIM_BODY_SCHEMA = Object.freeze({});
+// The page ask: a reason and nothing else. The target is the path's page id.
+const ASK_BODY_SCHEMA = Object.freeze({
+  reason: { required: true, type: 'string', maxLength: flags.MAX_REASON_CHARS, minLength: 1 },
+});
 
 // Load the registry or answer the named "no registry" state. Returns null when
 // it has already responded, so every handler is `if (!reg) return;`.
@@ -140,6 +153,51 @@ function readingsState() {
     : { data: null, info: { ok: false, code: loaded.code, run: loaded.detail.run } };
 }
 
+// Resolve :pageId against the inventory, or answer `unknown_page` (ADR 0341
+// D1). Returns null when it has already responded.
+function pageOrFail(req, res) {
+  const pageId = String(req.params.pageId || '');
+  if (!pages.PAGE_ID_RE.test(pageId)) {
+    res.fail('unknown_page', 404, { page_id: pageId, what_this_means: 'A page id is <surface>:<page>, for example landing:index.' });
+    return null;
+  }
+  const inv = inventoryOrFail(res);
+  if (!inv) return null;
+  const page = (inv.data.pages || []).find((p) => p && p.id === pageId);
+  if (!page) {
+    res.fail('unknown_page', 404, { page_id: pageId, what_this_means: 'The page inventory has no page with that id.' });
+    return null;
+  }
+  return { page, pageId, inv };
+}
+
+// An open page ask is RESOLVED when the page's next tweak ships (ADR 0341 D6).
+// Runs on the kernel's task.shipped event, after the ship has committed, so it
+// can never fail the ship: every error is logged and swallowed. The event
+// payload carries no source, so the task is read back through the port.
+async function resolveAsksOnShip(shipped, deps = {}) {
+  try {
+    const lifecycle = deps.lifecycle || (api.resolveOptional && api.resolveOptional('lifecycle'));
+    const flagsLib = deps.flags || flags;
+    if (!shipped || shipped.id == null || !lifecycle || typeof lifecycle.getTask !== 'function') return [];
+    const task = await lifecycle.getTask(shipped.id);
+    if (!task || task.source !== pages.SOURCE || task.status !== 'shipped') return [];
+    const ref = pages.parseRoundRef(task.source_ref);
+    if (!ref) return [];
+    const resolvedBy = task.shipped_by != null ? task.shipped_by : shipped.shipped_by;
+    // copy_desk_flags_closed_chk: a closed flag names who closed it. With no
+    // shipper on record the asks stay open rather than be closed by nobody.
+    if (resolvedBy == null) return [];
+    return await flagsLib.resolvePageAsks({
+      pageId: ref.page_id, taskId: task.id, resolvedBy, shippedAt: task.shipped_at || new Date().toISOString(),
+    });
+  } catch (err) {
+    log.warn({ err, task_id: shipped && shipped.id }, 'resolving page asks on ship failed (non-blocking)');
+    return [];
+  }
+}
+let _askListenerOff = null;
+
 // 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.
@@ -173,6 +231,11 @@ async function tallyCreditRows(builderId) {
 module.exports = function buildCopyDeskRouter() {
   const router = express.Router();
 
+  // Page asks resolve when the page's tweak ships (ADR 0341 D6). Re-registered
+  // on every router build (tests rebuild it), never stacked.
+  if (_askListenerOff) _askListenerOff();
+  _askListenerOff = api.on('task.shipped', (task) => resolveAsksOnShip(task));
+
   // -------------------------------------------------------------------------
   // GET /copy-desk/queue — the artist's working list.
   //
@@ -203,8 +266,11 @@ module.exports = function buildCopyDeskRouter() {
       // re-surfaces every already-dismissed duplicate as untouched work.
       // composeQueue owns that rule; this just feeds it both sets. When the
       // caller asked for everything the two are the same query, so it runs once.
-      const shown = await flags.listFlags({ status, surface });
-      const allFlags = status === 'all' ? shown : await flags.listFlags({ status: 'all', surface });
+      // Page asks (scope 'page', task 1004317) are the recommendation's signal,
+      // not rows in this string queue, so the queue reads the two flag scopes.
+      const scopes = flags.FLAG_SCOPES;
+      const shown = await flags.listFlags({ status, surface, scopes });
+      const allFlags = status === 'all' ? shown : await flags.listFlags({ status: 'all', surface, scopes });
 
       const queue = registry.composeQueue({
         registry: loaded.registry,
@@ -548,16 +614,9 @@ module.exports = function buildCopyDeskRouter() {
   // -------------------------------------------------------------------------
   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 found = pageOrFail(req, res);
+      if (!found) return;
+      const { page, pageId } = found;
       const lifecycle = pageReadsOrFail(res);
       if (!lifecycle) return;
       const readings = readingsState();
@@ -604,5 +663,185 @@ module.exports = function buildCopyDeskRouter() {
     }
   });
 
+  // -------------------------------------------------------------------------
+  // GET /copy-desk/next — the Tweak/CopyWrite Flow's recommendation (task
+  // 1004318 / BV2.TW07, ADR 0341 D8): the page the caller should tweak next
+  // and why ("2 people asked for it"), plus the next few for "pick another".
+  //
+  // Order: asked for (most distinct askers, then the oldest ask), then changed
+  // since the last tweak (most changed lines), then untweaked (landing,
+  // builders, status, then inventory order); tweaked pages with no drift last.
+  // A page another builder holds, or whose round is in flight, is never
+  // recommended (it is listed in `skipped`). The caller's own held page is
+  // `resume`, not a recommendation.
+  //
+  // "Take next" is POST /copy-desk/pages/:pageId/claim on `recommended.page_id`
+  // (each candidate carries its `take`), one call. The availability rule here
+  // is the claim's own, so that call is not refused for a reason this read knew.
+  //
+  // rank: any signed-in builder. The read is the caller's own and needs no
+  // craft; the claim it points at is where the artist gate lives.
+  // -------------------------------------------------------------------------
+  router.get('/copy-desk/next', 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, asks] = await Promise.all([
+        lifecycle.listPageTweakTasks(),
+        flags.pageAskSummary(),
+      ]);
+      const out = pageStatus.composeNext({ inventory: inv.data, readings: readings.data, tasks, asks, builderId: req.builder.id });
+      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/next failed');
+      if (!res.headersSent) res.fail('copy_next_failed', 500);
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // POST /copy-desk/pages/:pageId/claim — claim a page's tweak (task 1004317 /
+  // BV2.TW06, ADR 0341 D2 and D5). Also Resume and "Take next".
+  //
+  // Body: {} (nothing — who claims is the session, what is claimed is the path).
+  // rank: any signed-in builder; the gate is the CRAFT, read server-side
+  //       (builders.preferred_disciplines includes artist), never the request.
+  //
+  // One call finds the page's open round or creates it (source_ref
+  // page-tweak/<page_id>/r<n>, 30 credits, the building version's catch-all
+  // goal) and WEB-claims it: no worktree, no session. The lifecycle port runs it
+  // in one transaction under an advisory lock on the page, so two artists cannot
+  // both open a round.
+  //
+  //   201 created   a new round, held by the caller
+  //   200 claimed   an unheld round still being written (a draft released
+  //                 without submitting) taken over; the draft stays
+  //   200 resumed   the caller already holds it
+  //   409 page_held       another builder holds it; the holder is named
+  //   409 page_in_flight  the round is past writing (submitted, applying,
+  //                       waiting for the artist, landing)
+  //   403 not_an_artist   the caller's crafts do not include artist; they are
+  //                       offered the ask
+  // -------------------------------------------------------------------------
+  router.post('/copy-desk/pages/:pageId/claim', api.requireBuilder, async (req, res) => {
+    try {
+      if (validateOrRespond(req, res, CLAIM_BODY_SCHEMA)) return;
+      const found = pageOrFail(req, res);
+      if (!found) return;
+      const { page, pageId } = found;
+      const lifecycle = api.resolveOptional && api.resolveOptional('lifecycle');
+      if (!lifecycle || typeof lifecycle.webClaimPageTweak !== 'function') {
+        return res.fail('lifecycle_unavailable', 503, {
+          what_this_means: 'A page claim opens a task in the ledger, and this instance cannot. Nothing was recorded.',
+        });
+      }
+      // Where a NEW round lands: the version being built, as a copy proposal
+      // lands (no fallback to another version; see resolveTargetVersion).
+      const building = proposals.resolveTargetVersion(await lifecycle.listVersions());
+      const r = await lifecycle.webClaimPageTweak({
+        pageId,
+        builderId: req.builder.id,
+        versionId: building ? building.id : null,
+        round: {
+          title: () => pages.roundTaskTitle(page),
+          description: (n) => pages.roundTaskBody(page, n),
+          sourceRef: (n) => pages.roundSourceRef(pageId, n),
+          touches: Array.isArray(page.files) ? page.files : [],
+          creditsReward: pages.ROUND_CREDITS,
+          canTakeOver: pages.roundOpenForWriting,
+        },
+      });
+      const round = r.task ? { task_id: String(r.task.id), round: r.round, source_ref: r.task.source_ref, status: r.task.status } : null;
+      switch (r.outcome) {
+        case 'created':
+        case 'claimed':
+        case 'resumed':
+          return res.status(r.outcome === 'created' ? 201 : 200).json({
+            ok: true, outcome: r.outcome, page_id: pageId, round: { ...round, state: 'writing' },
+            claim: r.claim ? { id: String(r.claim.id), claimed_at: r.claim.claimed_at } : null,
+          });
+        case 'held':
+          return res.fail('page_held', 409, {
+            page_id: pageId, round, holder: r.holder,
+            what_this_means: r.holder_is_writing
+              ? `${r.holder.name || r.holder.login || 'Another artist'} is writing this page now. Ask for it instead, or take another.`
+              : `${r.holder.name || r.holder.login || 'Another builder'} is applying this page's submitted words. It comes back when it ships or is sent back.`,
+          });
+        case 'in_flight':
+          return res.fail('page_in_flight', 409, {
+            page_id: pageId, round,
+            what_this_means: 'This page\'s round has been submitted and is on its way to the site. It can be claimed again once it ships or is sent back.',
+          });
+        case 'not_an_artist':
+          return res.fail('not_an_artist', 403, {
+            page_id: pageId,
+            what_this_means: 'Only a builder whose crafts include artist can claim a page. Anyone can ask for one.',
+            your_options: [`POST /copy-desk/pages/${pageId}/asks with a one-line reason`, 'Add artist to your crafts in Settings'],
+          });
+        case 'builder_inactive':
+          return res.fail('builder_inactive', 403);
+        case 'no_open_version':
+          return res.fail('no_open_version', 503, {
+            what_this_means: 'No version is currently being built, so there is nowhere for a new page round to land. Nothing was recorded.',
+          });
+        default:
+          throw new Error(`webClaimPageTweak: unknown outcome ${r.outcome}`);
+      }
+    } catch (err) {
+      log.error({ err }, 'POST /copy-desk/pages/:pageId/claim failed');
+      if (!res.headersSent) res.fail('copy_page_claim_failed', 500);
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // POST /copy-desk/pages/:pageId/asks — ask for a page (task 1004317 / TW06,
+  // ADR 0341 D6).
+  //
+  // Body: { reason } — one line, the flag's own floor (10 characters).
+  // rank: any signed-in builder, any craft. A page ask is a copy_desk_flags row
+  //       with scope 'page'; it carries a judgement and a page id, never text.
+  //
+  //   201 a new ask · 200 the caller's open ask on this page already (the first
+  //   one comes back; a double ask is not a second signal)
+  // Both carry `askers`: distinct builders with an open ask on the page.
+  // -------------------------------------------------------------------------
+  router.post('/copy-desk/pages/:pageId/asks', api.requireBuilder, async (req, res) => {
+    try {
+      if (validateOrRespond(req, res, ASK_BODY_SCHEMA)) return;
+      const found = pageOrFail(req, res);
+      if (!found) return;
+      const { pageId } = found;
+      const norm = flags.normalizePageAsk(req.body, pageId);
+      if (!norm.ok) return res.fail(norm.code, 400, norm.detail);
+
+      let ask = await flags.findOpenPageAsk(pageId, req.builder.id);
+      let created = false;
+      if (!ask) {
+        try {
+          ask = await flags.insertFlag(norm.value, req.builder.id);
+          created = true;
+        } catch (err) {
+          // 23505: a concurrent ask by the same builder won the one-open-per-
+          // (builder, page) index. Same answer as the read above.
+          if (!(err && err.code === '23505')) throw err;
+          ask = await flags.findOpenPageAsk(pageId, req.builder.id);
+          if (!ask) throw err;
+        }
+      }
+      const askers = await flags.countPageAskers(pageId);
+      res.status(created ? 201 : 200).json({ ok: true, created, ask, page_id: pageId, askers });
+    } catch (err) {
+      log.error({ err }, 'POST /copy-desk/pages/:pageId/asks failed');
+      if (!res.headersSent) res.fail('copy_page_ask_failed', 500);
+    }
+  });
+
   return router;
 };
+
+module.exports.resolveAsksOnShip = resolveAsksOnShip;

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

@@ -67,7 +67,7 @@ const MODULE_FILES = ['registry.js', 'flags.js', 'proposals.js', 'pages.js', 'pa
 
 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]}`)
@@ -75,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);
@@ -88,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.
@@ -140,7 +153,11 @@ await test('the proposal domain holds no path to a renderer — it composes text
 
 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
@@ -149,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');