@bongos/core 1.21.97 → 1.21.99

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.97'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.99'; // 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('discord'); log.info('mounted');

package/tests/abandon_task.mjs

@@ -168,7 +168,7 @@ await test("restore: clears only an 'Abandoned: …' value_summary, leaving any
   assert.match(sql, /status = 'backlog'/);
   assert.match(sql, /value_summary LIKE 'Abandoned: %' THEN NULL ELSE value_summary END/,
     'the retire stamp is cleared conditionally — an unrelated summary survives');
-  assert.equal(upd.params.length, 1, 'only the task id is bound');
+  assert.deepEqual(upd.params, [TASK, null], 'the task id, then the parking builder (none passed here)');
 });
 
 await test('restore: clears merged_into_task_id + triage_note (task 1001478 grade finding)', async () => {

package/tests/government_walk.mjs

@@ -0,0 +1,56 @@
+// tests/government_walk.mjs — the government walk stays true (task 1004658, goal
+// 1000111, criterion gov-proven-and-kept-proven).
+//
+// scripts/gds/government-walk.js walks a throwaway project's whole government —
+// genesis, every form, every building's act-alone gate, every matter action — and
+// writes the pass/fail table to docs/governance/government-walk.md. This runs the
+// walk again in its own process (it points the instance root at a temp folder and
+// swaps the government db layer for its in-memory store, so it must not share a
+// module graph with other tests) and fails if ANY row differs from the committed
+// table: a change that breaks a decision flips a row from PASS to FAIL here, and a
+// fix to a filed bug flips one back, which asks for the table to be regenerated.
+//
+// Also pins the walk's own coverage, so it cannot quietly walk less: every bound
+// route of every building has a request in the walk, and every router a bound route
+// lives on is mounted.
+//
+// Run:  node --test tests/government_walk.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const SCRIPT = path.join(ROOT, 'scripts', 'gds', 'government-walk.js');
+const walk = require(SCRIPT);
+const dr = require(path.join(ROOT, 'modules', 'government', 'decision-rules.js'));
+const decisionBoard = require(path.join(ROOT, 'modules', 'government', 'decision-board.js'));
+
+test('the walk covers every bound route of every building', () => {
+  const bound = dr.AREAS.flatMap((a) => a.acts).sort();
+  assert.deepEqual(Object.keys(walk.REQUESTS).sort(), bound, 'a route added to decision-rules AREAS[].acts needs a request in the walk');
+});
+
+test('the walk passes a matter for every action a passed matter can carry out', () => {
+  const planned = walk.MATTER_PLAN.map(([area, , action]) => `${area}.${action.type}`).sort();
+  const actions = Object.entries(decisionBoard.MATTER_ACTIONS)
+    .flatMap(([area, acts]) => Object.keys(acts).map((type) => `${area}.${type}`)).sort();
+  assert.ok(actions.length > 0, 'the matter-action table is not empty');
+  assert.deepEqual(planned, actions, 'a new matter action needs a matter in the walk');
+  // and every planned action is one the server would accept as written
+  for (const [area, , action] of walk.MATTER_PLAN) {
+    assert.equal(decisionBoard.validateMatterAction(area, action).ok, true, `${area} ${action.type} validates`);
+  }
+});
+
+test('the walk re-runs and matches the committed pass/fail table', () => {
+  const env = { ...process.env };
+  delete env.DATABASE_URL;
+  const r = spawnSync(process.execPath, [SCRIPT, '--check'], { cwd: ROOT, env, encoding: 'utf8', timeout: 240000 });
+  assert.equal(r.status, 0, `government-walk --check failed (exit ${r.status}):\n${r.stdout}\n${r.stderr}`);
+  assert.match(r.stdout, /matches the committed table/);
+});

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/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