@bongos/core 1.23.20 → 1.23.22

package/src/platform-server.js

@@ -142,6 +142,24 @@ function stampAssets(html) {
     assetStamp(url) ? `${attr}="${url}?v=${assetStamp(url)}"` : m);
 }
 
+// The cache lifetime a landing asset is served with (task 1004925). A URL whose
+// ?v= is the file's CURRENT stamp can never name different bytes — a new file
+// means a new stamp, so a new URL — so the browser may keep it for a year instead
+// of re-fetching it after Cloudflare's four-hour default runs out. Only an exact
+// match earns that, the hall's rule (serve-internal.js, task 1004855): a stale or
+// made-up ?v=, or a bare URL, keeps whatever lifetime it had. Images and fonts
+// that no page stamps (a css url(), a script-built src) get one day, up from four
+// hours; everything else is left to the default. Returns null for "no header".
+const MEDIA_ASSET = /\.(?:png|jpe?g|webp|avif|gif|svg|ico|woff2?|ttf|otf)$/i;
+function landingAssetCache(urlPath, v) {
+  if (typeof urlPath !== 'string') return null;
+  if (typeof v === 'string' && /^[0-9a-f]{8}$/.test(v) && assetStamp(urlPath) === v) {
+    return 'public, max-age=31536000, immutable';
+  }
+  if (MEDIA_ASSET.test(urlPath)) return 'public, max-age=86400';
+  return null;
+}
+
 const _landingPages = new Map(); // memoized per file; '' if absent (instance ships no landing)
 function landingPage(file) {
   if (!_landingPages.has(file)) {
@@ -364,7 +382,15 @@ function buildPlatformApp() {
   });
   // Assets fall through to the 404 tail when no module claims the apex root — the
   // handler is not mounted at all rather than pointed at a missing directory.
-  const landingAssets = landingDir() && express.static(landingDir(), { index: false, fallthrough: true });
+  const landingAssets = landingDir() && express.static(landingDir(), {
+    index: false,
+    fallthrough: true,
+    setHeaders: (res) => {
+      const req = res.req || {};
+      const cache = landingAssetCache(req.path, req.query && req.query.v);
+      if (cache) res.setHeader('Cache-Control', cache);
+    },
+  });
   if (landingAssets) {
     app.use((req, res, next) => {
       if (!isApexHost(req)) return next();

package/tests/batched_writes_parity.mjs

@@ -0,0 +1,340 @@
+// tests/batched_writes_parity.mjs — the batched goal archive, version close and
+// weekly karma tally give the SAME results as the one-query-per-row loops they
+// replaced (task 1004929).
+//
+// Each case runs the old loop (tests/fixtures/per-row-loops-legacy.cjs, a
+// verbatim copy) and the new code over the SAME seeded fake database, then
+// compares what each returned or threw AND what each left in the tables. The
+// fake is a small interpreter for exactly the statements both versions send —
+// old per-row reads and new batched reads answer from one store — and it hands
+// bigint ids back as STRINGS, as node-pg does, so a plan that carries numbers is
+// matched back to rows the way production matches them. BEGIN snapshots the
+// store and ROLLBACK restores it, so a thrown run is compared on what survived.
+//
+// The rank-set apply parity lives in tests/government_routes.mjs, where the real
+// router is already standing.
+//
+// Run:  node --test tests/batched_writes_parity.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const { archiveGoalWithDispositions, closeVersion } = require('../modules/lifecycle/db.js');
+const { tallyPeerVotes } = require('../modules/lifecycle/db-analytics.js');
+const { idKey } = require('../modules/lifecycle/db-shared.js');
+const pgPool = require('../src/bongos/pool').pool;
+const legacy = require('./fixtures/per-row-loops-legacy.cjs');
+
+const TERMINAL = new Set(['shipped', 'abandoned']);
+const same = (a, b) => String(a) === String(b);
+const inIds = (arr, v) => arr.some((x) => same(idKey(x), idKey(v)));
+const clone = (v) => JSON.parse(JSON.stringify(v));
+
+// ---- the fake database -------------------------------------------------------
+
+function fakeDb(seed) {
+  let st = clone(seed);
+  let snap = null;
+  const queries = [];
+  const task = (id) => st.tasks.find((t) => same(t.id, idKey(id)));
+  const goal = (id) => st.goals.find((g) => same(g.id, idKey(id)));
+  const out = (row) => (row ? { ...row, id: String(row.id) } : row);
+  const openWork = (t) => !TERMINAL.has(t.status) && !t.title.startsWith('__smoke__');
+
+  async function query(sql, p = []) {
+    const s = String(sql).replace(/\s+/g, ' ').trim();
+    queries.push(s);
+    if (s === 'BEGIN') { snap = clone(st); return { rows: [] }; }
+    if (s === 'COMMIT') { snap = null; return { rows: [] }; }
+    if (s === 'ROLLBACK') { if (snap) st = snap; snap = null; return { rows: [] }; }
+
+    // ---- goal archive -------------------------------------------------------
+    if (/^SELECT .* FROM goals WHERE id = \$1 FOR UPDATE$/.test(s)) return { rows: [goal(p[0])].filter(Boolean).map(out) };
+    if (/FROM tasks WHERE id = \$1 AND goal_id = \$2 FOR UPDATE$/.test(s)) {
+      const t = task(p[0]);
+      return { rows: t && same(t.goal_id, p[1]) ? [out(t)] : [] };
+    }
+    if (/FROM tasks WHERE id = ANY\(\$1::bigint\[\]\) AND goal_id = \$2 ORDER BY id FOR UPDATE$/.test(s)) {
+      return { rows: st.tasks.filter((t) => inIds(p[0], t.id) && same(t.goal_id, p[1])).sort((a, b) => a.id - b.id).map(out) };
+    }
+    if (/^SELECT id FROM claims WHERE task_id = \$1 AND released_at IS NULL LIMIT 1$/.test(s)) {
+      return { rows: st.claims.filter((c) => same(c.task_id, idKey(p[0])) && !c.released_at).slice(0, 1).map((c) => ({ id: String(c.id) })) };
+    }
+    if (/^SELECT DISTINCT task_id FROM claims WHERE task_id = ANY\(\$1::bigint\[\]\) AND released_at IS NULL$/.test(s)) {
+      const ids = [...new Set(st.claims.filter((c) => inIds(p[0], c.task_id) && !c.released_at).map((c) => String(c.task_id)))];
+      return { rows: ids.map((task_id) => ({ task_id })) };
+    }
+    if (/^UPDATE tasks SET status = 'abandoned', .* WHERE id = \$1$/.test(s)) {
+      const t = task(p[0]); t.status = 'abandoned'; if (p[1]) t.value_summary = p[1];
+      return { rows: [], rowCount: 1 };
+    }
+    if (/^SELECT id, status FROM goals WHERE id = \$1 FOR SHARE$/.test(s)) return { rows: [goal(p[0])].filter(Boolean).map((g) => ({ id: String(g.id), status: g.status })) };
+    if (/^UPDATE tasks SET goal_id = \$2, updated_at = now\(\) WHERE id = \$1$/.test(s)) {
+      task(p[0]).goal_id = Number(p[1]);
+      return { rows: [], rowCount: 1 };
+    }
+    if (/count\(\*\)::int AS n FROM (tasks|goals)/.test(s)) return { rows: [{ n: 0 }] }; // the re-counts are not under test
+    if (/^UPDATE goal_membership_requests/.test(s)) return { rows: [], rowCount: 0 };
+
+    // ---- version close ------------------------------------------------------
+    if (/FROM versions WHERE id = \$1 FOR UPDATE$/.test(s)) return { rows: [{ id: p[0], status: 'building' }] };
+    if (/FROM goals WHERE id = \$1 AND version_id = \$2 FOR UPDATE$/.test(s)) {
+      const g = goal(p[0]);
+      return { rows: g && same(g.version_id, p[1]) ? [out(g)] : [] };
+    }
+    if (/FROM goals WHERE id = ANY\(\$1::bigint\[\]\) AND version_id = \$2 ORDER BY id FOR UPDATE$/.test(s)) {
+      return { rows: st.goals.filter((g) => inIds(p[0], g.id) && same(g.version_id, p[1])).sort((a, b) => a.id - b.id).map(out) };
+    }
+    if (/^UPDATE tasks SET status = 'abandoned', .* WHERE goal_id = \$1 AND .* RETURNING id$/.test(s)) {
+      const hit = st.tasks.filter((t) => same(t.goal_id, idKey(p[0])) && openWork(t));
+      for (const t of hit) { t.status = 'abandoned'; t.value_summary = p[1]; }
+      return { rows: hit.map((t) => ({ id: String(t.id) })) };
+    }
+    if (/^UPDATE goals SET status = 'archived', updated_at = now\(\) WHERE id = \$1/.test(s)) {
+      const g = goal(p[0]); g.status = 'archived';
+      return { rows: [out(g)], rowCount: 1 };
+    }
+    if (/^WITH next_order AS .* INSERT INTO goals/.test(s)) {
+      const src = goal(p[0]);
+      const id = st.nextGoalId++;
+      st.goals.push({ id, version_id: p[1], title: src.title, status: 'open', succeeded_by_goal_id: null });
+      return { rows: [{ id: String(id) }] };
+    }
+    if (/^INSERT INTO goal_members/.test(s)) return { rows: [], rowCount: 0 };
+    if (/^UPDATE tasks SET goal_id = \$2, version_id = \$3, .* RETURNING id$/.test(s)) {
+      const hit = st.tasks.filter((t) => same(t.goal_id, idKey(p[0])) && openWork(t));
+      for (const t of hit) { t.goal_id = Number(p[1]); t.version_id = p[2]; }
+      return { rows: hit.map((t) => ({ id: String(t.id) })) };
+    }
+    if (/^UPDATE goals SET succeeded_by_goal_id = \$2/.test(s)) { goal(p[0]).succeeded_by_goal_id = Number(p[1]); return { rows: [] }; }
+    if (/FROM tasks t LEFT JOIN goals g/.test(s)) return { rows: [] };
+    if (/^UPDATE versions SET status = 'shipped'/.test(s)) return { rows: [{ id: p[0], status: 'shipped' }] };
+
+    // ---- weekly karma tally -------------------------------------------------
+    if (/FROM peer_votes pv JOIN tasks t/.test(s)) {
+      return { rows: st.peerVotes.filter((v) => !v.tallied).map((v) => ({ id: String(v.id), builder_id: String(v.builder_id), vote: v.vote })) };
+    }
+    if (/to_regclass\('ideas_votes'\)/.test(s)) return { rows: [{ has: st.ideaVotes !== null }] };
+    if (/FROM ideas_votes iv JOIN idea_inbox i/.test(s)) {
+      return { rows: st.ideaVotes.filter((v) => !v.tallied).map((v) => ({ id: String(v.id), builder_id: String(v.builder_id), vote: v.vote })) };
+    }
+    if (/^INSERT INTO karma_log .* VALUES \(\$1, \$2, 'peer_vote_weekly', NULL\)$/.test(s)) {
+      st.karma.push({ builder_id: String(p[0]), delta: Number(p[1]), reason: 'peer_vote_weekly', granted_by: null });
+      return { rows: [], rowCount: 1 };
+    }
+    if (/^INSERT INTO karma_log .* FROM unnest\(\$1::bigint\[\], \$2::int\[\]\) WITH ORDINALITY .* ORDER BY k\.ord$/.test(s)) {
+      p[0].forEach((b, i) => st.karma.push({ builder_id: String(b), delta: Number(p[1][i]), reason: 'peer_vote_weekly', granted_by: null }));
+      return { rows: [], rowCount: p[0].length };
+    }
+    if (/^UPDATE (peer_votes|ideas_votes) SET tallied_at = now\(\) WHERE id = ANY/.test(s)) {
+      const list = s.startsWith('UPDATE peer_votes') ? st.peerVotes : st.ideaVotes;
+      for (const v of list) if (inIds(p[0], v.id)) v.tallied = true;
+      return { rows: [], rowCount: p[0].length };
+    }
+
+    throw new Error(`fake db: unhandled statement: ${s.slice(0, 120)}`);
+  }
+  const client = { query, release() {} };
+  return {
+    pool: { connect: async () => client, query },
+    client,
+    queries,
+    get state() { return clone(st); },
+  };
+}
+
+// Run a legacy loop the way its function ran it: inside one transaction, rolled
+// back on a throw. Returns { result } or { error }.
+async function runLegacyTx(db, fn) {
+  await db.client.query('BEGIN');
+  try {
+    const result = await fn(db.client);
+    await db.client.query('COMMIT');
+    return { result };
+  } catch (error) {
+    await db.client.query('ROLLBACK');
+    return { error };
+  }
+}
+async function runNew(fn) {
+  try { return { result: await fn() }; } catch (error) { return { error }; }
+}
+const errShape = (e) => (e ? { code: e.code, taskId: e.taskId, taskTitle: e.taskTitle, goalId: e.goalId, toGoalId: e.toGoalId, targetStatus: e.targetStatus } : null);
+
+// ---- goal archive ------------------------------------------------------------
+
+const ARCHIVE_SEED = {
+  goals: [
+    { id: 7, version_id: 'V1', title: 'the goal being archived', status: 'open' },
+    { id: 8, version_id: 'V1', title: 'a neighbour', status: 'open' },
+    { id: 9, version_id: 'V1', title: 'an open move target', status: 'open' },
+    { id: 10, version_id: 'V1', title: 'a closed move target', status: 'archived' },
+  ],
+  tasks: [
+    { id: 1, goal_id: 7, version_id: 'V1', status: 'ready', title: 'one', value_summary: null },
+    { id: 2, goal_id: 7, version_id: 'V1', status: 'shipped', title: 'two', value_summary: null },
+    { id: 3, goal_id: 8, version_id: 'V1', status: 'ready', title: 'three (elsewhere)', value_summary: null },
+    { id: 4, goal_id: 7, version_id: 'V1', status: 'active', title: 'four (claimed)', value_summary: null },
+    { id: 5, goal_id: 7, version_id: 'V1', status: 'backlog', title: 'five', value_summary: null },
+    { id: 6, goal_id: 7, version_id: 'V1', status: 'ready', title: 'six', value_summary: null },
+  ],
+  claims: [{ id: 99, task_id: 4, released_at: null }, { id: 98, task_id: 6, released_at: '2026-01-01' }],
+  nextGoalId: 100,
+};
+
+const ARCHIVE_PLANS = {
+  'mixed verbs, skips and a move': [
+    { taskId: 1, verb: 'abandon' }, { taskId: 2, verb: 'abandon' }, { taskId: 3, verb: 'abandon' },
+    { taskId: 5, verb: 'move', toGoalId: 9 }, { taskId: 6, verb: 'abandon' },
+  ],
+  'plan order is not id order': [{ taskId: 6, verb: 'abandon' }, { taskId: 1, verb: 'move', toGoalId: 9 }, { taskId: 5, verb: 'abandon' }],
+  'a task named twice reads what the first step left': [
+    { taskId: 1, verb: 'abandon' }, { taskId: 1, verb: 'abandon' },
+    { taskId: 5, verb: 'move', toGoalId: 9 }, { taskId: 5, verb: 'abandon' },
+  ],
+  'ids as strings, as a JSON body carries them': [{ taskId: '1', verb: 'abandon' }, { taskId: '5', verb: 'move', toGoalId: '9' }],
+  'an actively claimed task stops it, after earlier steps': [{ taskId: 1, verb: 'abandon' }, { taskId: 4, verb: 'abandon' }, { taskId: 6, verb: 'abandon' }],
+  'a closed move target stops it': [{ taskId: 1, verb: 'abandon' }, { taskId: 5, verb: 'move', toGoalId: 10 }],
+  'a missing move target stops it': [{ taskId: 5, verb: 'move', toGoalId: 404 }],
+  'a task that does not exist is skipped': [{ taskId: 777, verb: 'abandon' }, { taskId: 6, verb: 'abandon' }],
+  'an empty plan': [],
+};
+
+for (const [name, plan] of Object.entries(ARCHIVE_PLANS)) {
+  test(`goal archive, old loop vs batched: ${name}`, async () => {
+    const args = { goalId: 7, plan, reason: 'cut in review' };
+    const oldDb = fakeDb(ARCHIVE_SEED);
+    const old = await runLegacyTx(oldDb, (c) => legacy.legacyArchiveLoop(c, args));
+    const neuDb = fakeDb(ARCHIVE_SEED);
+    const neu = await runNew(() => archiveGoalWithDispositions(args, { pool: neuDb.pool }));
+
+    assert.deepEqual(errShape(neu.error), errShape(old.error), 'the same refusal, naming the same task');
+    if (!old.error) assert.deepEqual(neu.result.applied, old.result, 'the same applied list, in plan order');
+    assert.deepEqual(neuDb.state.tasks, oldDb.state.tasks, 'the same tasks left behind');
+  });
+}
+
+test('goal archive reads every plan task in ONE locked statement and the claims in one more', async () => {
+  const db = fakeDb(ARCHIVE_SEED);
+  await archiveGoalWithDispositions({ goalId: 7, plan: ARCHIVE_PLANS['mixed verbs, skips and a move'], reason: 'r' }, { pool: db.pool });
+  assert.equal(db.queries.filter((q) => /FROM tasks WHERE id = ANY/.test(q)).length, 1);
+  assert.equal(db.queries.filter((q) => /FROM claims WHERE task_id/.test(q)).length, 1);
+  assert.equal(db.queries.filter((q) => /FROM tasks WHERE id = \$1/.test(q)).length, 0, 'no per-step read is left');
+});
+
+// ---- version close -----------------------------------------------------------
+
+const CLOSE_SEED = {
+  goals: [
+    { id: 1, version_id: 'V1', title: 'g1', status: 'open', succeeded_by_goal_id: null },
+    { id: 2, version_id: 'V1', title: 'g2', status: 'open', succeeded_by_goal_id: null },
+    { id: 3, version_id: 'V1', title: 'g3 (already closed)', status: 'archived', succeeded_by_goal_id: null },
+    { id: 4, version_id: 'V9', title: 'g4 (another version)', status: 'open', succeeded_by_goal_id: null },
+    { id: 5, version_id: 'V1', title: 'g5', status: 'open', succeeded_by_goal_id: null },
+  ],
+  tasks: [
+    { id: 11, goal_id: 1, version_id: 'V1', status: 'ready', title: 'a', value_summary: null },
+    { id: 12, goal_id: 1, version_id: 'V1', status: 'shipped', title: 'b', value_summary: 'done' },
+    { id: 13, goal_id: 1, version_id: 'V1', status: 'ready', title: '__smoke__ fixture', value_summary: null },
+    { id: 21, goal_id: 2, version_id: 'V1', status: 'backlog', title: 'c', value_summary: null },
+    { id: 22, goal_id: 2, version_id: 'V1', status: 'active', title: 'd', value_summary: null },
+    { id: 51, goal_id: 5, version_id: 'V1', status: 'ready', title: 'e', value_summary: null },
+  ],
+  claims: [],
+  nextGoalId: 100,
+};
+
+const CLOSE_CASES = {
+  'abandon and roll forward, with skips': {
+    plan: [{ goalId: 1, verb: 'abandon' }, { goalId: 3, verb: 'abandon' }, { goalId: 4, verb: 'roll_forward' }, { goalId: 2, verb: 'roll_forward' }],
+    planningVersionId: 'V2',
+  },
+  'plan order is not id order': {
+    plan: [{ goalId: 5, verb: 'roll_forward' }, { goalId: 2, verb: 'abandon' }, { goalId: 1, verb: 'roll_forward' }],
+    planningVersionId: 'V2',
+  },
+  'a goal named twice reads archived the second time': {
+    plan: [{ goalId: 1, verb: 'abandon' }, { goalId: 1, verb: 'roll_forward' }, { goalId: 2, verb: 'roll_forward' }, { goalId: 2, verb: 'abandon' }],
+    planningVersionId: 'V2',
+  },
+  'ids as strings': { plan: [{ goalId: '2', verb: 'abandon' }, { goalId: '5', verb: 'roll_forward' }], planningVersionId: 'V2' },
+  'a roll forward with no planning version throws after earlier steps': {
+    plan: [{ goalId: 1, verb: 'abandon' }, { goalId: 2, verb: 'roll_forward' }],
+    planningVersionId: null,
+  },
+  'an empty plan': { plan: [], planningVersionId: 'V2' },
+};
+
+for (const [name, { plan, planningVersionId }] of Object.entries(CLOSE_CASES)) {
+  test(`version close, old loop vs batched: ${name}`, async () => {
+    const args = { versionId: 'V1', plan, reason: 'V1 is done', planningVersionId };
+    const oldDb = fakeDb(CLOSE_SEED);
+    const old = await runLegacyTx(oldDb, (c) => legacy.legacyCloseLoop(c, args));
+    const neuDb = fakeDb(CLOSE_SEED);
+    const neu = await runNew(() => closeVersion(args, { pool: neuDb.pool }));
+
+    assert.deepEqual(errShape(neu.error), errShape(old.error), 'the same refusal');
+    if (!old.error) assert.deepEqual(neu.result.applied, old.result, 'the same applied list, in plan order');
+    assert.deepEqual(neuDb.state.goals, oldDb.state.goals, 'the same goals, successors included');
+    assert.deepEqual(neuDb.state.tasks, oldDb.state.tasks, 'the same tasks');
+  });
+}
+
+test('version close locks every plan goal in ONE statement, in id order', async () => {
+  const db = fakeDb(CLOSE_SEED);
+  await closeVersion({ versionId: 'V1', plan: CLOSE_CASES['plan order is not id order'].plan, reason: 'r', planningVersionId: 'V2' }, { pool: db.pool });
+  const locks = db.queries.filter((q) => /FROM goals WHERE id = ANY\(\$1::bigint\[\]\) AND version_id = \$2 ORDER BY id FOR UPDATE/.test(q));
+  assert.equal(locks.length, 1);
+  assert.equal(db.queries.filter((q) => /FROM goals WHERE id = \$1 AND version_id/.test(q)).length, 0, 'no per-step lock is left');
+});
+
+// ---- weekly karma tally ------------------------------------------------------
+
+const TALLY_SEED = {
+  goals: [], tasks: [], claims: [], nextGoalId: 1, karma: [],
+  peerVotes: [
+    { id: 1, builder_id: 30, vote: 1 }, { id: 2, builder_id: 10, vote: 1 }, { id: 3, builder_id: 30, vote: 1 },
+    { id: 4, builder_id: 20, vote: 1 }, { id: 5, builder_id: 20, vote: -1 }, // nets to zero: no row
+    { id: 6, builder_id: 40, vote: -1 },
+  ],
+  ideaVotes: [{ id: 7, builder_id: 10, vote: 1 }, { id: 8, builder_id: 50, vote: 1 }],
+};
+
+async function withFakePool(db, fn) {
+  const had = Object.prototype.hasOwnProperty.call(pgPool, 'connect');
+  const real = pgPool.connect;
+  pgPool.connect = db.pool.connect;
+  try { return await fn(); } finally { if (had) pgPool.connect = real; else delete pgPool.connect; }
+}
+const fakeWithTx = (db) => async (fn) => {
+  await db.client.query('BEGIN');
+  try { const r = await fn(db.client); await db.client.query('COMMIT'); return r; } catch (e) { await db.client.query('ROLLBACK'); throw e; }
+};
+
+for (const [name, seed] of Object.entries({
+  'task and idea votes, a zero net, first-seen order': TALLY_SEED,
+  'no ideas module': { ...TALLY_SEED, ideaVotes: null },
+  'nothing matured': { ...TALLY_SEED, peerVotes: [], ideaVotes: [] },
+})) {
+  test(`weekly karma tally, old loop vs batched: ${name}`, async () => {
+    const oldDb = fakeDb(seed);
+    const old = await legacy.legacyTallyPeerVotes(fakeWithTx(oldDb));
+    const neuDb = fakeDb(seed);
+    const neu = await withFakePool(neuDb, () => tallyPeerVotes());
+
+    assert.deepEqual(neu, old, 'the same reply');
+    assert.deepEqual(neuDb.state.karma, oldDb.state.karma, 'the same karma_log rows, in the same order');
+    assert.deepEqual(neuDb.state.peerVotes, oldDb.state.peerVotes, 'the same votes stamped');
+    assert.deepEqual(neuDb.state.ideaVotes, oldDb.state.ideaVotes);
+  });
+}
+
+test('the tally writes every credited builder in ONE insert', async () => {
+  const db = fakeDb(TALLY_SEED);
+  const r = await withFakePool(db, () => tallyPeerVotes());
+  assert.equal(r.builders_credited, 4);
+  assert.equal(db.queries.filter((q) => /^INSERT INTO karma_log/.test(q)).length, 1);
+});

package/tests/conductor_main_e2e.mjs

@@ -161,6 +161,10 @@ await test('asking for the next how-to step twice in one session reaches the AI
   const r = await runHook(mePayload(), { prompts: ["what's next in the tutorial", "what's next in the tutorial"] });
   assert.equal(r.outs.length, 2);
   for (const [i, out] of r.outs.entries()) assert.ok(out.includes('npx bongos howto next'), `ask ${i + 1} was swallowed; stdout: ${JSON.stringify(out.slice(0, 200))}`);
+  // task 1004742: the second ask prints the how-to answer ALONE; the rest of the
+  // block (here, the interaction profile) was already shown this session.
+  assert.ok(r.outs[0].includes(INTERACTION), 'the first prompt carries the whole block');
+  assert.ok(!r.outs[1].includes(INTERACTION), `the repeat re-printed the whole block; stdout: ${JSON.stringify(r.outs[1].slice(0, 300))}`);
 });
 
 summary();

package/tests/copy_desk_page_docx.mjs

@@ -75,12 +75,12 @@ const errDetail = (b) => (b && b.error && b.error.details) || {};
 
 const L = (key, section, text, placement, row) => ({ key, section, text, placement, ...(row || {}) });
 const STUDIO_LINES = [
-  L('L0001', 'top bar', 'Studio', 'shared', { file: 'modules/hall-ui/public/shell.js', line: 40, string_id: 'sh0001' }),
-  L('L0002', 'top bar', 'Ctrl K', 'shared'),
+  L('L0001', 'shell bar', 'Studio', 'shared', { file: 'modules/hall-ui/public/shell.js', line: 40, string_id: 'sh0001' }),
+  L('L0002', 'shell bar', 'Ctrl K', 'shared'),
   L('L0003', 'greeting', 'Welcome back', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 12, string_id: 'st0003' }),
   L('L0004', 'greeting', '{…} pages tweaked', 'placed', { file: 'modules/hall-ui/public/studio.js', line: 88, string_id: 'st0004' }),
   L('L0005', 'greeting', 'Your desk is quiet today', 'unplaced'),
-  L('L0006', 'footer', 'Resume where you left off', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 90, string_id: 'st0006' }),
+  L('L0006', 'shell foot', 'Resume where you left off', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 90, string_id: 'st0006' }),
 ];
 const INDEX_LINES = [
   L('L0001', 'hero', 'Build here', 'placed', { file: 'modules/public-landing/public/index.html', line: 3, string_id: 'ix0001' }),

package/tests/copy_desk_page_editor.mjs

@@ -64,11 +64,11 @@ const errCode = (b) => (b && b.error && b.error.code) || null;
 
 const L = (key, section, text, placement, row) => ({ key, section, text, placement, ...(row || {}) });
 const STUDIO_LINES = [
-  L('L0001', 'top bar', 'Studio', 'shared', { file: 'modules/hall-ui/public/shell.js', line: 40, string_id: 'sh0001' }),
-  L('L0002', 'top bar', 'Ctrl K', 'shared'),
+  L('L0001', 'shell bar', 'Studio', 'shared', { file: 'modules/hall-ui/public/shell.js', line: 40, string_id: 'sh0001' }),
+  L('L0002', 'shell bar', 'Ctrl K', 'shared'),
   L('L0003', 'greeting', 'Welcome back', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 12, string_id: 'st0003' }),
   L('L0004', 'greeting', 'Your desk is quiet today', 'unplaced'),
-  L('L0005', 'footer', 'Resume where you left off', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 90, string_id: 'st0005' }),
+  L('L0005', 'shell foot', 'Resume where you left off', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 90, string_id: 'st0005' }),
 ];
 const readingsWith = (studioHash, lines = STUDIO_LINES) => ({
   schema: 1,
@@ -96,13 +96,13 @@ try {
     assert.equal(r.body.page.surface_word, 'builders hall');
     assert.equal(r.body.reading.reading_hash, 'studio-h1');
     assert.deepEqual(r.body.reading.lines.map((l) => [l.key, l.section, l.text, l.note]), [
-      ['L0001', 'top bar', 'Studio', 'shared'],
+      ['L0001', 'shell bar', 'Studio', 'shared'],
       // Shared shell text with no registry row cannot be applied mechanically,
       // so it goes to an engineer at submit, and the note says so.
-      ['L0002', 'top bar', 'Ctrl K', 'engineer'],
+      ['L0002', 'shell bar', 'Ctrl K', 'engineer'],
       ['L0003', 'greeting', 'Welcome back', null],
       ['L0004', 'greeting', 'Your desk is quiet today', 'engineer'],
-      ['L0005', 'footer', 'Resume where you left off', null],
+      ['L0005', 'shell foot', 'Resume where you left off', null],
     ]);
     assert.deepEqual(r.body.notes, { shared: 'changes this on every page', engineer: 'goes to an engineer', guarded: 'must still say' });
     assert.equal(r.body.round, null);

package/tests/copy_desk_page_next.mjs

@@ -101,7 +101,8 @@ try {
 
     const { status, body } = await getNext(ALICE);
     assert.equal(status, 200, JSON.stringify(body));
-    assert.deepEqual(order(body), ['landing:projects', 'status:explore', 'builders:studio', 'landing:index']);
+    assert.deepEqual(order(body), ['landing:projects', 'status:explore', 'builders:studio', 'landing:index', 'landing:skip-link']);
+    // landing:skip-link is the surface's shared chrome, a page of its own, untweaked
     assert.equal(body.recommended.why, '2 people asked for it');
     assert.equal(body.recommended.why_line, 'landing · 2 people asked for it · untweaked');
     assert.equal(body.alternatives[1].why, '1 line changed since your last pass', 'the round artist is the web claim, alice');
@@ -145,7 +146,7 @@ try {
     assert.equal(take.body.page_id, 'status:explore');
     const after = (await getNext(CAROL)).body;
     assert.deepEqual(after.skipped.map((s) => s.page_id).sort(), ['landing:projects', 'status:explore']);
-    assert.deepEqual(order(after), ['builders:studio', 'landing:index']);
+    assert.deepEqual(order(after), ['builders:studio', 'landing:index', 'landing:skip-link', 'builders:top-bar']);
   });
 
   await test('a submitted round is in flight: skipped, and the claim agrees', async () => {

package/tests/copy_desk_page_reads.mjs

@@ -115,7 +115,8 @@ try {
     assert.equal(p('builders:studio').status_label, 'Text tweaked 1x');
     assert.equal(p('builders:studio').drift.changed_count, 1);
     assert.equal(p('builders:studio').open_round.state, 'writing');
-    assert.deepEqual(body.surfaces.map((s) => s.line), ['1 of 2 tweaked', '1 of 1 tweaked', '0 of 1 tweaked']);
+    // Each surface's shared chrome is a page of its own now: landing gains a skip link page, builders a top bar page.
+    assert.deepEqual(body.surfaces.map((s) => s.line), ['1 of 3 tweaked', '1 of 2 tweaked', '0 of 1 tweaked']);
     assert.deepEqual(body.readings, { ok: true, at: 'docs/page-readings.json' });
     assert.deepEqual(body.inventory, { at: 'docs/page-inventory.json' });
   });

package/tests/copy_desk_page_submit.mjs

@@ -65,8 +65,8 @@ const errDetail = (b) => (b && b.error && b.error.details) || {};
 // and an unplaced line.
 const L = (key, section, text, placement, row) => ({ key, section, text, placement, ...(row || {}) });
 const STUDIO_LINES = [
-  L('L0001', 'top bar', 'Studio', 'shared', { file: 'modules/hall-ui/public/shell.js', line: 40, string_id: 'sh0001' }),
-  L('L0002', 'top bar', 'Ctrl K', 'shared'),
+  L('L0001', 'shell bar', 'Studio', 'shared', { file: 'modules/hall-ui/public/shell.js', line: 40, string_id: 'sh0001' }),
+  L('L0002', 'shell bar', 'Ctrl K', 'shared'),
   L('L0003', 'greeting', 'Welcome back', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 12, string_id: 'st0003' }),
   L('L0004', 'greeting', '{…} pages tweaked', 'placed', { file: 'modules/hall-ui/public/studio.js', line: 88, string_id: 'st0004' }),
   L('L0005', 'greeting', 'Your desk is quiet today', 'unplaced'),
@@ -360,6 +360,34 @@ try {
       guarded._setList(null);
     }
   });
+
+  // Task 1004904: a shared-chrome page is a page like any other, whole path.
+  await test('a chrome page: claimed, drafted and submitted through the real routes, its lines placed from the first occurrence', async () => {
+    const TOP = '/copy-desk/pages/builders:top-bar';
+    const chromeLine = (key, text, row) => L(key, 'top bar', text, 'shared', row);
+    const r0 = readingsWith(
+      { hash: 'studio-h1', lines: [chromeLine('L0001', 'Projects', { file: 'modules/hall-ui/public/shell.js', line: 41, string_id: 'sh0041' }), chromeLine('L0002', 'Sign out', { file: 'modules/hall-ui/public/shell.js', line: 42, string_id: 'sh0042' }), ...STUDIO_LINES.slice(2)] },
+      { hash: 'index-h2', lines: INDEX_LINES },
+    );
+    writeReadings(r0);
+    const studio = await call('GET', '/copy-desk/pages/builders:studio', ALICE);
+    assert.equal(studio.status, 200);
+    const page = await call('GET', TOP, ALICE);
+    assert.equal(page.status, 200, JSON.stringify(page.body));
+    assert.equal((await call('POST', `${TOP}/claim`, ALICE)).status, 201);
+    const read = await call('GET', `${TOP}/draft`, ALICE);
+    assert.equal(read.status, 200, JSON.stringify(read.body));
+    const hash = read.body.reading.reading_hash || read.body.reading_hash;
+    assert.ok(hash, 'the chrome page has a reading hash of its own');
+    assert.deepEqual(read.body.reading.lines.map((l) => l.text), ['Projects', 'Sign out']);
+    const saved = await call('PUT', `${TOP}/draft`, ALICE, { reading_hash: hash, lines: [{ key: 'L0001', after: 'Your projects' }] });
+    assert.equal(saved.status, 200, JSON.stringify(saved.body));
+    const sub = await call('POST', `${TOP}/submit`, ALICE);
+    assert.equal(sub.status, 200, JSON.stringify(sub.body));
+    const round = db.tasks.find((t) => t.source_ref === 'page-tweak/builders:top-bar/r1');
+    const batch = pages.parseBatchBlock(round.description).batch;
+    assert.deepEqual(batch.lines.map((l) => [l.key, l.file, l.line, l.before, l.after]), [['L0001', 'modules/hall-ui/public/shell.js', 41, 'Projects', 'Your projects']]);
+  });
 } finally {
   server.close();
   pageData._setRoot(null);