@bongos/core 1.21.96 → 1.21.98

package/tests/hall_studio_home.mjs

@@ -7,7 +7,10 @@
 // Then the REAL page: studio.html's own body in a mini-DOM, with the real
 // dom-utils.js, tweak-editor-lib.js, studio-lib.js and studio.js in a vm over a
 // stub client, driven the way an artist would: the tally, Resume, the three
-// panels, "take it", and the studio's own words typed over in place.
+// panels, "take it", and the studio's own words typed over in place. And the
+// room's sky (task 1004654): the day room from 07:00 to 18:59 on the viewer's
+// clock, re-checked each minute, and a greeting for the time of day that an
+// artist's own words always beat.
 
 import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
@@ -112,9 +115,23 @@ function augment(el) {
   return el;
 }
 
-function bootStudio({ answers = {}, signedIn = true } = {}) {
+// The viewer's clock, in LOCAL time (the rule reads getHours), held still so
+// a test can name the hour. new Date() answers the held time; new Date(x) is
+// the real constructor, so the composers' ISO dates still parse.
+function heldClock(h, m) {
+  const Real = Date;
+  let t = new Real(2026, 9, 9, h, m, 0).getTime();
+  class Held extends Real {
+    constructor(...a) { if (a.length) super(...a); else super(t); }
+    static now() { return t; }
+  }
+  Held.set = (hh, mm) => { t = new Real(2026, 9, 9, hh, mm, 0).getTime(); };
+  return Held;
+}
+
+function bootStudio({ answers = {}, signedIn = true, at = null, body = BODY } = {}) {
   const root = augment(makeEl('body', {}));
-  root.innerHTML = BODY;
+  root.innerHTML = body;
   const byId = (id) => walk(root, (c) => (c.id === id ? c : null));
   const docListeners = {};
   const requests = [];
@@ -154,12 +171,20 @@ function bootStudio({ answers = {}, signedIn = true } = {}) {
     addEventListener() {},
     scrollTo() {},
   };
-  const sandbox = { window: windowObj, document: documentObj, location: windowObj.location, console, setTimeout, clearTimeout, encodeURIComponent };
+  // setInterval is held, never real (a real one would keep the run alive): the
+  // test fires each registered tick by hand, as a minute passing.
+  const intervals = [];
+  const fakeSetInterval = (fn, ms) => { intervals.push({ fn, ms }); return intervals.length; };
+  const sandbox = { window: windowObj, document: documentObj, location: windowObj.location, console, setTimeout, clearTimeout, setInterval: fakeSetInterval, encodeURIComponent };
+  const clock = at ? heldClock(at[0], at[1]) : null;
+  if (clock) sandbox.Date = clock;
   sandbox.globalThis = sandbox;
   vm.createContext(sandbox);
   for (const [name, src] of SOURCES) vm.runInContext(src, sandbox, { filename: name });
   const out = {
-    requests, navigated: null, focused: null, el: byId, html: htmlEl,
+    requests, navigated: null, focused: null, el: byId, html: htmlEl, body: root, intervals,
+    // Move the held clock and let a minute pass: every registered tick fires.
+    tickTo: (h, m) => { clock.set(h, m); for (const i of intervals) i.fn(); },
     writes: () => requests.filter((r) => r.method !== 'GET'),
     click: async (id) => { const el = byId(id); assert.ok(el, `no #${id}`); el.fire('click', { target: el }); await out.settle(); },
     clickIn: async (overlayId, sel) => {
@@ -404,6 +429,116 @@ try {
     assert.match(s.el('st-offer-err').textContent, /Only an artist can take a page/);
   });
 
+  // ── the room's sky and the greeting (task 1004654) ────────────────────────
+  const at = (h, m) => new Date(2026, 9, 9, h, m, 0);
+
+  await test('the sky: day from 07:00 to 18:59 on the viewer\'s clock, night either side of it', () => {
+    assert.equal(lib.skyAt(at(6, 59)), 'night');
+    assert.equal(lib.skyAt(at(7, 0)), 'day');
+    assert.equal(lib.skyAt(at(12, 0)), 'day');
+    assert.equal(lib.skyAt(at(18, 59)), 'day');
+    assert.equal(lib.skyAt(at(19, 0)), 'night');
+    assert.equal(lib.skyAt(at(0, 0)), 'night');
+  });
+
+  await test('the greeting\'s time of day: morning before noon by day, afternoon after, evening at night', () => {
+    assert.equal(lib.dayPart(at(6, 59)), 'evening', 'before seven the room is still at night');
+    assert.equal(lib.dayPart(at(7, 0)), 'morning');
+    assert.equal(lib.dayPart(at(11, 59)), 'morning');
+    assert.equal(lib.dayPart(at(12, 0)), 'afternoon');
+    assert.equal(lib.dayPart(at(18, 59)), 'afternoon');
+    assert.equal(lib.dayPart(at(19, 0)), 'evening');
+    assert.equal(lib.clockGreets('Good evening.'), true);
+    assert.equal(lib.clockGreets('  Good   evening. '), true, 'the served markup\'s whitespace is not a tweak');
+    assert.equal(lib.clockGreets('Hello, you.'), false, 'an artist\'s words are not the stock greeting');
+    assert.match(HTML, new RegExp('id="studio-greet"[^>]*>' + lib.STOCK_GREETING.replace('.', '\\.') + '<'), 'the page is served with the stock greeting');
+  });
+
+  await test('the page: the body wears the sky and the greeting follows the clock at each boundary hour', async () => {
+    for (const [h, m, sky, words] of [
+      [6, 59, 'night', 'Good evening.'],
+      [7, 0, 'day', 'Good morning.'],
+      [11, 59, 'day', 'Good morning.'],
+      [12, 0, 'day', 'Good afternoon.'],
+      [18, 59, 'day', 'Good afternoon.'],
+      [19, 0, 'night', 'Good evening.'],
+    ]) {
+      const s = bootStudio({ answers: HOME, at: [h, m] });
+      await s.settle();
+      const hhmm = `${h}:${String(m).padStart(2, '0')}`;
+      assert.equal(s.body.getAttribute('data-sky'), sky, `the sky at ${hhmm}`);
+      assert.equal(s.el('studio-greet').textContent, words, `the greeting at ${hhmm}`);
+    }
+  });
+
+  await test('re-checked each minute: the room turns to day at 07:00 and back to night at 19:00', async () => {
+    const s = bootStudio({ answers: HOME, at: [6, 59] });
+    await s.settle();
+    assert.deepEqual(s.intervals.map((i) => i.ms), [60000], 'one tick, once a minute');
+    assert.equal(s.body.getAttribute('data-sky'), 'night');
+    s.tickTo(7, 0);
+    assert.equal(s.body.getAttribute('data-sky'), 'day');
+    assert.equal(s.el('studio-greet').textContent, 'Good morning.');
+    s.tickTo(12, 0);
+    assert.equal(s.el('studio-greet').textContent, 'Good afternoon.');
+    s.tickTo(19, 0);
+    assert.equal(s.body.getAttribute('data-sky'), 'night');
+    assert.equal(s.el('studio-greet').textContent, 'Good evening.', 'at night the page\'s own greeting is back');
+  });
+
+  await test('an artist\'s rewritten greeting wins at every hour; the sky still follows the clock', async () => {
+    const tweaked = BODY.replace(/(id="studio-greet"[^>]*>)Good evening\.</, '$1Back at the desk.<');
+    assert.notEqual(tweaked, BODY, 'the fixture rewrote the greeting');
+    const s = bootStudio({ answers: HOME, body: tweaked, at: [8, 0] });
+    await s.settle();
+    assert.equal(s.body.getAttribute('data-sky'), 'day');
+    assert.equal(s.el('studio-greet').textContent, 'Back at the desk.');
+    for (const [h, m] of [[12, 0], [19, 0], [7, 0]]) {
+      s.tickTo(h, m);
+      assert.equal(s.el('studio-greet').textContent, 'Back at the desk.', `their words at ${h}:${m}`);
+    }
+  });
+
+  await test('typing over the greeting in the morning: it opens as the page\'s own line, and the clock never types over it', async () => {
+    const s = bootStudio({ answers: { ...HOME, 'GET /copy-desk/pages/builders:studio/draft': ok(studioRead({ held: true })) }, at: [9, 0] });
+    await s.settle();
+    const greet = s.el('studio-greet');
+    assert.equal(greet.textContent, 'Good morning.');
+    await s.click('studio-greet');
+    assert.equal(greet.getAttribute('contenteditable'), 'true', 'matched to the greeting line, not left unread');
+    assert.equal(greet.getAttribute('data-unread'), null);
+    greet.textContent = 'Morning, you.';
+    s.tickTo(13, 0);
+    assert.equal(greet.textContent, 'Morning, you.', 'a minute passing never overwrites the words being typed');
+  });
+
+  await test('the sheet: the day tokens sit beside the night ones, the day pieces, and motion only without a reduced-motion preference', () => {
+    const CSS = read('studio.css');
+    const dayAt = CSS.indexOf('body[data-page="studio"][data-sky="day"] {');
+    const nightAt = CSS.indexOf('body[data-page="studio"] {');
+    assert.ok(nightAt >= 0 && dayAt > nightAt, 'a day block after the night tokens');
+    assert.ok(CSS.slice(nightAt, dayAt).split('\n}').length === 2, 'directly after them: nothing between the two blocks but the day block\'s note');
+    const dayBlock = CSS.slice(dayAt, CSS.indexOf('}', dayAt));
+    // the mockup's [data-sky="day"] values (docs/design/mocks/day-night-rooms/index.html)
+    for (const [tok, v] of [['--st-room', '#efe7dc'], ['--st-frame', '#d6c9b7'], ['--st-night', '#bfdaf0'], ['--st-moon', '#ffd46e'],
+      ['--st-tower-1', '#9db2c7'], ['--st-tower-2', '#8ea4bb'], ['--st-tower-3', '#a8bccf'], ['--st-pane', '#e9f1f8'],
+      ['--st-floor', '#e2d5c3'], ['--st-ink', '#1b1a1d'], ['--st-glass', 'rgba(255, 255, 255, .52)']]) {
+      assert.ok(dayBlock.includes(`${tok}: ${v};`), `day ${tok} is the mockup's ${v}`);
+    }
+    assert.match(CSS, /\.st-light \{[^}]*background: var\(--st-pane\)/, 'the panes are lit by night and unlit by day through one token');
+    assert.match(CSS, /body\[data-sky="day"\] \.st-cloud \{ opacity: \.9; \}/);
+    assert.match(CSS, /body\[data-sky="day"\] \.st-sunpatch \{ opacity: \.7; \}/);
+    assert.match(CSS, /body\[data-sky="day"\] \.st-star,\s*body\[data-sky="day"\] \.st-glow \{ opacity: 0; \}/, 'no stars, and the lamp is off');
+    assert.match(HTML, /class="st-cloud st-cloud--1"/);
+    assert.match(HTML, /class="st-sunpatch"/);
+    const anims = [...CSS.matchAll(/animation:\s*[^;]+;|transition:\s*[^;]+;/g)].map((m) => m.index);
+    const calm = CSS.indexOf('@media (prefers-reduced-motion: no-preference) {');
+    const calmEnd = CSS.indexOf('\n}', calm);
+    assert.ok(anims.length > 0 && anims.every((i) => i > calm && i < calmEnd), 'every animation and transition sits inside the no-preference block');
+    assert.match(CSS, /body\[data-page="studio"\]\[data-sky="day"\] \.st-overlay \{\s*--st-scrim:/, 'the panels follow the sky');
+    assert.match(CSS, /body\[data-page="studio"\]\[data-sky="day"\] \.aq-overlay \{/, 'the Approval queue follows the sky');
+  });
+
   await test('the older reviews stay one quiet door away while any still wait', async () => {
     const REVIEW = { id: '1900', title: 'Artist review: the copy and visuals that shipped in task 1899', status: 'backlog', source: 'cascade', source_ref: 'cascade-artist-review-on-ship-1899', created_at: day(20) };
     const s = bootStudio({ answers: { ...HOME, 'GET /tasks?discipline=artist&status=backlog&limit=50': ok({ tasks: [REVIEW] }) } });

package/tests/parked_backlog_stays_parked.mjs

@@ -0,0 +1,182 @@
+// tests/parked_backlog_stays_parked.mjs
+//
+// A task a PERSON parked in backlog stays there until a person promotes it
+// (task 1004592, migration core_274).
+//
+// What happened: restoring abandoned task 1003397 put it in backlog as ADR 0152
+// says ("comes back un-workable and needs a second, explicit promote"), and the
+// promotion sweep promoted it on the next reconciler tick. Demoting it again
+// was undone one tick later the same way. The sweep could not tell "waiting on
+// a dependency" from "parked on purpose", because nothing in the row said so.
+//
+// HOW THIS PROVES IT. The DB-free unit gate has no Postgres, so the fake below
+// holds task rows in memory and answers each statement the way the database
+// would GIVEN WHAT THE STATEMENT ACTUALLY SAYS: a restore or demote parks a row
+// only if its UPDATE writes parked_at, and the sweep withholds a parked row
+// only if its SQL carries `parked_at IS NULL`. Drop either half and the
+// "still backlog" cases go red. The real restoreTask, parkTask and
+// promoteUnblockedBacklogTasks run against it; nothing is re-typed here.
+//
+// The trigger half (the three promotion functions and the un-park trigger) is
+// checked on the migration's SQL, comments stripped, as
+// tests/promotion_triggers_skip_cascade.mjs does for core_250. That it applied
+// is not proved here; it needs Postgres.
+//
+// Run:  node tests/parked_backlog_stays_parked.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { makeRunner } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const dbShip = require('../modules/lifecycle/db-ship.js');
+const dbTasks = require('../modules/lifecycle/db-tasks.js');
+const read = (rel) => readFileSync(new URL(`../${rel}`, import.meta.url), 'utf8').replace(/\r\n/g, '\n');
+
+const { test, summary } = makeRunner();
+
+const PERSON = 42;
+
+// One in-memory tasks table. Every row has no dependencies and no blocker, so
+// the sweep's other guards pass it: the parked clause is the only thing that
+// can hold a row back.
+function fakeDb(rows) {
+  const tasks = new Map(rows.map((r) => [r.id, { parked_at: null, parked_by: null, ...r }]));
+  const flat = (sql) => String(sql).replace(/\s+/g, ' ');
+  // core_274's BEFORE UPDATE trigger: leaving backlog un-parks.
+  const setStatus = (row, status) => {
+    if (status !== 'backlog') { row.parked_at = null; row.parked_by = null; }
+    row.status = status;
+  };
+  const sweepAdmits = (sql, row) => row.status === 'backlog'
+    && !(/parked_at IS NULL/.test(sql) && row.parked_at);
+  async function query(sqlIn, params = []) {
+    const sql = flat(sqlIn);
+    if (/^(BEGIN|COMMIT|ROLLBACK)/.test(sql)) return { rows: [] };
+    if (/^SELECT id, title, status FROM tasks WHERE id = \$1 FOR UPDATE/.test(sql)) {
+      const row = tasks.get(params[0]);
+      return { rows: row ? [{ ...row }] : [] };
+    }
+    if (/^SELECT t\.id, t\.title, t\.goal_id FROM tasks t/.test(sql)) {
+      return { rows: [...tasks.values()].filter((r) => sweepAdmits(sql, r)).map(({ id, title, goal_id }) => ({ id, title, goal_id })) };
+    }
+    if (/^UPDATE tasks t SET status = 'ready'/.test(sql)) {
+      const ids = params[0];
+      const hit = [...tasks.values()].filter((r) => ids.includes(r.id) && sweepAdmits(sql, r));
+      hit.forEach((r) => setStatus(r, 'ready'));
+      return { rows: hit.map(({ id, title, goal_id }) => ({ id, title, goal_id })) };
+    }
+    if (/^UPDATE tasks SET status = 'backlog'/.test(sql)) {
+      const row = tasks.get(params[0]);
+      const guard = /AND status = 'ready'/.test(sql) ? row && row.status === 'ready' : !!row;
+      if (!guard) return { rows: [], rowCount: 0 };
+      setStatus(row, 'backlog');
+      if (/parked_at = now\(\)/.test(sql)) { row.parked_at = new Date(); row.parked_by = params[1] ?? null; }
+      return { rows: [{ id: row.id, title: row.title, status: row.status }], rowCount: 1 };
+    }
+    throw new Error(`unexpected SQL in fake: ${sql.slice(0, 80)}`);
+  }
+  const client = { query, release() {} };
+  return { tasks, query, connect: async () => client };
+}
+
+const sweep = (pool) => dbTasks.promoteUnblockedBacklogTasks(pool, { armed: true });
+
+await test('control: an ordinary backlog row with nothing pending IS promoted', async () => {
+  // Without this the "still backlog" cases below could pass on a sweep that
+  // promotes nothing at all.
+  const pool = fakeDb([{ id: 1, title: 'waiting on a trigger', status: 'backlog', goal_id: 7 }]);
+  const out = await sweep(pool);
+  assert.deepEqual(out.promoted.map((r) => r.id), [1]);
+  assert.equal(pool.tasks.get(1).status, 'ready');
+});
+
+await test('restore, then the armed sweep: the task is still backlog', async () => {
+  const pool = fakeDb([{ id: 2, title: 'retired by mistake', status: 'abandoned', goal_id: 7 }]);
+  await dbShip.restoreTask({ taskId: 2, parkedBy: PERSON }, { pool });
+  assert.equal(pool.tasks.get(2).status, 'backlog');
+  assert.ok(pool.tasks.get(2).parked_at, 'restore must park the task');
+  assert.equal(pool.tasks.get(2).parked_by, PERSON, 'and record who parked it');
+  const out = await sweep(pool);
+  assert.deepEqual(out.candidates, [], 'a restored task is not a promotion candidate');
+  assert.equal(pool.tasks.get(2).status, 'backlog',
+    'the sweep promoted a restored task: ADR 0152\'s second, explicit promote was skipped');
+});
+
+await test('demote, then the armed sweep: the task is still backlog', async () => {
+  const pool = fakeDb([{ id: 3, title: 'taken back off the board', status: 'ready', goal_id: 7 }]);
+  assert.equal(await dbTasks.parkTask(3, PERSON, pool), true, 'a ready task demotes');
+  assert.equal(pool.tasks.get(3).status, 'backlog');
+  assert.equal(pool.tasks.get(3).parked_by, PERSON);
+  await sweep(pool);
+  assert.equal(pool.tasks.get(3).status, 'backlog',
+    'the sweep re-promoted a demoted task one tick later (task 1003397, 2026-10-06)');
+});
+
+await test('demote refuses a task that is no longer ready, and writes nothing', async () => {
+  const pool = fakeDb([{ id: 4, title: 'claimed meanwhile', status: 'active', goal_id: 7 }]);
+  assert.equal(await dbTasks.parkTask(4, PERSON, pool), false);
+  assert.equal(pool.tasks.get(4).status, 'active');
+  assert.equal(pool.tasks.get(4).parked_at, null);
+});
+
+await test('the sweep carries the parked clause in BOTH the read and the write', async () => {
+  const pool = fakeDb([{ id: 6, title: 'x', status: 'backlog', goal_id: 7 }]);
+  const seen = [];
+  const spy = { query: async (sql, p) => { seen.push(String(sql)); return pool.query(sql, p); } };
+  await sweep(spy);
+  assert.match(seen.find((s) => /SELECT/.test(s)), /t\.parked_at IS NULL/);
+  assert.match(seen.find((s) => /^\s*UPDATE/.test(s)), /t\.parked_at IS NULL/,
+    'the UPDATE re-checks the guard rather than trusting the ids it read');
+});
+
+// ---------- the routes hand the person in ----------
+
+const ROUTES = read('modules/lifecycle/routes/tasks.js');
+const slice = (from, to) => ROUTES.slice(ROUTES.indexOf(from), ROUTES.indexOf(to, ROUTES.indexOf(from)));
+
+await test('the restore branch of /promote parks with the caller', () => {
+  const promote = slice("router.post('/tasks/:id/promote'", "router.post('/tasks/:id/demote'");
+  assert.match(promote, /restoreTask\(\{ taskId: id, parkedBy: req\.builder\.id \}\)/);
+});
+
+await test('/demote parks with the caller instead of a bare status flip', () => {
+  const demote = slice("router.post('/tasks/:id/demote'", '// Phase 5 lifecycle transitions');
+  assert.match(demote, /db\.parkTask\(id, req\.builder\.id\)/);
+  assert.doesNotMatch(demote, /updateTaskStatus\(id, 'backlog'\)/,
+    'a bare flip leaves no marker and the sweep undoes it');
+});
+
+// ---------- core_274: the triggers ----------
+
+const MIG = read('migrations/core_274_parked_backlog_stays_parked.sql')
+  .replace(/^\s*--.*$/gm, '').replace(/\s+/g, ' ');
+const fnBody = (name) => {
+  const start = MIG.indexOf(`CREATE OR REPLACE FUNCTION ${name}()`);
+  assert.notEqual(start, -1, `core_274 does not define ${name}`);
+  const rest = MIG.slice(start + 1);
+  const next = rest.indexOf('CREATE OR REPLACE FUNCTION');
+  return next === -1 ? rest : rest.slice(0, next);
+};
+
+await test('core_274 adds the two nullable marker columns, forward-safe', () => {
+  assert.match(MIG, /ADD COLUMN IF NOT EXISTS parked_at timestamptz;/);
+  assert.match(MIG, /ADD COLUMN IF NOT EXISTS parked_by bigint REFERENCES builders\(id\) ON DELETE SET NULL;/);
+  assert.doesNotMatch(MIG, /NOT NULL|DEFAULT/i, 'no default: an older release must never park anything');
+});
+
+await test('each promotion trigger refuses a parked row (a dependency shipping cannot free it)', () => {
+  for (const name of ['promote_dependents_on_ship', 'promote_dependents_on_criterion_satisfy', 'promote_dependents_on_goal_achieve']) {
+    assert.match(fnBody(name), /AND t\.parked_at IS NULL/, `${name} promotes a parked task`);
+  }
+});
+
+await test('leaving backlog un-parks, and only a real status change does', () => {
+  const fn = fnBody('clear_parked_on_leave_backlog');
+  assert.match(fn, /IF NEW\.status IS DISTINCT FROM 'backlog' THEN NEW\.parked_at := NULL; NEW\.parked_by := NULL;/);
+  assert.match(MIG, /BEFORE UPDATE OF status ON tasks FOR EACH ROW WHEN \(OLD\.status IS DISTINCT FROM NEW\.status\) EXECUTE FUNCTION clear_parked_on_leave_backlog\(\)/);
+});
+
+summary();

package/tests/projects_hub_pre_uat.mjs

@@ -213,8 +213,9 @@ test('the manifest step acknowledges code_received, offers a restart after a sta
   // 'converting' is the same stage — it used to fall through to "waiting for approval" (task 1004572)
   assert.match(SCRIPT, /if \(live\.manifest === 'code_received' \|\| live\.manifest === 'converting'\)/, 'GitHub’s half is acknowledged');
   assert.match(SCRIPT, /Approved on GitHub\. The platform is placing the app’s keys on your project/);
-  assert.match(SCRIPT, /manifestStale \? '<button type="button" class="linklike" data-action="manifest-start">/, 'a stalled wait gets a restart door');
-  assert.match(SCRIPT, /\(Date\.now\(\) - manifestStartedAt\) > 90000/, 'after ~90 seconds');
+  // the way back is the SAME attempt, on show from the start — never a new link after 90s (task 1004652)
+  assert.match(SCRIPT, /data-action="reopen-github">No GitHub tab\? Reopen GitHub/, 'a waiting step can reopen GitHub');
+  assert.doesNotMatch(SCRIPT, /manifestStale|> 90000/, 'no 90-second restart door left');
   assert.match(SCRIPT, /function rememberManifest\(stateToken, status, appSlug\)/);
   assert.match(SCRIPT, /rememberManifest\(d\.state, 'pending'\)/, 'the token is remembered when GitHub is opened');
   assert.match(SCRIPT, /if \(created\.manifest\) \{ live\.manifest = created\.manifest; live\.appSlug = created\.app_slug \|\| null; \}/, 'enter() re-seeds the step');

package/tests/promotion_triggers_skip_cascade.mjs

@@ -33,7 +33,9 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const repoRoot = join(__dirname, '..');
 const read = (...p) => readFileSync(join(repoRoot, ...p), 'utf8');
 
-const MIG = 'core_250_cascade_requests_do_not_auto_promote.sql';
+// core_274 (task 1004592) restated all three bodies to add the parked clause,
+// so it is now the latest definition and must carry core_250's guard forward.
+const MIG = 'core_274_parked_backlog_stays_parked.sql';
 
 // The three promotion triggers, by the state transition each reacts to.
 const TRIGGERS = [
@@ -59,7 +61,7 @@ function fnBody(name) {
 
 const { test, summary } = makeRunner();
 
-await test('core_250 redefines all three promotion triggers', () => {
+await test('the latest migration redefines all three promotion triggers', () => {
   for (const name of TRIGGERS) {
     assert.match(body, new RegExp(`CREATE OR REPLACE FUNCTION ${name}\\(\\)`), `${name} is redefined`);
   }
@@ -99,7 +101,7 @@ await test('nothing else was weakened while adding the guard', () => {
   }
 });
 
-await test('core_250 is the LAST definition of each trigger in migrations/', () => {
+await test('the latest migration is the LAST definition of each trigger in migrations/', () => {
   // The drift tripwire, and the assertion that would have caught migration 177
   // on the day it landed. A later whole-body redefinition inherits only what it
   // restates, so this fails the moment someone redefines one of these functions

package/tests/provisioning_github_app_routes.mjs

@@ -29,6 +29,9 @@ provisioning.getOAuthManifestByState = async (_db, state) => (state === 'GOODSTA
   ? { id: 99, instance_id: 42, requested_by: 7, status: 'pending', expires_at: new Date(Date.now() + 600000).toISOString() }
   : null);
 provisioning.attachManifestCode = async (_db, id, code) => ({ id, status: 'code_received', github_code: code });
+// the latest attempt the mint guard and the pick-up route read (task 1004652); none by default
+let latest = null;
+provisioning.getLatestOAuthManifestForInstance = async () => latest;
 
 // A branding with a known publicOrigin so mothershipOrigin() resolves deterministically.
 const branding = require(`${ROOT}/src/branding.js`);
@@ -281,6 +284,76 @@ console.log('\nGET /provisioning/github-app/status (the page poll → auto-open
   t('missing state → 400', res.status === 400, `status=${res.status}`);
 }
 
+console.log('\nNever a second app (task 1004652): the mint guard and "Pick up where it stopped":');
+{
+  const mint = async () => fetch(`${base}/provisioning/instances/42/github-app`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}' });
+  const soon = new Date(Date.now() + 600000).toISOString();
+  // a link still waiting on GitHub is handed back — the SAME state, no new attempt row
+  stored = null;
+  latest = { id: 70, instance_id: 42, state: 'WAITINGSTATE', status: 'pending', attempts: 0, expires_at: soon, created_at: new Date().toISOString() };
+  let res = await mint();
+  let j = await res.json();
+  t('a waiting link is reopened, not re-minted: same state, same expiry, no new row', res.status === 200 && j.state === 'WAITINGSTATE' && j.expires_at === soon && stored === null && j.post_url === 'https://github.com/settings/apps/new?state=WAITINGSTATE', JSON.stringify(j));
+  // GitHub already made the app (keys placed, sign-in unconfirmed): refused, nothing minted
+  for (const row of [
+    { id: 71, instance_id: 42, state: 'S71', status: 'error', attempts: 1, app_id: 5, app_slug: 'mercury-app', expires_at: soon },
+    { id: 72, instance_id: 42, state: 'S72', status: 'done', attempts: 1, app_id: 5, app_slug: 'mercury-app', expires_at: soon },
+    { id: 73, instance_id: 42, state: 'S73', status: 'error', attempts: 2, app_id: null, app_slug: null, expires_at: soon },
+  ]) {
+    stored = null; latest = row;
+    res = await mint(); j = await res.json();
+    t(`an attempt GitHub approved (${row.status}, attempts ${row.attempts}) refuses a new link: 409 app_exists, nothing minted`, res.status === 409 && j.error.code === 'app_exists' && stored === null, JSON.stringify(j));
+  }
+  stored = null; latest = { id: 74, instance_id: 42, state: 'S74', status: 'converting', attempts: 1, expires_at: soon };
+  res = await mint(); j = await res.json();
+  t('an attempt the runner is converting refuses a new link: 409 github_in_progress', res.status === 409 && j.error.code === 'github_in_progress' && stored === null, JSON.stringify(j));
+  // nothing was made on GitHub: a fresh link is minted
+  for (const row of [
+    { id: 75, instance_id: 42, state: 'S75', status: 'pending', attempts: 0, expires_at: new Date(Date.now() - 1000).toISOString() },
+    { id: 76, instance_id: 42, state: 'S76', status: 'error', attempts: 0, expires_at: soon },
+  ]) {
+    stored = null; latest = row;
+    res = await mint(); j = await res.json();
+    t(`nothing made on GitHub (${row.status}, attempts ${row.attempts}) → a fresh state is minted`, res.status === 200 && stored && stored.state === j.state && j.state !== row.state, JSON.stringify(j));
+  }
+
+  // the pick-up route: 'convert' re-queues the SAME attempt with the code it holds
+  const queries = [];
+  const pg = require(`${ROOT}/src/module-api.js`).pool;
+  const prevQuery = pg.query;
+  pg.query = async (sql, params) => { queries.push({ sql, params }); return { rows: /UPDATE provisioning_oauth_manifests/.test(sql) ? [{ id: params[0] }] : [] }; };
+  const pickUp = async () => fetch(`${base}/provisioning/instances/42/github-app/pick-up`, { method: 'POST' });
+  latest = { id: 80, instance_id: 42, state: 'S80', status: 'error', attempts: 1, github_code: 'CODE', app_id: null, app_slug: null, created_at: new Date(Date.now() - 10 * 60000).toISOString(), expires_at: soon };
+  const before = reported.length;
+  stored = null;
+  res = await pickUp(); j = await res.json();
+  const requeue = queries.find((q) => /UPDATE provisioning_oauth_manifests/.test(q.sql));
+  t("pick-up 'convert' re-queues attempt 80 itself (status code_received, attempts reset), mints nothing", res.status === 200 && j.action === 'convert' && requeue && requeue.params[0] === 80 && /status = 'code_received', attempts = 0/.test(requeue.sql) && /github_code IS NOT NULL/.test(requeue.sql) && stored === null, JSON.stringify(j));
+  // 'check': keys placed, the runner's window closed → a check request, no new attempt
+  queries.length = 0;
+  latest = { id: 81, instance_id: 42, state: 'S81', status: 'error', attempts: 1, app_id: 5, app_slug: 'mercury-app', created_at: new Date(Date.now() - 5 * 3600000).toISOString(), resolved_at: new Date(Date.now() - 4 * 3600000).toISOString(), expires_at: soon };
+  res = await pickUp(); j = await res.json();
+  const asked = reported.slice(before).filter((e) => e.event === 'github-app-check-requested');
+  t("pick-up 'check' records one check request for the project and writes no attempt", res.status === 200 && j.action === 'check' && asked.length === 1 && asked[0].instanceId === 42 && !queries.some((q) => /UPDATE|INSERT/.test(q.sql)) && stored === null, JSON.stringify(j));
+  // nothing the route itself can pick up: 409 naming the page's own action
+  for (const [row, action] of [
+    [{ id: 82, instance_id: 42, state: 'S82', status: 'pending', attempts: 0, expires_at: soon }, 'reopen'],
+    [{ id: 83, instance_id: 42, state: 'S83', status: 'error', attempts: 2, github_code: null, app_id: null, created_at: new Date().toISOString(), expires_at: soon }, 'operator'],
+  ]) {
+    latest = row;
+    res = await pickUp(); j = await res.json();
+    t(`pick-up on '${action}' is the page's own: 409 nothing_to_pick_up, action named`, res.status === 409 && j.error.code === 'nothing_to_pick_up' && j.error.action === action, JSON.stringify(j));
+  }
+  // another builder's project is a 404, like a missing one
+  const prevInst = provisioning.getInstanceById;
+  provisioning.getInstanceById = async () => ({ id: 42, owner_builder_id: 8, slug: 'mercury', domain: 'mercury.example.com', status: 'active' });
+  res = await pickUp();
+  t('pick-up on someone else’s project → 404', res.status === 404, `status=${res.status}`);
+  provisioning.getInstanceById = prevInst;
+  pg.query = prevQuery;
+  latest = null;
+}
+
 console.log('\nparseId contract (the (req,res) signature — a bad id is a clean 400, not a 500):');
 {
   const res = await fetch(`${base}/provisioning/instances/not-a-number/github-app`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}' });