@bongos/core 1.19.1060 → 1.19.1061

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

@@ -0,0 +1,202 @@
+// modules/copy-desk/tests/copy_page_draft.mjs — the page draft and the frozen
+// batch, pure (task 1004319 / BV2.TW08, ADR 0341 D4).
+//
+// What the resolvers in pages.js must do before any route or transaction is
+// involved: a draft save resolves every target from the page reading and keeps
+// only changed lines; the same draft again is recognised as the same; the
+// submit re-resolves each line on the CURRENT reading, refuses by name the
+// lines it cannot place, and splits the unplaced rewrites out for an engineer.
+//
+// The whole path (routes, the lifecycle transaction, the engineer tasks, the
+// released claim) is tests/copy_desk_page_submit.mjs (root).
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const pages = require('../pages.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.stack || err.message}`); }
+}
+
+// A page reading in the shape page-reader.js writes: placed lines carry their
+// registry row, a shared line may or may not have one, an unplaced line none.
+const L = (key, section, text, placement, row) => ({ key, section, text, placement, ...(row || {}) });
+const READING = {
+  id: 'landing:index',
+  reading_hash: 'h-now',
+  lines: [
+    L('L0001', 'skip link', 'Skip to content', 'shared', { file: 'shell.js', line: 7, string_id: 'aaa111' }),
+    L('L0002', 'top bar', 'Ctrl K', 'shared'),
+    L('L0003', 'hero', 'Build here', 'placed', { file: 'index.html', line: 12, string_id: 'bbb222' }),
+    L('L0004', 'hero', '{…} of {…} shipped', 'placed', { file: 'index.js', line: 40, string_id: 'ccc333' }),
+    L('L0005', 'hero', 'Cloud Bongos: Building Digitally', 'unplaced'),
+    L('L0006', 'footer', 'Resume', 'placed', { file: 'index.html', line: 90, string_id: 'ddd444' }),
+  ],
+};
+const SAVED_AT = '2026-09-28T10:00:00.000Z';
+const body = (lines, hash = 'h-now') => ({ reading_hash: hash, lines });
+
+console.log('copy-desk: the page draft and the frozen batch');
+
+test('a draft resolves every target from the reading and keeps only changed lines, in page order', () => {
+  const r = pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([
+    { key: 'L0006', after: 'Pick up where you left off' },
+    { key: 'L0003', after: '  Build   it here ' },
+    { key: 'L0001', after: 'Skip to content' }, // unchanged: dropped
+  ]) });
+  assert.equal(r.ok, true, JSON.stringify(r));
+  assert.deepEqual(r.draft, {
+    page_id: 'landing:index', reading_hash: 'h-now', saved_at: SAVED_AT,
+    lines: [
+      { key: 'L0003', section: 'hero', before: 'Build here', after: 'Build it here', placement: 'placed' },
+      { key: 'L0006', section: 'footer', before: 'Resume', after: 'Pick up where you left off', placement: 'placed' },
+    ],
+  });
+});
+
+test('a draft body cannot describe its own target: before, section and placement are ignored', () => {
+  const r = pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([
+    { key: 'L0003', after: 'New words', before: 'A sentence the page does not show', section: 'x', placement: 'unplaced' },
+  ]) });
+  assert.equal(r.ok, true);
+  assert.deepEqual([r.draft.lines[0].before, r.draft.lines[0].section, r.draft.lines[0].placement], ['Build here', 'hero', 'placed']);
+});
+
+test('a draft built on another reading is refused whole, reading_moved, naming the current hash', () => {
+  const r = pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([{ key: 'L0003', after: 'x y' }], 'h-old') });
+  assert.equal(r.ok, false);
+  assert.equal(r.code, 'reading_moved');
+  assert.deepEqual(r.detail, { reading_hash: 'h-now', sent: 'h-old' });
+});
+
+test('the draft refusals are named: unknown line, empty line, too long, duplicate, malformed, no reading', () => {
+  const code = (lines) => pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body(lines) }).code;
+  assert.equal(code([{ key: 'L0099', after: 'x' }]), 'unknown_line');
+  assert.equal(code([{ key: 'L0003', after: '   ' }]), 'line_empty');
+  assert.equal(code([{ key: 'L0003', after: 'x'.repeat(pages.MAX_LINE_CHARS + 1) }]), 'line_too_long');
+  assert.equal(code([{ key: 'L0003', after: 'a' }, { key: 'L0003', after: 'b' }]), 'duplicate_line');
+  assert.equal(code([{ key: 'nope', after: 'a' }]), 'line_malformed');
+  assert.equal(code([{ key: 'L0003' }]), 'line_malformed');
+  assert.equal(pages.resolveDraft({ readingPage: null, body: body([]) }).code, 'reading_missing');
+});
+
+test('an autosave mid-sentence is accepted: the placeholder arithmetic waits for the submit', () => {
+  const r = pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([{ key: 'L0004', after: 'shipped so far' }]) });
+  assert.equal(r.ok, true);
+});
+
+test('sameDraft ignores saved_at, so an unchanged autosave is recognised', () => {
+  const a = pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([{ key: 'L0003', after: 'Build it here' }]) }).draft;
+  const b = pages.resolveDraft({ readingPage: READING, savedAt: '2026-09-28T11:00:00.000Z', body: body([{ key: 'L0003', after: 'Build it here' }]) }).draft;
+  const c = pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body([{ key: 'L0003', after: 'Build it there' }]) }).draft;
+  assert.equal(pages.sameDraft(a, b), true);
+  assert.equal(pages.sameDraft(a, c), false);
+  // Round-trips through the block: what is stored is what is compared.
+  const parsed = pages.parseDraftBlock(pages.composeDraftBlock(a));
+  assert.equal(parsed.ok, true);
+  assert.equal(pages.sameDraft(parsed.draft, b), true);
+});
+
+test('replaceBlock replaces the one draft in place, appends when there is none, refuses two', () => {
+  const intro = 'Page tweak round 1.';
+  const d1 = pages.composeDraftBlock({ page_id: 'landing:index', reading_hash: 'h', saved_at: 'a', lines: [] });
+  const d2 = pages.composeDraftBlock({ page_id: 'landing:index', reading_hash: 'h', saved_at: 'b', lines: [] });
+  const first = pages.replaceBlock(intro, pages.FENCES.draft, d1);
+  assert.equal(first.description, `${intro}\n\n${d1}`);
+  const second = pages.replaceBlock(first.description, pages.FENCES.draft, d2);
+  assert.equal(second.description, `${intro}\n\n${d2}`);
+  // The batch fence is a prefix of the draft fence: replacing the batch must
+  // not touch the draft.
+  const batch = pages.composeBatchBlock({ page_id: 'landing:index', reading_hash: 'h', submitted_at: 's', lines: [] });
+  const both = pages.replaceBlock(second.description, pages.FENCES.batch, batch).description;
+  assert.ok(both.includes(d2) && both.includes(batch));
+  assert.equal(pages.parseDraftBlock(both).ok, true);
+  assert.equal(pages.parseBatchBlock(both).ok, true);
+  assert.equal(pages.replaceBlock(`${d1}\n\n${d2}`, pages.FENCES.draft, d1).code, 'multiple_blocks');
+});
+
+const draftOf = (lines) => pages.resolveDraft({ readingPage: READING, savedAt: SAVED_AT, body: body(lines) }).draft;
+
+test('the submit freezes placed and shared lines with their registry rows, and splits the unplaced out', () => {
+  const draft = draftOf([
+    { key: 'L0001', after: 'Jump to the page' },
+    { key: 'L0002', after: 'Control K' },
+    { key: 'L0003', after: 'Build it here' },
+    { key: 'L0005', after: 'Cloud Bongos: build it with us' },
+  ]);
+  const f = pages.freezeBatch({ readingPage: READING, draft, submittedAt: 'S' });
+  assert.equal(f.ok, true, JSON.stringify(f));
+  assert.deepEqual(f.batch.lines.map((l) => [l.key, l.placement, l.file, l.line, l.string_id, l.after]), [
+    ['L0001', 'shared', 'shell.js', 7, 'aaa111', 'Jump to the page'],
+    ['L0003', 'placed', 'index.html', 12, 'bbb222', 'Build it here'],
+  ]);
+  // Unplaced text, and shared shell text the registry has no row for, go to an engineer.
+  assert.deepEqual(f.unplaced.map((l) => [l.key, l.placement, l.before, l.after]), [
+    ['L0002', 'shared', 'Ctrl K', 'Control K'],
+    ['L0005', 'unplaced', 'Cloud Bongos: Building Digitally', 'Cloud Bongos: build it with us'],
+  ]);
+  assert.equal(f.batch.reading_hash, 'h-now');
+  assert.equal(f.batch.submitted_at, 'S');
+});
+
+test('a line the page no longer shows is refused target_gone, by name, and nothing is frozen', () => {
+  const draft = draftOf([{ key: 'L0003', after: 'Build it here' }, { key: 'L0006', after: 'Carry on' }]);
+  const moved = { ...READING, reading_hash: 'h-next', lines: READING.lines.filter((l) => l.key !== 'L0003') };
+  const f = pages.freezeBatch({ readingPage: moved, draft, submittedAt: 'S' });
+  assert.equal(f.ok, false);
+  assert.equal(f.code, 'lines_refused');
+  assert.deepEqual(f.detail.refused, [{ key: 'L0003', section: 'hero', before: 'Build here', code: 'target_gone' }]);
+});
+
+test('a line that moved to another key is found by its words, and frozen under its new key', () => {
+  const draft = draftOf([{ key: 'L0006', after: 'Carry on' }]);
+  const shifted = { ...READING, reading_hash: 'h-next', lines: [
+    L('L0001', 'skip link', 'Skip to content', 'shared', { file: 'shell.js', line: 7, string_id: 'aaa111' }),
+    L('L0002', 'hero', 'A new line above', 'placed', { file: 'index.html', line: 5, string_id: 'eee555' }),
+    L('L0007', 'footer', 'Resume', 'placed', { file: 'index.html', line: 91, string_id: 'ddd444' }),
+  ] };
+  const f = pages.freezeBatch({ readingPage: shifted, draft, submittedAt: 'S' });
+  assert.equal(f.ok, true, JSON.stringify(f));
+  assert.deepEqual([f.batch.lines[0].key, f.batch.lines[0].line, f.batch.reading_hash], ['L0007', 91, 'h-next']);
+});
+
+test('the same words in two places on a moved page are ambiguous_target, never a guess', () => {
+  const draft = draftOf([{ key: 'L0006', after: 'Carry on' }]);
+  const twice = { ...READING, lines: [
+    L('L0001', 'a', 'Resume', 'placed', { file: 'x', line: 1, string_id: 's1' }),
+    L('L0002', 'b', 'Resume', 'placed', { file: 'x', line: 2, string_id: 's1' }),
+  ] };
+  const f = pages.freezeBatch({ readingPage: twice, draft, submittedAt: 'S' });
+  assert.deepEqual(f.detail.refused.map((x) => x.code), ['ambiguous_target']);
+});
+
+test('the placeholder arithmetic is checked per line at submit', () => {
+  const bad = pages.freezeBatch({ readingPage: READING, draft: draftOf([{ key: 'L0004', after: 'shipped so far' }]), submittedAt: 'S' });
+  assert.deepEqual(bad.detail.refused, [{ key: 'L0004', section: 'hero', before: '{…} of {…} shipped', code: 'placeholder_mismatch', expected: 2, got: 0 }]);
+  const moved = pages.freezeBatch({ readingPage: READING, draft: draftOf([{ key: 'L0004', after: '{…} shipped, of {…}' }]), submittedAt: 'S' });
+  assert.equal(moved.ok, true, 'a hole may MOVE within the sentence');
+});
+
+test('an empty draft is nothing_to_submit', () => {
+  assert.equal(pages.freezeBatch({ readingPage: READING, draft: draftOf([]), submittedAt: 'S' }).code, 'nothing_to_submit');
+  assert.equal(pages.freezeBatch({ readingPage: READING, draft: null, submittedAt: 'S' }).code, 'nothing_to_submit');
+});
+
+test('the engineer task carries the page, the line and the wording, keyed per round and line', () => {
+  const page = { id: 'landing:index', title: 'Home', path: '/' };
+  const line = { key: 'L0005', section: 'hero', before: 'Cloud Bongos: Building Digitally', after: 'Cloud Bongos: build it with us', placement: 'unplaced' };
+  assert.equal(pages.unplacedSourceRef('5001', 'L0005'), 'page-tweak-unplaced/5001/L0005');
+  assert.equal(pages.unplacedTaskTitle(page, line), 'Place and reword "Cloud Bongos: Building Digitally" (landing:index)');
+  const b = pages.unplacedTaskBody(page, line, '5001');
+  for (const want of ['landing:index', 'Home', 'L0005', 'hero', '"Cloud Bongos: Building Digitally"', '"Cloud Bongos: build it with us"', 'task 5001', 'does not wait']) {
+    assert.ok(b.includes(want), `the body names ${want}`);
+  }
+});
+
+console.log(`\ncopy_page_draft: ${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);

package/modules/lifecycle/lifecycle.js

@@ -26,6 +26,7 @@ const activity = require('./activity');
 const mingle = require('./mingle');
 const pageTweakReads = require('./page-tweak-reads');
 const pageTweakClaim = require('./page-tweak-claim');
+const pageTweakWrite = require('./page-tweak-write');
 
 module.exports = {
   // --- retired doorway leaks (ADR 0093 §3) ---------------------------------
@@ -118,6 +119,13 @@ module.exports = {
   // 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),
+  // The page draft's autosave and the submit (task 1004319 / BV2.TW08, ADR 0341
+  // D4, D11): a holder-guarded description write that skips an unchanged save,
+  // and the submit's one transaction (engineer tasks for unplaced lines, the
+  // frozen batch, the web claim released, the round back to ready). D11 names
+  // updateTaskDescription and releaseClaim; see modules/lifecycle/page-tweak-write.js.
+  updateHeldTaskDescription: (...a) => pageTweakWrite.updateHeldTaskDescription(...a),
+  submitPageTweak: (...a) => pageTweakWrite.submitPageTweak(...a),
   listVersions: (...a) => db.listVersions(...a),
   versionProgress: (...a) => db.versionProgress(...a),
   recentShippedTasks: (...a) => db.recentShippedTasks(...a),

package/modules/lifecycle/page-tweak-reads.js

@@ -37,10 +37,17 @@ const api = require('../../src/module-api');
 //     per task), joined once, rather than a correlated subquery per task:
 //     claims has no full index on task_id, so a per-row LATERAL would scan it
 //     once per round.
-async function listPageTweakTasks() {
+//
+// `pageId` narrows it to ONE page's rounds (task 1004319 / TW08): the draft
+// autosave runs this on every debounced save, and a page's rounds are a handful
+// while the instance's grow without bound. The prefix is matched with left(),
+// not LIKE, the page claim's own rule (an `_` in an id is never a wildcard).
+async function listPageTweakTasks({ pageId = null } = {}) {
+  const prefix = pageId ? `page-tweak/${pageId}/` : null;
   const { rows } = await api.pool.query(
     `WITH pt AS (
        SELECT t.id FROM tasks t WHERE t.source = 'page-tweak'
+          AND ($1::text IS NULL OR left(t.source_ref, length($1::text)) = $1::text)
      ), web AS (
        SELECT DISTINCT ON (c.task_id) c.task_id, c.builder_id
          FROM claims c JOIN pt ON pt.id = c.task_id
@@ -60,7 +67,9 @@ async function listPageTweakTasks() {
        LEFT JOIN web wc ON wc.task_id = t.id
        LEFT JOIN builders ab ON ab.id = wc.builder_id
       WHERE t.source = 'page-tweak'
-      ORDER BY t.id ASC`
+        AND ($1::text IS NULL OR left(t.source_ref, length($1::text)) = $1::text)
+      ORDER BY t.id ASC`,
+    [prefix]
   );
   return rows;
 }

package/modules/lifecycle/page-tweak-write.js

@@ -0,0 +1,192 @@
+// modules/lifecycle/page-tweak-write.js — the page draft save and the submit
+// (task 1004319 / BV2.TW08, ADR 0341 D4, D7, D11).
+//
+// On the `lifecycle` port because tasks and claims are this module's tables and
+// copy-desk may only cross the wall through a port (ADR 0083, ADR 0093 §2). What
+// the draft and the batch SAY (the fenced blocks, the resolution against the page
+// reading, the engineer task an unplaced line files) is copy-desk's and is handed
+// in as a function; the transaction and the holder check are lifecycle's.
+//
+// BOTH ARE HOLDER-ONLY. The caller must hold the task's open WEB claim
+// (worktree_name NULL and creator_session_id NULL, the claim the page claim
+// takes). The check runs inside the transaction, after the task row is locked
+// FOR UPDATE, the same lock claimTask and the page claim take, so a save cannot
+// interleave with a claim or a release of the same round.
+//
+// AN AUTOSAVE THAT CHANGES NOTHING WRITES NOTHING. The editor autosaves often
+// (it debounces; the server accepts a whole-draft replace). When the composed
+// description equals the stored one, the transaction ends without an UPDATE, so
+// `updated_at` and every reader that sorts by it stay where they were.
+//
+// ADR 0341 D11 names the port entries updateTaskDescription, webClaimTask and
+// releaseClaim. They landed page-shaped, as TW06's webClaimPageTweak did: the
+// description update is holder-guarded (updateHeldTaskDescription, so no caller
+// can rewrite a task it does not hold through the port), and the release runs
+// INSIDE the submit's transaction (submitPageTweak), because the batch, the
+// engineer tasks and the release must commit together or not at all.
+//
+// Outcomes are returned, not thrown, so the route maps each to a named answer:
+//   saved | unchanged | submitted
+//   not_found      no such task
+//   wrong_source   the task is not of the source the caller named
+//   not_held       the caller does not hold its open web claim (holder named)
+//   refused        copy-desk's function refused (its refusal is passed back)
+
+'use strict';
+
+const api = require('../../src/module-api');
+const db = require('./db');
+
+function activePoolFor(deps) {
+  return (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : api.pool;
+}
+
+// Lock the task, then read its open claim. Returns { task, claim } or an outcome.
+async function lockHeld(client, { taskId, builderId, source }) {
+  const { rows } = await client.query(
+    `SELECT id, status, title, description, source, source_ref, version_id, goal_id, touches
+       FROM tasks WHERE id = $1 FOR UPDATE`,
+    [taskId]
+  );
+  const task = rows[0];
+  if (!task) return { outcome: 'not_found' };
+  if (source && task.source !== source) return { outcome: 'wrong_source', task };
+  const { rows: held } = await client.query(
+    `SELECT c.id, c.builder_id, c.worktree_name, c.creator_session_id, b.github_login, b.display_name
+       FROM claims c JOIN builders b ON b.id = c.builder_id
+      WHERE c.task_id = $1 AND c.released_at IS NULL
+      LIMIT 1`,
+    [taskId]
+  );
+  const claim = held[0] || null;
+  const web = !!claim && claim.worktree_name == null && claim.creator_session_id == null;
+  if (!claim || !web || String(claim.builder_id) !== String(builderId)) {
+    return {
+      outcome: 'not_held',
+      task,
+      holder: claim ? { id: String(claim.builder_id), login: claim.github_login || null, name: claim.display_name || null, writing: web } : null,
+    };
+  }
+  return { task, claim };
+}
+
+// updateHeldTaskDescription({ taskId, builderId, source, compose }, deps)
+//
+//   compose(task) -> { ok: true, description } | { ok: false, code, detail }
+//
+// The page draft's autosave (PUT /copy-desk/pages/:pageId/draft). Writes the
+// composed description when it differs from the stored one.
+async function updateHeldTaskDescription({ taskId, builderId, source = null, compose }, deps = {}) {
+  const client = await activePoolFor(deps).connect();
+  try {
+    await client.query('BEGIN');
+    const held = await lockHeld(client, { taskId, builderId, source });
+    if (held.outcome) { await client.query('ROLLBACK'); return held; }
+    const r = compose(held.task);
+    if (!r || !r.ok) { await client.query('ROLLBACK'); return { outcome: 'refused', refusal: r, task: held.task }; }
+    if (r.description === held.task.description) {
+      await client.query('ROLLBACK');
+      return { outcome: 'unchanged', task: held.task };
+    }
+    const { rows } = await client.query(
+      `UPDATE tasks SET description = $2, updated_at = now() WHERE id = $1
+       RETURNING id, status, description, source_ref, updated_at`,
+      [taskId, r.description]
+    );
+    await client.query('COMMIT');
+    return { outcome: 'saved', task: rows[0] };
+  } catch (err) {
+    await client.query('ROLLBACK').catch(() => {});
+    throw err;
+  } finally {
+    client.release();
+  }
+}
+
+// submitPageTweak({ taskId, builderId, versionId, freeze }, deps)
+//
+//   freeze(task) -> { ok: true, unplaced: [{ sourceRef, title, description, touches }],
+//                     description(unplacedTaskIds) -> string }
+//                 | { ok: false, code, detail }
+//
+// The submit (POST /copy-desk/pages/:pageId/submit), one transaction:
+//   1. each unplaced rewrite files its engineer task (source page-tweak-unplaced,
+//      backlog, engineer), or finds the one its source ref already filed;
+//   2. the description gains the frozen `page-tweak` block naming those tasks;
+//   3. the artist's web claim is RELEASED (outcome 'partial': their part is done
+//      and the task goes on) and the task returns to `ready`, so the round reads
+//      `submitted` and sits in the /tweak queue (ADR 0341 D7).
+// The released claim is the one the payee rule reads (ADR 0341 D10).
+async function submitPageTweak({ taskId, builderId, versionId = null, freeze }, deps = {}) {
+  const createTask = deps.createTask || db.createTask;
+  const client = await activePoolFor(deps).connect();
+  try {
+    await client.query('BEGIN');
+    const held = await lockHeld(client, { taskId, builderId, source: 'page-tweak' });
+    if (held.outcome) { await client.query('ROLLBACK'); return held; }
+    const plan = freeze(held.task);
+    if (!plan || !plan.ok) { await client.query('ROLLBACK'); return { outcome: 'refused', refusal: plan, task: held.task }; }
+
+    // The engineer tasks an earlier submit of this round already filed, in ONE
+    // read (a resubmit after a send-back finds them). Only the missing ones go
+    // through createTask, the single create chokepoint, one at a time.
+    const wanted = plan.unplaced || [];
+    const existing = new Map();
+    if (wanted.length) {
+      const { rows: found } = await client.query(
+        'SELECT id, source_ref FROM tasks WHERE source = $1 AND source_ref = ANY($2::text[])',
+        [wanted[0].source, wanted.map((u) => u.sourceRef)]
+      );
+      for (const f of found) if (!existing.has(f.source_ref)) existing.set(f.source_ref, String(f.id));
+    }
+    const filed = [];
+    for (const u of wanted) {
+      if (existing.has(u.sourceRef)) { filed.push({ id: existing.get(u.sourceRef), key: u.key, created: false }); continue; }
+      const t = await createTask({
+        versionId: versionId != null ? versionId : held.task.version_id,
+        // The building version's catch-all goal, declared out loud (BV1.R11),
+        // exactly as the round itself and a copy proposal land.
+        allowCatchAll: true,
+        title: u.title,
+        description: u.description,
+        // BACKLOG (ADR 0341 D4): an engineer's triage decides when, and the
+        // page does not wait for it.
+        status: 'backlog',
+        kind: 'feature',
+        discipline: 'engineer',
+        priority: 4,
+        touches: u.touches || [],
+        source: u.source,
+        sourceRef: u.sourceRef,
+        createdBy: builderId,
+      }, { client });
+      filed.push({ id: String(t.id), key: u.key, created: true });
+    }
+
+    const description = plan.description(filed.map((f) => f.id));
+    const { rows } = await client.query(
+      `UPDATE tasks SET description = $2, status = 'ready', updated_at = now() WHERE id = $1
+       RETURNING id, status, description, source_ref, updated_at`,
+      [taskId, description]
+    );
+    await releaseClaim(client, held.claim.id);
+    await client.query('COMMIT');
+    return { outcome: 'submitted', task: rows[0], unplaced_tasks: filed, released_claim_id: String(held.claim.id) };
+  } catch (err) {
+    await client.query('ROLLBACK').catch(() => {});
+    throw err;
+  } finally {
+    client.release();
+  }
+}
+
+// Release one claim inside the caller's transaction. The task's status is the
+// caller's to set (the submit sets `ready` with the same UPDATE as the batch).
+async function releaseClaim(client, claimId, outcome = 'partial') {
+  await client.query(
+    'UPDATE claims SET released_at = now(), outcome = $2 WHERE id = $1 AND released_at IS NULL',
+    [claimId, outcome]
+  );
+}
+
+module.exports = { updateHeldTaskDescription, submitPageTweak };

package/package-lock.json

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

package/package.json

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

package/release-notes.json

@@ -7661,5 +7661,11 @@
       "id": "1004318",
       "text": "An artist can now ask \"what should I tweak next?\" and get one page back, with the reason in plain words, such as \"2 people asked for it\". Pages people asked for come first, then pages whose words changed since their last tweak"
     }
+  ],
+  "1.19.1061": [
+    {
+      "id": "1004319",
+      "text": "An artist's page rewrite is now saved as they type and can be submitted. The draft rests on the page's own tweak task, and saving the same words again changes nothing. Submitting freezes the rewrite for a /tweak session to app"
+    }
   ]
 }

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.1060'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.1061'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');