@bongos/core 1.25.5 → 1.25.7

package/tests/hall_visor.mjs

@@ -105,8 +105,8 @@ test('no key ever means two things: every character over every real scene, and O
     assert.notEqual(r.options.key, 'esc', `${c}: Options is not on Escape; Escape is Close`);
     assert.ok(r.options.key, `${c}: Options has a key of its own`);
   }
-  assert.equal(V.resolveKeys('artist').options.key, 'o', 'O is Options where nothing else holds it');
-  assert.equal(V.resolveKeys('patron').options.key, 'p', "the Patron's O is the Board room, so Options moves to its next letter");
+  assert.equal(V.resolveKeys('artist').options.key, 'm', 'M is the game menu where nothing else holds it');
+  assert.equal(V.resolveKeys('patron').options.key, 'm', 'no character holds M, so the game menu keeps it for all three');
 });
 
 test('a clash moves the later claimant to a free letter of its own name, and its key follows', () => {
@@ -205,6 +205,25 @@ test('source: the minimal visor spends the Helm tokens and types in no colour, s
   assert.doesNotMatch(glass, /background|box-shadow|backdrop-filter|filter:/, 'the glass itself paints nothing: no edge band, no vignette, no veil');
   assert.doesNotMatch(css, /--night-glass|linear-gradient|radial-gradient\((?!circle, currentColor)|--type-halo/, 'no band of the night anywhere on the glass, and no dark glow round its type');
   assert.match(css, /\.visor__place, \.visor__who, \.visor__hint \{ background: var\(--night-plate\); clip-path: var\(--cut-path-sm\); \}/, 'the place, each hint and your credits stand on a small cut plate of the night');
+  // smoked glass (task 1005252): where the browser can blur, each plate is a pane that softens the scene
+  // behind it, from the Helm tokens; asking for less transparency puts the night plate back
+  const PANES = '.visor__place, .visor__who, .visor__hint, .visor__progress-words {';
+  const block = (head) => { const at = css.indexOf(head); assert.ok(at >= 0, head); const open = css.indexOf(PANES, at); assert.ok(open > at, head + ' holds the four plates'); return css.slice(open, css.indexOf('}', open)); };
+  const smoke = block('@supports ((backdrop-filter: blur(1px)) or (-webkit-backdrop-filter: blur(1px))) {');
+  assert.ok(smoke.includes('background: var(--smoke-sheen), var(--smoke);'), 'a light smoke with a sheen, from tokens');
+  assert.ok(smoke.includes('box-shadow: var(--smoke-edge);'), 'a lit top edge makes it a pane');
+  assert.ok(smoke.includes(' backdrop-filter: var(--smoke-blur);'), 'it blurs the scene behind it');
+  const STYLE = fs.readFileSync(new URL('../modules/hall-ui/public/style.css', import.meta.url), 'utf8');
+  const plainAt = STYLE.indexOf('@media (prefers-reduced-transparency: reduce) {');
+  const plain = STYLE.slice(plainAt, STYLE.indexOf('}', plainAt));
+  assert.ok(plainAt >= 0 && plain.includes('html .visor__place, html .visor__who, html .visor__hint, html .visor__progress-words {'), 'less transparency is answered in style.css, lifted over visor.css');
+  assert.ok(plain.includes('background: var(--night-plate);') && plain.includes(' backdrop-filter: none;'), 'less transparency: the night plate again');
+  const smokeTokens = STYLE.match(/--smoke[a-z-]*:[^;]*;/g) || [];
+  assert.equal(smokeTokens.length, 4, 'four smoke tokens: the tint, the blur, the sheen, the edge');
+  assert.doesNotMatch(smokeTokens.join(' '), /rgba?\(|#[0-9a-f]{3,8}\b/i, 'every smoke colour derives from a Helm token, no literal');
+  assert.ok(STYLE.includes('html[data-game="on"] .visor__who, html[data-game="on"] .visor__hint { background: var(--night-plate); box-shadow: none; -webkit-backdrop-filter: none; backdrop-filter: none; }'), 'a phone keeps the night plate: no live blur on the weakest GPU');
+  assert.ok(STYLE.indexOf('backdrop-filter: none; }') > STYLE.indexOf('tasks 1005148 and 1005195, the visor'), 'and that rule sits in the shared phone block');
+  assert.ok(css.indexOf('@supports ((backdrop-filter') > css.indexOf('.visor__progress-words {'), 'the smoke comes after every plate rule, so it wins the cascade');
   assert.match(css, /\.visor__line--under \{ stroke: var\(--bg\); stroke-opacity: 1/, 'every line is drawn over a solid stroke of the night, so it reads on cloud and on night');
   assert.match(css, /\.visor__key \{[^}]*background: var\(--bg\)/, 'a key sits on a chip of the night');
   assert.doesNotMatch(css, /data-hour|data-time|data-sky/, 'no per-hour style');
@@ -365,12 +384,26 @@ test('a lead scene action is the first key hint, and its click and its key run i
   await ctx.close();
 });
 
+// task 1005251: the options window keeps its aria-modal box after it closes. Only a dialog that
+// is SHOWN holds the visor's keys; before this, one visit to Options left every key dead.
+test('a closed dialog left in the page does not hold the keys; an open one does', { skip }, async () => {
+  const { ctx, page } = await open();
+  await page.evaluate(() => { const d = document.createElement('div'); d.id = 'gone'; d.setAttribute('aria-modal', 'true'); d.hidden = true; document.body.appendChild(d); });
+  await page.keyboard.press('a');
+  assert.equal(await page.evaluate(() => OTBVisor.isOpen()), true, 'a hidden modal box: A still opens the sheet');
+  await page.keyboard.press('Escape');
+  await page.evaluate(() => { document.getElementById('gone').hidden = false; document.getElementById('gone').textContent = 'up'; });
+  await page.keyboard.press('a');
+  assert.equal(await page.evaluate(() => OTBVisor.isOpen()), false, 'a modal that is up keeps the keyboard');
+  await ctx.close();
+});
+
 test('the sheet lists the character\'s actions, then this place, and runs a scene action', { skip }, async () => {
   const { ctx, page } = await open();
   await page.click('[data-visor-sheet]');
   const rows = await page.$$eval('.visor__sheet .visor__row', (r) => r.map((x) => [...x.children].map((c) => c.textContent).join(' ')));
   // task 1005200: Claim a task and Blockers open classic pages, so they are off the glass.
-  assert.deepEqual(rows, ['Goal sky G', 'Your thinking T', 'Back to centre 0', 'Look around drag', 'Options O']);
+  assert.deepEqual(rows, ['Goal sky G', 'Your thinking T', 'Back to centre 0', 'Look around drag', 'Game menu M']);
   assert.equal(await page.$eval('.visor__sheet [data-visor-close]', (b) => b.textContent), 'Esc', 'Escape is the Close of the sheet, and only that');
   await page.click('[data-visor-scene="0"]');
   assert.deepEqual(await page.evaluate(() => ({ centred: window.centred, open: OTBVisor.isOpen() })), { centred: true, open: false });
@@ -481,7 +514,7 @@ test('the glass is the kit\'s: the cut accent button, ice hints with no box, the
     return {
       mainBg: cs('.visor__main').backgroundColor, accent: probe('var(--accent)'), mainClip: cs('.visor__main').clipPath,
       mainCase: cs('.visor__main').textTransform, hintBg: cs('.visor__hint').backgroundColor, hintBorder: cs('.visor__hint').borderTopWidth,
-      plate: probe('var(--night-plate)'), placeBg: cs('.visor__place').backgroundColor, whoBg: cs('.visor__who').backgroundColor, hintClip: cs('.visor__hint').clipPath,
+      plate: probe('var(--smoke)'), blur: cs('.visor__place').backdropFilter, edge: cs('.visor__hint').boxShadow, placeBg: cs('.visor__place').backgroundColor, whoBg: cs('.visor__who').backgroundColor, hintClip: cs('.visor__hint').clipPath,
       glassBg: cs('#visor').backgroundImage + ' ' + cs('#visor').backgroundColor,
       hintColor: cs('.visor__hint').color, ice: probe('var(--ink-soft)'), num: cs('.visor__num').color, unit: cs('.visor__unit').color, white: probe('var(--ink)'),
       placeShadow: cs('.visor__place').textShadow, radius: cs('.visor__sprite').borderTopLeftRadius, spriteClip: cs('.visor__sprite').clipPath,
@@ -492,7 +525,9 @@ test('the glass is the kit\'s: the cut accent button, ice hints with no box, the
   assert.match(g.mainClip, /^polygon\(/, 'cut corner');
   assert.equal(g.mainCase, 'uppercase', 'the name voice');
   assert.equal(g.glassBg, 'none rgba(0, 0, 0, 0)', 'the glass darkens nothing: the scene shows to every edge');
-  assert.equal(g.hintBg, g.plate, 'a hint stands on a plate of the night');
+  assert.equal(g.hintBg, g.plate, 'a hint stands on a pane of smoked glass (task 1005252)');
+  assert.match(g.blur, /blur\(14px\)/, 'the pane blurs the scene behind it');
+  assert.match(g.edge, /inset/, 'and has a lit edge');
   assert.equal(g.placeBg, g.plate, 'so does the place');
   assert.equal(g.whoBg, g.plate, 'and your credits');
   assert.match(g.hintClip, /^polygon\(/, 'the plate is cut');

package/tests/provision_settings_apply.mjs

@@ -80,6 +80,7 @@ ${NEUTRAL_PREFIX}_FOUNDING_GENESIS=
 ${NEUTRAL_PREFIX}_DEMO_PEOPLE=
 ${NEUTRAL_PREFIX}_DEMO_HOURS=
 ${NEUTRAL_PREFIX}_SHIP_MODE=
+${NEUTRAL_PREFIX}_TEST_PROJECT=
 ${NEUTRAL_PREFIX}_HUB_UPGRADE_URL=
 `;
 
@@ -151,7 +152,7 @@ t('settingsEnvVarsFor: the runner pushes the SAME pair webEnvBody writes at stan
     // the birth marker and a demo's box (task 1004506), empty on an un-stamped row
     [`${NEUTRAL_PREFIX}_FOUNDING_BIRTH`]: '', [`${NEUTRAL_PREFIX}_FOUNDING_GENESIS`]: '', [`${NEUTRAL_PREFIX}_DEMO_PEOPLE`]: '', [`${NEUTRAL_PREFIX}_DEMO_HOURS`]: '',
     // the wizard's ship mode (task 1004629), empty when none was picked
-    [`${NEUTRAL_PREFIX}_SHIP_MODE`]: '',
+    [`${NEUTRAL_PREFIX}_SHIP_MODE`]: '', [`${NEUTRAL_PREFIX}_TEST_PROJECT`]: '',
     // where the hall's Update button goes (task 1004608), empty when no hub origin resolves
     [`${NEUTRAL_PREFIX}_HUB_UPGRADE_URL`]: '',
   });

package/tests/provisioning_paid_shape_gate.mjs

@@ -243,6 +243,22 @@ await ta('cloud-host: ADMITTED past the limit for a builder holding provisioning
   assert.equal(lastCreateArgs && lastCreateArgs.hostingShape, 'cloud-host');
 });
 
+await ta('cloud-host: a TEST project holds no free place, so it does not make the next one a second (task 1005036)', async () => {
+  // Only an archon makes a test project, and it is for trying features: counting it would
+  // charge a builder's one free place for a project nobody meant to keep.
+  held = [];
+  owned = [{ ...LIVE_HOSTED, slug: 'sandbox', settings: { test_project: 'on' } }];
+  lastCreateArgs = null;
+  const res = await post('/provisioning/instances', { slug: 'demo', hosting_shape: 'cloud-host', no_address: true });
+  assert.equal(res.status, 201, 'a test project alone leaves the free place free: ' + res.raw);
+  held = [];
+  owned = [LIVE_HOSTED, { ...LIVE_HOSTED, slug: 'sandbox', settings: { test_project: 'on' } }];
+  lastCreateArgs = null;
+  const second = await post('/provisioning/instances', { slug: 'demo', hosting_shape: 'cloud-host', no_address: true });
+  owned = [];
+  assert.equal(second.status, 403, 'a real project plus a test one still counts the real one');
+});
+
 // ── control-plane is not requestable AT ALL (task 1003370) ────────────────────────
 
 await ta('control-plane: refused for an unprivileged builder, and the refusal is not a permission', async () => {

package/tests/provisioning_settings_env.mjs

@@ -128,7 +128,7 @@ t('settingsEnvVars is the single source both legs derive from — same keys, sam
     // route never stamped, which is every row made before it shipped (spec D8).
     CLOUDBONGOS_FOUNDING_BIRTH: '', CLOUDBONGOS_FOUNDING_GENESIS: '', CLOUDBONGOS_DEMO_PEOPLE: '', CLOUDBONGOS_DEMO_HOURS: '',
     // The wizard's ship mode (task 1004629): empty when none was picked.
-    CLOUDBONGOS_SHIP_MODE: '',
+    CLOUDBONGOS_SHIP_MODE: '', CLOUDBONGOS_TEST_PROJECT: '',
   });
   // varsOf splits on '=', so an empty value reads as '' on both sides — the point
   // of the comparison is that the standup lines carry exactly the same key set.
@@ -137,7 +137,7 @@ t('settingsEnvVars is the single source both legs derive from — same keys, sam
     X_PLATFORM_VISIBILITY: 'public', X_JOINABILITY: 'apply', X_VISIBILITY: 'public', X_JOIN_GRANT: 'full',
     X_ARTIST_GATE: 'strict', X_ARTIST_GATE_SINCE: '', X_SPEND_PAYER: 'none',
     X_LOOK: 'own', X_NIGHT_TINT: 'on', X_LOOK_ACCENT: '', X_LOGO_URL: '',
-    X_FOUNDING_BIRTH: '', X_FOUNDING_GENESIS: '', X_DEMO_PEOPLE: '', X_DEMO_HOURS: '', X_SHIP_MODE: '',
+    X_FOUNDING_BIRTH: '', X_FOUNDING_GENESIS: '', X_DEMO_PEOPLE: '', X_DEMO_HOURS: '', X_SHIP_MODE: '', X_TEST_PROJECT: '',
   }, 'defaults, explicitly');
 });
 

package/tests/test_project.mjs

@@ -0,0 +1,122 @@
+// tests/test_project.mjs — A TEST PROJECT: one made to try features that are not live yet
+// (task 1005036, idea 1001299; owner, 2026-11-01).
+//
+// Done-when: only an archon can ask for one; it is stamped once on the row just made; it is
+// kept off the public map; it reaches the instance as project.test; and the not-yet-live
+// genesis switch opens on a test project and nowhere else. The free-place count is pinned in
+// tests/provisioning_paid_shape_gate.mjs and the create route in tests/wizard_demo.mjs.
+//
+// Run:  node --test tests/test_project.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const tp = require('../modules/provisioning/test-project.js');
+const provisioning = require('../modules/provisioning/provisioning.js');
+const bridge = require('../modules/provisioning/catalog-bridge.js');
+const gh = require('../modules/onboarding/genesis-home.js');
+const fm = require('../modules/onboarding/founding-mode.js');
+
+const ARCHON = { id: 1, rank: 'archon' };
+const METIC = { id: 2, rank: 'metic' };
+const ROW = (settings) => ({ id: 41, slug: 'sandbox', domain: 'sandbox.example.test', status: 'active', hosting_shape: 'cloud-host', settings });
+
+test('only an archon can ask for a test project, and genesis means nothing without one', () => {
+  assert.deepEqual(tp.parseTestAsk({ test: true }, ARCHON), { ok: true, test: true, genesis: false });
+  assert.deepEqual(tp.parseTestAsk({ test: true, genesis: true }, ARCHON), { ok: true, test: true, genesis: true });
+  assert.deepEqual(tp.parseTestAsk({}, METIC), { ok: true, test: false, genesis: false }, 'a request that asks for nothing is fine for anyone');
+  const refused = tp.parseTestAsk({ test: true }, METIC);
+  assert.equal(refused.ok, false);
+  assert.equal(refused.status, 403);
+  assert.equal(refused.code, 'test_project_forbidden');
+  assert.equal(tp.parseTestAsk({ test: true }, undefined).ok, false, 'no builder, no test project');
+  assert.equal(tp.parseTestAsk({ test: 'yes' }, METIC).ok, true, 'only a real boolean true asks');
+  const alone = tp.parseTestAsk({ genesis: true }, ARCHON);
+  assert.equal(alone.ok, false);
+  assert.equal(alone.code, 'genesis_needs_test');
+  assert.equal(alone.status, 400);
+});
+
+test('the mark: stamped on the row it is given, once; read only when it says on', async () => {
+  const seen = [];
+  await tp.stampTestProject({ query: async (sql, params) => { seen.push({ sql, params }); return { rows: [] }; } }, 41);
+  assert.equal(seen.length, 1);
+  assert.match(seen[0].sql, /WHERE id = \$1 AND NOT \(COALESCE\(settings, '\{\}'::jsonb\) \? \$2::text\)/, 'write-once');
+  assert.deepEqual(seen[0].params, [41, 'test_project']);
+  assert.equal(tp.isTestProject(ROW({ test_project: 'on' })), true);
+  for (const bad of [undefined, null, {}, { test_project: 'yes' }, { test_project: true }, 'on']) {
+    assert.equal(tp.isTestProject(ROW(bad)), false, JSON.stringify(bad));
+  }
+  assert.equal(tp.isTestProject(null), false);
+});
+
+test('the owner view says it, and it reaches web.env as TEST_PROJECT, empty on every other project', () => {
+  assert.equal(provisioning.publicInstance(ROW({ test_project: 'on' })).is_test, true);
+  assert.equal(provisioning.publicInstance(ROW({})).is_test, false);
+  assert.equal(provisioning.settingsEnvVars(ROW({ test_project: 'on' }), 'X').X_TEST_PROJECT, 'on');
+  assert.equal(provisioning.settingsEnvVars(ROW({}), 'X').X_TEST_PROJECT, '', 'a line that came and went would leave a stale one behind');
+  assert.equal(provisioning.settingsEnvVars(ROW({ test_project: 'maybe' }), 'X').X_TEST_PROJECT, '');
+});
+
+test('a test project is never on the public map; the same row without the mark is', () => {
+  assert.equal(bridge.catalogEntryForInstance(ROW({ test_project: 'on' }), { ownerGithubId: 99 }), null);
+  const plain = bridge.catalogEntryForInstance(ROW({}), { ownerGithubId: 99 });
+  assert.ok(plain && plain.clientId === 'sandbox', 'an ordinary project still projects');
+});
+
+test('the instance reads TEST_PROJECT into project.test, and publishes it as a boolean beside project, not in it', () => {
+  const read = (env) => JSON.parse(execFileSync(process.execPath, ['-e',
+    "const b=require('./src/branding.js');const r=(b.branding||b)();console.log(JSON.stringify({p:r.project&&r.project.test,c:b.clientBranding(r).testProject}))"],
+    { cwd: ROOT, encoding: 'utf8', env: { ...process.env, ...env } }));
+  assert.deepEqual(read({}), { c: false }, 'no env, not a test project');
+  assert.deepEqual(read({ CLOUDBONGOS_TEST_PROJECT: 'on' }), { p: 'on', c: true });
+  assert.deepEqual(read({ CLOUDBONGOS_TEST_PROJECT: '' }), { c: false }, 'the empty line every other project carries');
+});
+
+// ── the genesis switch, on the instance ────────────────────────────────────────
+
+function world({ test = true, settings = {} } = {}) {
+  const store = new Map(Object.entries(settings));
+  const deps = {
+    branding: { project: { test: test ? 'on' : '' } },
+    getSetting: async (k) => (store.has(k) ? { key: k, value: store.get(k) } : null),
+    setSetting: async (k, v) => { store.set(k, String(v)); return { key: k, value: String(v) }; },
+    lifecycle: { seedGenesis: async () => ({ seeded: 0 }), genesisTasks: async () => ({}) },
+    government: null,
+    now: new Date('2026-11-02T09:00:00Z'),
+  };
+  return { store, deps };
+}
+
+test('genesis cannot be switched on from a project that is not a test project', async () => {
+  const w = world({ test: false });
+  assert.deepEqual(await gh.setEnabled(true, 1, w.deps), { ok: false, reason: 'not_a_test_project' });
+  assert.deepEqual(await gh.ownerStart(1, w.deps), { ok: false, reason: 'not_a_test_project' });
+  assert.equal(w.store.size, 0, 'nothing is written');
+});
+
+test('on a test project the switch starts genesis, pauses it, and brings it back', async () => {
+  const w = world();
+  const on = await gh.setEnabled(true, 1, w.deps);
+  assert.equal(on.ok, true);
+  assert.equal(on.mode.active, true);
+  assert.equal(w.store.get(fm.KEYS.ENABLED), 'true');
+  const off = await gh.setEnabled(false, 1, w.deps);
+  assert.equal(off.ok, true);
+  assert.equal(off.mode, null, 'paused: the hall opens full');
+  assert.equal(w.store.get(fm.KEYS.ACTIVE), 'true', 'the founding record is kept');
+  const again = await gh.setEnabled(true, 1, w.deps);
+  assert.equal(again.mode.active, true, 'it comes back where it was');
+  assert.equal((await gh.ownerStart(1, world().deps)).ok, true, 'the owner\'s own start works on a test project');
+});
+
+test('a genesis that came alive cannot be switched back on', async () => {
+  const w = world({ settings: { [fm.KEYS.STARTED_AT]: '2026-11-01T00:00:00Z', [fm.KEYS.ENDED_AT]: '2026-11-01T05:00:00Z' } });
+  assert.deepEqual(await gh.setEnabled(true, 1, w.deps), { ok: false, reason: 'already_alive' });
+});

package/tests/wizard_demo.mjs

@@ -117,6 +117,9 @@ provisioning.getInstanceByDomain = async () => null;
 const order = [];
 const birth = require('../modules/provisioning/birth.js');
 birth.stampBirth = async (_db, id) => { order.push(`birth:${id}`); };
+const testProject = require('../modules/provisioning/test-project.js');
+testProject.stampTestProject = async (_db, id) => { order.push(`test:${id}`); };
+let rank = 'metic';   // who is asking: a test project is an archon's alone (task 1005036)
 provisioning.createInstance = async (_db, args) => {
   created = args;
   const fresh = args.slug !== 'old-one';
@@ -126,7 +129,7 @@ provisioning.enqueueIntent = async (_db, _id, action) => { order.push(`enqueue:$
 provisioning.getOpenIntent = async () => null;
 provisioning.recordEvent = async () => {};
 demo.startDemoProject = async (_db, _p, id, d) => { started = { id, d }; order.push(`demo:${id}`); return null; };
-api.requireBuilder = (req, _res, next) => { req.builder = { id: 7, github_login: 'owner' }; next(); };
+api.requireBuilder = (req, _res, next) => { req.builder = { id: 7, github_login: 'owner', rank }; next(); };
 let stored = null;
 provisioning.getInstanceById = async (_db, id) => (id === 41 ? { id: 41, owner_builder_id: 7, demo: stored } : null);
 api.pool.query = async (sql, params) => { if (/UPDATE provisioning_instances SET demo/.test(sql)) stored = JSON.parse(params[1]); return { rows: [] }; };
@@ -173,8 +176,26 @@ test('a new project is stamped born, once, before its provision intent; an exist
   assert.equal((await post('/provisioning/instances', { slug: 'born-real', hosting_shape: 'byo-host' })).status, 201);
   assert.deepEqual(order, ['enqueue:provision'], 'a real project opens as the full hall: genesis is off by default (owner, 2026-11-01)');
   order.length = 0;
-  assert.equal((await post('/provisioning/instances', { slug: 'born-test', hosting_shape: 'byo-host', genesis: true })).status, 201);
-  assert.deepEqual(order, ['birth:41', 'enqueue:provision'], 'the genesis toggle still births a test project, with no demo box');
+  // A test project (task 1005036): an archon's alone, marked once on the row, and the only way to be born with genesis.
+  const asked = await post('/provisioning/instances', { slug: 'sneaky', hosting_shape: 'byo-host', test: true });
+  assert.equal(asked.status, 403, 'a non-archon cannot make one');
+  assert.equal(asked.body.error.code, 'test_project_forbidden');
+  assert.deepEqual(order, [], 'and nothing is made, marked or queued');
+  const bare = await post('/provisioning/instances', { slug: 'bare-genesis', hosting_shape: 'byo-host', genesis: true });
+  assert.equal(bare.status, 400, 'genesis alone is no longer a way in');
+  assert.equal(bare.body.error.code, 'genesis_needs_test');
+  assert.deepEqual(order, []);
+  rank = 'archon';
+  try {
+    assert.equal((await post('/provisioning/instances', { slug: 'sandbox-a', hosting_shape: 'byo-host', test: true })).status, 201);
+    assert.deepEqual(order, ['test:41', 'enqueue:provision'], 'a test project is marked, not born into genesis');
+    order.length = 0;
+    assert.equal((await post('/provisioning/instances', { slug: 'sandbox-g', hosting_shape: 'byo-host', test: true, genesis: true })).status, 201);
+    assert.deepEqual(order, ['birth:41', 'test:41', 'enqueue:provision'], 'a test project that asks for genesis is born into it, marked, before the runner can read it');
+    order.length = 0;
+    assert.equal((await post('/provisioning/instances', { slug: 'archon-real', hosting_shape: 'byo-host' })).status, 201);
+    assert.deepEqual(order, ['enqueue:provision'], 'an ordinary project made by an archon is still an ordinary project');
+  } finally { rank = 'metic'; }
   order.length = 0;
   const again = await post('/provisioning/instances', { slug: 'old-one', hosting_shape: 'byo-host' });
   assert.ok(again.status < 300, JSON.stringify(again.body));
@@ -182,7 +203,7 @@ test('a new project is stamped born, once, before its provision intent; an exist
   const keep = birth.stampBirth;
   birth.stampBirth = async () => { throw new Error('db hiccup'); };
   try {
-    assert.equal((await post('/provisioning/instances', { slug: 'unlucky', hosting_shape: 'byo-host', genesis: true })).status, 201,
+    assert.equal((await post('/provisioning/instances', { slug: 'unlucky', hosting_shape: 'byo-host', demo: { people: 2, hours_each: 3 } })).status, 201,
       'a missed marker costs the project its genesis, never its creation');
   } finally { birth.stampBirth = keep; }
 });