@bongos/core 1.19.826 → 1.19.828

package/tests/blockers_hall.mjs

@@ -0,0 +1,107 @@
+// tests/blockers_hall.mjs — task 1003455 (goal 1000089): "Blockers become
+// visible: the queue page and the attention slice, from one code path."
+//
+// GET /blockers had zero hall consumers before this task. Done-when: the queue
+// renders on a real page from GET /blockers, the attention inbox shows open
+// blockers as line items, BOTH read the same renderer (blockers-lib.js, pinned
+// separately in tests/blockers_lib.mjs), and the page's list is paged through
+// OTBKit rather than hand-rolled. This file pins the WIRING — that both
+// consumers actually call the shared lib and the real API, and that the page
+// uses the kit's pager rather than reimplementing slicing.
+//
+// Source-regex style, matching tests/rot_inbox.mjs's checks on the same file —
+// pure text assertions over the real client source, no DOM/vm harness needed for
+// what this pins (presence + call shape, not runtime behaviour).
+//
+// Run:  node tests/blockers_hall.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = join(ROOT, 'modules/hall-ui/public');
+const GOAL_INBOX_SRC = readFileSync(join(HALL, 'goal-inbox.js'), 'utf8');
+const BLOCKERS_JS_SRC = readFileSync(join(HALL, 'blockers.js'), 'utf8');
+const BLOCKERS_HTML_SRC = readFileSync(join(HALL, 'blockers.html'), 'utf8');
+const INDEX_HTML_SRC = readFileSync(join(HALL, 'index.html'), 'utf8');
+
+// ---- the attention-inbox slice (goal-inbox.js) -----------------------------
+
+test('goal-inbox.js carries a blockers slice div in the SAME needs-attention card', () => {
+  assert.match(GOAL_INBOX_SRC, /<div id="attention-blockers"><\/div>/,
+    'a second Home card would violate the placement rule (hall-ui/CLAUDE.md): an action awaiting a human is an inbox line, never a new card');
+});
+
+test('goal-inbox.js reads the real GET /blockers route, not a stand-in', () => {
+  assert.match(GOAL_INBOX_SRC, /getJSON\(`\$\{API\}\/blockers/);
+});
+
+test('goal-inbox.js asks the server for a BOUNDED read and reports the total, not fetch-all-then-slice', () => {
+  // The "Home bounded reads" rule this module's own CLAUDE.md names: a capped
+  // Home card must ask for exactly what it shows and get a total back, never
+  // download the whole feed and .slice() it client-side.
+  assert.match(GOAL_INBOX_SRC, /\/blockers\?limit=\$\{MAX_BLOCKER_ROWS\}/);
+  assert.match(GOAL_INBOX_SRC, /data\.page\.total/);
+});
+
+test('goal-inbox.js renders blocker rows through the SHARED lib, not a re-implementation', () => {
+  assert.match(GOAL_INBOX_SRC, /window\.OTBBlockersLib/);
+  assert.match(GOAL_INBOX_SRC, /lib\.blockerFacts\(/);
+});
+
+test('the blocker row carries .ginbox__item, so the card\'s count-pill and visibility include it', () => {
+  assert.match(GOAL_INBOX_SRC, /function blockerRowHtml[\s\S]*?class="ginbox__item"/);
+});
+
+test('the mount() boot sequence actually calls loadBlockers()', () => {
+  assert.match(GOAL_INBOX_SRC, /loadNodQueue\(\);\s*\n\s*loadBlockers\(\);\s*\n\s*loadRot\(\);/);
+});
+
+// ---- the full queue page (blockers.html + blockers.js) ---------------------
+
+test('blockers.js reads the real GET /blockers route, not a stand-in', () => {
+  assert.match(BLOCKERS_JS_SRC, /API \+ '\/blockers/);
+});
+
+test('blockers.js renders rows through the SAME shared lib the attention slice uses', () => {
+  assert.match(BLOCKERS_JS_SRC, /window\.OTBBlockersLib/);
+  assert.match(BLOCKERS_JS_SRC, /lib\.blockerFacts\(/);
+});
+
+test('blockers.js pages through OTBKit — makePager/paginate/wirePager/pagerBarHtml — not by hand', () => {
+  assert.match(BLOCKERS_JS_SRC, /kit\.makePager\(/);
+  assert.match(BLOCKERS_JS_SRC, /kit\.paginate\(/);
+  assert.match(BLOCKERS_JS_SRC, /kit\.wirePager\(/);
+  assert.match(BLOCKERS_JS_SRC, /kit\.pagerBarHtml\(/);
+  // The negative half: no hand-rolled slice math (start/end arithmetic) sitting
+  // beside the kit call, which is what "paged through OTBKit rather than
+  // hand-rolled" would otherwise silently tolerate.
+  assert.doesNotMatch(BLOCKERS_JS_SRC, /\.slice\(\s*\(?\s*pager\.page/);
+});
+
+test('blockers.html loads blockers-lib.js BEFORE blockers.js', () => {
+  const libAt = BLOCKERS_HTML_SRC.indexOf('src="/builders/blockers-lib.js"');
+  const pageAt = BLOCKERS_HTML_SRC.indexOf('src="/builders/blockers.js"');
+  assert.ok(libAt > -1 && pageAt > -1, 'both scripts must be present');
+  assert.ok(libAt < pageAt, 'blockers.js calls window.OTBBlockersLib at load time');
+});
+
+test('index.html loads blockers-lib.js BEFORE goal-inbox.js', () => {
+  // The literal <script src> attribute, not a bare filename mention — a
+  // surrounding comment is free to name either file in either order (and does:
+  // profile-nudge.js's own comment mentions "goal-inbox.js" ahead of the real
+  // goal-inbox.js <script> tag), so only the src strings say what actually loads
+  // first.
+  const libAt = INDEX_HTML_SRC.indexOf('src="/builders/blockers-lib.js"');
+  const inboxAt = INDEX_HTML_SRC.indexOf('src="/builders/goal-inbox.js');
+  assert.ok(libAt > -1 && inboxAt > -1, 'both scripts must be present');
+  assert.ok(libAt < inboxAt);
+});
+
+test('every title link opens the SAME #/blocker/N overlay task-detail.js already renders', () => {
+  assert.match(GOAL_INBOX_SRC, /`#\/blocker\/\$\{encodeURIComponent\(id\)\}`/);
+  assert.match(BLOCKERS_JS_SRC, /'#\/blocker\/' \+ encodeURIComponent\(id\)/);
+});

package/tests/blockers_lib.mjs

@@ -0,0 +1,102 @@
+// tests/blockers_lib.mjs — the shared blocker-row renderer (blockers-lib.js,
+// task 1003455, goal 1000089).
+//
+// Pins that the lib is genuinely pure (no window.OTB, no DOM) so it loads
+// standalone via require() the way goals-lib.js loads standalone in a vm — and
+// that its output is what both callers (goal-inbox.js's attention-inbox slice,
+// blockers.js's full-queue page) actually depend on: a title link into the
+// EXISTING #/blocker/N overlay (task-detail.js), a quoted note, and a `·`-joined
+// facts line naming which tasks a blocker holds up.
+//
+// Run:  node tests/blockers_lib.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const lib = require('../modules/hall-ui/public/blockers-lib.js');
+
+test('loads standalone via require() — no window, no DOM (Node-require-safe like hall-kit.js)', () => {
+  assert.ok(lib, 'module.exports must be set');
+  for (const k of ['esc', 'fmtDate', 'blockingLine', 'blockerFacts']) {
+    assert.ok(k in lib, `missing export: ${k}`);
+  }
+});
+
+test('blockerFacts: title links into the SAME #/blocker/N overlay task-detail.js renders', () => {
+  const b = { id: 42, title: 'Need the owner’s AWS card on file', created_at: '2026-08-30T00:00:00.000Z', blocking_task_ids: [] };
+  const { titleHtml } = lib.blockerFacts(b, { blockerHref: (id) => `#/blocker/${id}` });
+  assert.match(titleHtml, /href="#\/blocker\/42"/);
+  assert.match(titleHtml, /Need the owner/);
+});
+
+test('blockerFacts: with no blockerHref, the title renders as plain text, not a dead link', () => {
+  const b = { id: 42, title: 'Something stuck', created_at: null, blocking_task_ids: [] };
+  const { titleHtml } = lib.blockerFacts(b);
+  assert.doesNotMatch(titleHtml, /<a /);
+  assert.match(titleHtml, /<span/);
+});
+
+test('blockerFacts: the caller-supplied classes land on the right fragments', () => {
+  const b = { id: 1, title: 'x', body_md: 'a reason', created_at: '2026-08-30T00:00:00.000Z', blocking_task_ids: [] };
+  const { titleHtml, noteHtml, factsHtml } = lib.blockerFacts(b, {
+    titleClass: 'ginbox__goal', noteClass: 'ginbox__note', whenClass: 'ginbox__sub',
+  });
+  assert.match(titleHtml, /class="ginbox__goal"/);
+  assert.match(noteHtml, /class="ginbox__note"/);
+  assert.match(factsHtml, /class="ginbox__sub"/);
+});
+
+test('blockingLine: no linked tasks reads honestly, not as a false "0 tasks"', () => {
+  assert.equal(lib.blockingLine({ blocking_task_ids: [] }, null), 'Blocking nothing yet');
+  assert.equal(lib.blockingLine({}, null), 'Blocking nothing yet');
+});
+
+test('blockingLine: singular/plural noun agreement, and every id becomes a link when taskHref is given', () => {
+  const one = lib.blockingLine({ blocking_task_ids: [5] }, (id) => `/task/${id}`);
+  assert.equal(one, 'Blocking 1 task: <a href="/task/5">#5</a>');
+  const many = lib.blockingLine({ blocking_task_ids: [5, 6] }, (id) => `/task/${id}`);
+  assert.equal(many, 'Blocking 2 tasks: <a href="/task/5">#5</a>, <a href="/task/6">#6</a>');
+});
+
+test('blockingLine: with no taskHref the ids still render, as plain text — never a dead link', () => {
+  const line = lib.blockingLine({ blocking_task_ids: [5] }, null);
+  assert.equal(line, 'Blocking 1 task: #5');
+  assert.doesNotMatch(line, /<a /);
+});
+
+test('blockerFacts: the facts line is ONE `·`-joined span, not several ungapped siblings', () => {
+  // The bug this shape avoids: two adjacent .ginbox__sub spans have no flex gap
+  // between them (unlike .ov-row__facts, which is a flex container) and would
+  // render Filed-date and Blocking-line running together with no separator.
+  const b = { id: 1, title: 'x', created_at: '2026-08-30T00:00:00.000Z', blocking_task_ids: [7] };
+  const { factsHtml } = lib.blockerFacts(b, { taskHref: (id) => `/task/${id}` });
+  assert.equal((factsHtml.match(/<span/g) || []).length, 1, 'exactly one wrapping span');
+  assert.match(factsHtml, /Filed .* · Blocking 1 task/);
+});
+
+test('blockerFacts: body_md becomes a quoted note; an empty one renders nothing', () => {
+  const withNote = lib.blockerFacts({ id: 1, title: 'x', body_md: 'reason', blocking_task_ids: [] });
+  assert.match(withNote.noteHtml, /<p class="ov-row__sub">“reason”<\/p>/);
+  const noNote = lib.blockerFacts({ id: 1, title: 'x', body_md: '   ', blocking_task_ids: [] });
+  assert.equal(noNote.noteHtml, '');
+});
+
+test('blockerFacts: a very long body_md is clipped, so one enormous blocker cannot blow up the row', () => {
+  const long = 'x'.repeat(500);
+  const { noteHtml } = lib.blockerFacts({ id: 1, title: 't', body_md: long, blocking_task_ids: [] });
+  assert.ok(noteHtml.length < 500, 'clipped well below the source length');
+  assert.match(noteHtml, /…”<\/p>$/);
+});
+
+test('blockerFacts: HTML in a title/body/task id is escaped, not injected', () => {
+  const b = {
+    id: 1, title: '<script>alert(1)</script>', body_md: '<img onerror=alert(1)>',
+    created_at: '2026-08-30T00:00:00.000Z', blocking_task_ids: [1],
+  };
+  const { titleHtml, noteHtml, factsHtml } = lib.blockerFacts(b, { taskHref: (id) => `/task/"><script>${id}` });
+  assert.doesNotMatch(titleHtml, /<script>/);
+  assert.doesNotMatch(noteHtml, /<img /);
+  assert.doesNotMatch(factsHtml, /<script>/);
+});

package/tests/hall_nav.mjs

@@ -255,7 +255,10 @@ test('sidebar groups read by audience, in order', () => {
   // (2026-09-09) was to move it: a sitting is work the project does, beside Goals
   // and Tasks, not one of Government's monitoring surfaces. The item is invisible
   // to anyone without the atom, so most builders never see it here.
-  assert.deepEqual(nav[0].items.map((i) => i.id), ['home', 'roadmap', 'goals', 'work', 'board-room', 'ideas', 'copy-desk', 'studio'],
+  // task 1003455 (goal 1000089): 'blockers' joins the same group, after Tasks —
+  // its subject is the project (what's stuck on the owner), not a person or a
+  // craft, and its one data source (GET /blockers) is public like Roadmap's.
+  assert.deepEqual(nav[0].items.map((i) => i.id), ['home', 'roadmap', 'goals', 'work', 'blockers', 'board-room', 'ideas', 'copy-desk', 'studio'],
     'the unlabeled group is the project itself (task 1002425 order)');
   assert.deepEqual(nav[1].items.map((i) => i.id), ['standing', 'profile'], 'You = your own numbers');
   // People (task 1002577): the /scouting directory graduated into the hall.

package/tests/hall_page_gate_map.mjs

@@ -129,6 +129,14 @@ const ORACLE = {
   '/builders/drachmae': null,
   '/builders/profile': null,
 
+  // task 1003455: the blocker queue. GET /blockers is deliberately public (the
+  // status dashboard is meant to read it too — "anyone landing on /builders or
+  // the status dashboard can see what's stuck on the owner", the route's own
+  // handler comment), so the page must not be gated tighter than the API it
+  // fronts — the same rule that puts /roster and /drachmae here. The nav link
+  // is still cosmetically 'signed', same as those two.
+  '/builders/blockers': null,
+
   // The bare detail slugs, gated by task 1003629 — the decision idea 1000907
   // (task 1003448) asked for. They resolve to the same task.html / idea.html
   // shells their /:id forms do, so they now sit on the same tier: the id-less

package/tests/join_dark_matter.mjs

@@ -0,0 +1,208 @@
+// tests/join_dark_matter.mjs — the hub's join relay refuses a project the platform's own
+// record says is unpublished, before it relays anything (task 1003578, ADR 0247 D4).
+//
+// TWO HALVES.
+//
+//   Part A — the provider: `provisioning.projectPublishIdentity` reads the provisioning row
+//   (the one LIVE copy of a control-plane project's description) keyed on BOTH halves of the
+//   ADR 0246 projection, and maps slug → name so the hub's gate never learns this schema.
+//
+//   Part B — the real POST /my-projects/join with the port scripted. Only a positive
+//   "unpublished" verdict refuses. No port, no row (a self-hosted or hand-seeded project),
+//   or a failed read is NO verdict, and the request is relayed exactly as before — the
+//   project's own door still decides, and the hub grants nothing by relaying.
+//
+// DB-free. Run:  node --test tests/join_dark_matter.mjs
+
+import assert from 'node:assert/strict';
+import { test, before, after } from 'node:test';
+import http from 'node:http';
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+
+// ESM import so the knip ratchet credits the exports this file consumes
+// (a createRequire() import does not credit a CJS export).
+import { projectPublishIdentity, registerProvisioningSeams } from '../modules/provisioning/seams.js';
+
+const require = createRequire(import.meta.url);
+const express = require('express');
+
+const PORT_NAME = 'provisioning.projectPublishIdentity';
+
+// ── the doorway, with the port scripted ──────────────────────────────────────
+
+let portMode = 'present';        // 'present' | 'absent' | 'throws'
+let identity = null;             // what the port answers
+let portCalls = [];
+let fetches = [];
+let echoWrites = 0;
+
+const pool = {
+  query: async (text, params = []) => {
+    const sql = String(text).replace(/\s+/g, ' ').trim();
+    if (/FROM platform_identity_sso_clients WHERE origin = \$1 AND status = 'active'/.test(sql)) {
+      return { rows: params[0] === 'https://Target.example'
+        ? [{ client_id: 'proj-open', name: 'Target', origin: 'https://Target.example', status: 'active' }]
+        : [] };
+    }
+    if (/^INSERT INTO platform_identity_application_echoes/.test(sql)) { echoWrites++; return { rows: [] }; }
+    throw new Error(`fake pool: unsupported statement — ${sql}`);
+  },
+};
+
+const apiPath = require.resolve('../src/module-api.js');
+const realApi = require(apiPath);
+require.cache[apiPath].exports = {
+  ...realApi,
+  pool,
+  logger: () => ({ error() {}, warn() {}, info() {}, debug() {} }),
+  requireBuilder: (req, _res, next) => {
+    req.builder = { id: 1, github_id: 4242, github_login: 'octo', display_name: 'Octo' };
+    next();
+  },
+  resolveOptional: (name, fallback = null) => {
+    if (name !== PORT_NAME) return realApi.resolveOptional(name, fallback);
+    if (portMode === 'absent') return fallback;
+    return async (target) => {
+      portCalls.push(target);
+      if (portMode === 'throws') throw new Error('provisioning is down');
+      return identity;
+    };
+  },
+};
+
+const statsPath = require.resolve('../modules/platform-identity/project-stats.js');
+require.cache[statsPath] = {
+  id: statsPath, filename: statsPath, loaded: true,
+  exports: { getProjectStats: async () => ({}) },
+};
+
+const myProjectsRoutes = require('../modules/platform-identity/routes/my-projects.js');
+const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+
+const realFetch = globalThis.fetch;
+globalThis.fetch = async (url) => {
+  fetches.push(String(url));
+  return { status: 201, json: async () => ({ ok: true }) };
+};
+after(() => { globalThis.fetch = realFetch; });
+
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use('/api/bongos', myProjectsRoutes());
+
+let server, port;
+before(async () => {
+  server = http.createServer(app);
+  await new Promise((r) => server.listen(0, '127.0.0.1', r));
+  port = server.address().port;
+});
+after(async () => { await new Promise((r) => server.close(r)); });
+
+function join(origin = 'https://Target.example') {
+  return new Promise((resolve, reject) => {
+    const payload = Buffer.from(JSON.stringify({ origin }));
+    const req = http.request({ host: '127.0.0.1', port, method: 'POST', path: '/api/bongos/my-projects/join',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': payload.length } }, (res) => {
+      let data = '';
+      res.on('data', (c) => { data += c; });
+      res.on('end', () => resolve({ status: res.statusCode, body: data ? JSON.parse(data) : null }));
+    });
+    req.on('error', reject);
+    req.end(payload);
+  });
+}
+
+function reset(mode, answer) {
+  portMode = mode; identity = answer; portCalls = []; fetches = []; echoWrites = 0;
+}
+
+// ── Part A — the provider ────────────────────────────────────────────────────
+
+function recorder(rows = []) {
+  const calls = [];
+  return { calls, query: async (sql, params) => { calls.push({ sql: String(sql).replace(/\s+/g, ' ').trim(), params }); return { rows }; } };
+}
+
+test('projectPublishIdentity asks the provisioning row for BOTH halves of the projection', async () => {
+  const db = recorder([{ slug: 'spike', description: 'A harbour of builders' }]);
+  const got = await projectPublishIdentity(db, { slug: 'spike', host: 'Spike.Example.com' });
+  assert.deepEqual(got, { name: 'spike', description: 'A harbour of builders' },
+    'the slug IS the name on this plane — the mapping stays here, the rule stays in the hub');
+  const [{ sql, params }] = db.calls;
+  assert.match(sql, /FROM provisioning_instances WHERE slug = \$1 AND lower\(domain\) = \$2/);
+  assert.deepEqual(params, ['spike', 'spike.example.com']);
+});
+
+test('projectPublishIdentity answers null — no verdict — when no row carries both halves', async () => {
+  assert.equal(await projectPublishIdentity(recorder([]), { slug: 'spike', host: 'h.test' }), null);
+});
+
+test('projectPublishIdentity never queries for a target that names no project', async () => {
+  for (const target of [{}, { slug: '', host: 'h.test' }, { slug: ['spike'], host: 'h.test' }, undefined]) {
+    const db = recorder([{ slug: 'spike', description: 'x' }]);
+    assert.equal(await projectPublishIdentity(db, target), null, JSON.stringify(target));
+    assert.equal(db.calls.length, 0);
+  }
+});
+
+test('the port is registered once, declared by provisioning, and not required by the hub', () => {
+  registerProvisioningSeams();
+  registerProvisioningSeams();
+  assert.equal(typeof realApi.resolveOptional(PORT_NAME), 'function');
+  const read = (rel) => JSON.parse(readFileSync(new URL(rel, import.meta.url), 'utf8'));
+  assert.ok(read('../modules/provisioning/module.json').provides.includes(PORT_NAME), 'declared');
+  assert.ok(!(read('../modules/platform-identity/module.json').consumes || []).includes(PORT_NAME),
+    'optional — a hub with no provisioning module must still boot and relay');
+});
+
+// ── Part B — the relay ───────────────────────────────────────────────────────
+
+test('an unpublished project is refused at the hub: not_published, no relay, no echo', async () => {
+  reset('present', { name: 'proj-open', description: null });
+  const r = await join();
+  assert.equal(r.status, 200);
+  assert.equal(r.body.status, 'not_published');
+  assert.match(r.body.message, /isn’t published yet/);
+  assert.deepEqual(r.body.project, { name: 'Target', origin: 'https://Target.example' });
+  assert.deepEqual(fetches, [], 'the request never reaches a project with no door');
+  assert.equal(echoWrites, 0, 'a refusal is not an application');
+  assert.deepEqual(portCalls, [{ slug: 'proj-open', host: 'target.example' }],
+    'asked about the client row the relay would have used: client_id + its origin host');
+});
+
+test('a blank description is dark matter too — the gate trims, so the relay does', async () => {
+  reset('present', { name: 'proj-open', description: '   ' });
+  const r = await join();
+  assert.equal(r.body.status, 'not_published');
+  assert.deepEqual(fetches, []);
+});
+
+test('a published project is relayed exactly as before', async () => {
+  reset('present', { name: 'proj-open', description: 'A harbour of builders' });
+  const r = await join();
+  assert.equal(r.body.status, 'requested');
+  assert.equal(fetches.length, 1);
+  assert.equal(echoWrites, 1);
+});
+
+for (const [label, mode, answer] of [
+  ['no provisioning module (no port)', 'absent', null],
+  ['no provisioning row (self-hosted or hand-seeded)', 'present', null],
+  ['a verdict read that fails', 'throws', null],
+]) {
+  test(`${label} is NO verdict: the request is relayed and the project decides`, async () => {
+    reset(mode, answer);
+    const r = await join();
+    assert.equal(r.body.status, 'requested');
+    assert.equal(fetches.length, 1, 'never refused on a guess');
+  });
+}
+
+test('an unknown project is still a 404 and the port is never asked', async () => {
+  reset('present', { name: 'x', description: null });
+  const r = await join('https://nowhere.example');
+  assert.equal(r.status, 404);
+  assert.deepEqual(portCalls, []);
+});

package/tests/projects_hub.mjs

@@ -1950,7 +1950,8 @@ test('the feed carries the owner\'s choice through a seam: platform-identity res
   assert.ok(manifest.provides.includes('provisioning.projectPlanets'), 'the port is declared');
   const pi = JSON.parse(fs.readFileSync(path.join(ROOT, 'modules', 'platform-identity', 'module.json'), 'utf8'));
   assert.ok(!(pi.consumes || []).includes('provisioning.projectPlanets'), 'not a required capability — the hub must boot without provisioning');
-  const prov = fs.readFileSync(path.join(ROOT, 'modules', 'provisioning', 'routes', 'provisioning.js'), 'utf8');
+  // the registrations moved to seams.js at the routes file's size ratchet (task 1003578)
+  const prov = fs.readFileSync(path.join(ROOT, 'modules', 'provisioning', 'seams.js'), 'utf8');
   assert.match(prov, /api\.registerProvider\('provisioning\.projectPlanets', \(hosts\) => provisioning\.planetChoicesForHosts\(pool, hosts\)\);/, 'registered beside instanceState');
 });