@bongos/core 1.19.528 → 1.19.530

package/modules/provisioning/starter-bundles.js

@@ -106,6 +106,60 @@ const OPTIONAL_MODULES = Object.freeze([
 // so the declaration above stays the single place a choice is written down.
 const OPTIONAL_MODULE_KEYS = Object.freeze(OPTIONAL_MODULES.map((m) => m.key));
 
+// How the interview's team-shape answer ADJUSTS the type's starter bundle, in
+// application order. Each entry is one condition (`teamShape`) and one effect on
+// ONE opt-in module, carrying the sentence the picker shows when it fires.
+//
+// WHY THE TABLE LIVES HERE and not in recommendations.js beside the governance
+// and invite tables it shipped with (task 1002336, ADR 0239). A bundle adjustment
+// is not advice about the bundle — it IS the bundle, once the owner has answered.
+// `effectiveModules` below is the function ADR 0240 §2 leans the whole skip
+// contract on ("the preselect and the fallback are the same declaration — one
+// function, called twice"), and a rule the picker applies but that function does
+// not is exactly two lists kept in agreement by hand. So the rules sit at the
+// bundle layer, `effectiveModules` applies them, and recommendations.js re-exports
+// them unchanged — its governance preview and invite seam are genuinely advice and
+// stay there. Decision: ADR 0243 (BV1.R22, task 1002341).
+//
+// Deliberately tiny: ADR 0237 already made the per-type preset the opinion, and
+// today's opt-in catalog is three modules wide — so this table's job is to correct
+// a preset the owner's answer contradicts, not to re-derive it.
+//
+// A rule may only ever name an OPT-IN module. Adding or removing an always-on one
+// would be a toggle that toggles nothing (ADR 0237 §3's argument, and
+// `tests/provisioning_recommendations.mjs` fails the build over it).
+const TEAM_SHAPE_RULES = Object.freeze([
+  Object.freeze({
+    id: 'a-community-needs-somewhere-to-gather',
+    teamShape: 'community',
+    effect: 'add',
+    module: 'discord',
+    reason: 'You said an open community is building this, so somewhere for it to gather is switched on.',
+  }),
+  Object.freeze({
+    id: 'a-team-shares-one-environment',
+    teamShape: 'small-team',
+    effect: 'add',
+    module: 'dev-box',
+    reason: 'A small team gets one shared environment to build in, so nobody is debugging their own laptop.',
+  }),
+  Object.freeze({
+    id: 'building-alone-needs-no-shared-environment',
+    teamShape: 'solo',
+    effect: 'remove',
+    module: 'dev-box',
+    reason: 'You are building this alone, so the shared cloud environment is off — your own machine is the setup.',
+  }),
+]);
+
+// The team shapes the rules above can fire on. Derived from the table rather than
+// imported from provisioning.js's PROJECT_DETAIL_VOCAB, because importing it would
+// point this file UP at the module that requires it. It costs nothing to derive:
+// an off-vocabulary shape matches no rule and adjusts nothing, which is already
+// the right answer — `tests/provisioning_recommendations.mjs` pins the two lists
+// against each other so a fourth interview answer cannot arrive unhandled.
+const RULED_TEAM_SHAPES = Object.freeze([...new Set(TEAM_SHAPE_RULES.map((r) => r.teamShape))]);
+
 // The curated presets, keyed by the declared project type (the closed vocabulary
 // owner-decided 2026-08-13 and mirrored in provisioning.PROJECT_TYPES + the
 // provisioning_007 CHECK). `label` and `summary` are the owner-facing copy the
@@ -192,6 +246,69 @@ function optionalModules() {
   return OPTIONAL_MODULES.map((m) => ({ ...m }));
 }
 
+// Apply the team-shape rules to one type's opt-in bundle. Returns the adjusted
+// list plus the adjustments that ACTUALLY changed it — a rule whose module the
+// bundle already carries (or already lacks) records nothing, because a stated
+// reason for a change that did not happen is a lie the owner cannot check.
+// A null/unknown/off-vocabulary shape fires no rule and adjusts nothing, which is
+// the same answer `normalizeProjectDetail` gives such a value on the way in.
+// Never touches the always-on core. PURE.
+function adjustBundle(bundle, teamShape) {
+  const held = new Set(bundle);
+  const adjustments = [];
+  for (const rule of TEAM_SHAPE_RULES) {
+    if (rule.teamShape !== teamShape) continue;
+    if (rule.effect === 'add' && !held.has(rule.module)) held.add(rule.module);
+    else if (rule.effect === 'remove' && held.has(rule.module)) held.delete(rule.module);
+    else continue;
+    adjustments.push({ rule: rule.id, effect: rule.effect, module: rule.module, reason: rule.reason });
+  }
+  // CATALOG order, not append order — `normalizeModuleSelection` stores a chosen
+  // set this way and the picker re-derives its toggles this way, so an adjusted
+  // bundle that appended would make the same set of modules read as a different
+  // list depending on whether the owner answered the picker or skipped it.
+  return { modules: OPTIONAL_MODULE_KEYS.filter((k) => held.has(k)), adjustments };
+}
+
+// What the creation flow preselects for one set of ANSWERS — `bundleForProjectType`
+// with the team-shape rules applied, in the same `{ type, label, summary, core,
+// bundle, modules }` shape plus the `adjustments` delta that got it there.
+//
+// This is the single resolver the picker paints from and `effectiveModules` falls
+// back to, so an owner who answers the interview and then skips the picker gets
+// the set the panel was showing them (ADR 0240 §2's property, extended to the
+// interview's answer — BV1.R22, ADR 0243). PURE; arrays are fresh.
+function bundleForAnswers(type, teamShape) {
+  const preset = bundleForProjectType(type);
+  const { modules, adjustments } = adjustBundle(preset.bundle, teamShape);
+  return {
+    ...preset,
+    bundle: modules,
+    modules: [...ALWAYS_ON_CORE, ...modules],
+    adjustments,
+  };
+}
+
+// Every curated bundle resolved for every team shape the rules can fire on, plus
+// the no-answer resolution — the whole preselect table in ONE read.
+//
+// The picker needs this shape rather than a per-answer query because ADR 0240 §4's
+// rule is that what may be chosen and what is preselected have to arrive together
+// or the panel can preselect a key it has no row for. The owner flips the type
+// question and the team-shape question freely on two earlier panels; re-preselecting
+// must not cost a round trip, and a round trip it did pay could land after they had
+// moved on. PURE — five types by four answers is twenty small rows.
+function starterBundleAnswerTable() {
+  return allStarterBundles().map((preset) => {
+    const byTeamShape = {};
+    for (const shape of RULED_TEAM_SHAPES) {
+      const { modules, adjustments } = adjustBundle(preset.bundle, shape);
+      byTeamShape[shape] = { bundle: modules, adjustments };
+    }
+    return { ...preset, byTeamShape };
+  });
+}
+
 // A MODULE SELECTION as it may be STORED (BV1.R20, task 1002339): opt-in keys
 // only, deduped, in catalog order. Everything else is dropped — an always-on
 // module (it was never a choice), a hub-only one (the control plane's own), and
@@ -218,22 +335,39 @@ function normalizeModuleSelection(input) {
 
 // What a row's modules READ as: the always-on floor, plus whatever the owner
 // chose — or, when they never answered, the starter bundle for their declared
-// type. `source` says which of the two it is, so a surface can tell a chosen
-// empty set from an unanswered one without re-deriving the rule.
+// type ADJUSTED by what they told the interview. `source` says which of the two
+// it is, so a surface can tell a chosen empty set from an unanswered one without
+// re-deriving the rule.
 //
 // This is what makes skipping the picker a supported default rather than a
 // project with nothing on it: the flow's preselect and the server's fallback are
 // the SAME declaration, so the owner gets exactly the set the panel showed them.
-// PURE — takes a row-shaped `{ type, modules }`, touches no database.
+// The team-shape adjustment is INSIDE that fallback (BV1.R22, ADR 0243) for
+// exactly that reason — the picker paints the adjusted set, so a picker skipped
+// after an answered interview has to resolve to the adjusted set too, or the
+// panel's promise stops being true the moment the interview is answered.
+//
+// Reads `detail.team_shape` straight off the row rather than through
+// provisioning.js's `normalizeProjectDetail` — importing it would point this file
+// up at the module that requires it, and it would buy nothing: an off-vocabulary
+// shape fires no rule and adjusts nothing, which is the answer the normalizer
+// would have produced anyway.
+//
+// PURE — takes a row-shaped `{ type, modules, detail }`, touches no database.
 function effectiveModules(row) {
   const chosen = normalizeModuleSelection(row && row.modules);
-  const preset = bundleForProjectType(row && row.type);
+  const detail = row && row.detail && typeof row.detail === 'object' ? row.detail : null;
+  const preset = bundleForAnswers(row && row.type, detail ? detail.team_shape : null);
   const selected = chosen === null ? preset.bundle : chosen;
   return {
     core: [...ALWAYS_ON_CORE],
     selected,
     modules: [...ALWAYS_ON_CORE, ...selected],
     source: chosen === null ? 'bundle' : 'chosen',
+    // Why the unanswered set is what it is, in the owner's own words — empty when
+    // nothing adjusted it, and never populated for a `chosen` set, because an
+    // owner's own toggle needs no reason given back to them.
+    adjustments: chosen === null ? preset.adjustments : [],
   };
 }
 
@@ -242,9 +376,14 @@ module.exports = {
   HUB_ONLY_MODULES,
   OPTIONAL_MODULES,
   STARTER_BUNDLES,
+  TEAM_SHAPE_RULES,
+  RULED_TEAM_SHAPES,
   bundleForProjectType,
   allStarterBundles,
   optionalModules,
+  adjustBundle,
+  bundleForAnswers,
+  starterBundleAnswerTable,
   normalizeModuleSelection,
   effectiveModules,
 };

package/modules/public-landing/public/projects.html

@@ -328,6 +328,14 @@ summary{min-height:24px;padding:3px 0;}
 .tpill:hover::before{border-color:var(--ink-faint);}
 .tpill[aria-pressed=true]{background:none;border-color:var(--rule-soft);color:var(--ink);}
 .tpill[aria-pressed=true]::before{background:var(--accent);border-color:var(--accent);outline:4px solid color-mix(in srgb,var(--accent) 22%,transparent);}
+/* Why the picker preselected what it did (task 1002341) — one line per rule that
+   moved something, between the band and the always-on clause. Wears .reassure's
+   weight on purpose: this is the panel explaining itself, never a thing to act on,
+   so it must not compete with the toggles it is explaining. */
+.modWhy{display:none;}
+.modWhy.on{display:grid;gap:6px;margin:0 0 14px;max-width:62ch;}
+.modWhy span{font-size:13.5px;font-weight:400;color:var(--ink-soft);line-height:1.5;}
+
 /* the module picker (task 1002339) wears the SAME band as the type and team
    questions — one hairline cell per choice, the dot on the chosen ones. The only
    difference is that a module carries a one-line summary under its name, so its
@@ -1017,11 +1025,12 @@ summary{min-height:24px;padding:3px 0;}
                to make, when in fact they were never choices. -->
           <section class="panel" id="panel-modules" aria-labelledby="mod-h">
             <h1 id="mod-h">What it comes with</h1>
-            <p class="lede">Optional — skip it and you get the suggested set below. These are extras on top of everything every project already has, and you can switch any of them on or off later.</p>
+            <p class="lede">Optional — skip it and you get the suggested set below, shaped by what you just told us. These are extras on top of everything every project already has, and you can switch any of them on or off later.</p>
             <form data-next="5">
               <div class="wizField"><span id="modLbl">Extras for this project</span>
                 <div class="typeCards" id="modCards" role="group" aria-labelledby="modLbl"></div>
               </div>
+              <div class="modWhy" id="modWhy" aria-live="polite"></div>
               <div class="reassure" id="modCoreNote"></div>
               <div class="hint" id="h-modules">&nbsp;</div>
               <div class="nav">
@@ -3204,10 +3213,39 @@ summary{min-height:24px;padding:3px 0;}
       if (state.step === 4) renderModules();
       else if (state.step === 7) renderReview();
     }
+    /* The row for the declared type, or null before the read lands / for a type
+       the table has no row for (including no type at all). */
+    function bundleRow() {
+      if (!starterBundles) return null;
+      return (starterBundles.bundles || []).filter(function (b) { return b.type === state.projType; })[0] || null;
+    }
+    /* The type's preselect AS THE ABOUT STEP'S ANSWER SHAPES IT (task 1002341,
+       BV1.R22). The server resolved every combination into byTeamShape, so
+       answering "just me" three panels back re-preselects here with no round trip
+       and no rule applied twice in two languages — the wizard reads the same
+       table `effectiveModules` falls back to (ADR 0243).
+
+       An older payload without byTeamShape, or a team shape no rule fires on,
+       falls through to the unadjusted bundle: the answer this panel showed before
+       R22, which is never wrong, only untailored. */
+    function tailoredRow() {
+      var row = bundleRow();
+      if (!row) return null;
+      var forShape = row.byTeamShape && state.teamShape ? row.byTeamShape[state.teamShape] : null;
+      return forShape || { bundle: row.bundle || [], adjustments: [] };
+    }
     function preselectedModules() {
-      if (!starterBundles) return [];
-      var forType = (starterBundles.bundles || []).filter(function (b) { return b.type === state.projType; })[0];
-      return forType ? forType.bundle.slice() : [];
+      var row = tailoredRow();
+      return row ? row.bundle.slice() : [];
+    }
+    /* Why the preselect is what it is, in the owner's own words — one sentence per
+       rule that ACTUALLY moved something. Empty when nothing did, and empty once
+       the owner has answered for themselves: a reason given back for a toggle they
+       flipped reads as the panel arguing with them. */
+    function preselectReasons() {
+      if (state.modules !== null) return [];
+      var row = tailoredRow();
+      return row ? (row.adjustments || []) : [];
     }
     /* What the panel paints and the review names: the owner's answer if they
        gave one, otherwise the type's preselect. */
@@ -3233,6 +3271,8 @@ summary{min-height:24px;padding:3px 0;}
            a moment; only a read that ANSWERED badly gets the clause, so a slow
            network never tells the owner something is broken when it isn't. */
         band.innerHTML = '';
+        $('modWhy').innerHTML = '';
+        $('modWhy').classList.remove('on');
         note.textContent = bundlesFailed
           ? 'We couldn’t load the list of extras just now. Your project is created with everything it needs either way, and you can add extras from its settings.'
           : '';
@@ -3245,6 +3285,17 @@ summary{min-height:24px;padding:3px 0;}
           + (on.indexOf(m.key) === -1 ? 'false' : 'true') + '"><span><b>' + esc(m.label)
           + '</b><small>' + esc(m.summary) + '</small></span></button>';
       }).join('');
+      /* The tailoring, said out loud (task 1002341). A preselect an owner cannot
+         see the reason for is one they have to audit, which is the thing ADR 0237
+         says is worse than no preselect at all. Rendered as its own block above the
+         core clause, because it is about THIS project's answers while the clause
+         below is about every project. */
+      var why = $('modWhy');
+      var reasons = preselectReasons();
+      why.innerHTML = reasons.length
+        ? reasons.map(function (a) { return '<span>' + esc(a.reason) + '</span>'; }).join('')
+        : '';
+      why.classList.toggle('on', reasons.length > 0);
       var core = (starterBundles.core || []).length;
       note.textContent = core
         ? 'Every project also starts with the same ' + core + ' core parts — the platform itself, the way it tracks work, and the builders’ hall. They are always on, so they are not part of this choice.'

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.528",
+  "version": "1.19.530",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.528",
+      "version": "1.19.530",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.528",
+  "version": "1.19.530",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/src/module-api.js

@@ -45,7 +45,7 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.528'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.530'; // 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('dev-box'); log.info('mounted');

package/tests/design_tokens_sync.mjs

@@ -132,7 +132,7 @@ test('the explore page mirrors the pack, var for var', () => {
 
 test('the provisioning onboarding pages resolve their accent pair from branding', () => {
   const source = fs.readFileSync(
-    path.join(REPO_ROOT, 'modules/provisioning/routes/provisioning.js'), 'utf8');
+    path.join(REPO_ROOT, 'modules/provisioning/routes/callback-page.js'), 'utf8');
   assert.match(source, /--sun:\$\{/, '--sun interpolates a resolved value, never a literal');
   assert.match(source, /--sun600:\$\{/, '--sun600 interpolates a resolved value, never a literal');
   const block = source.match(/const ACCENT =[\s\S]*?\}\)\(\);/);

package/tests/projects_hub_module_picker.mjs

@@ -25,6 +25,17 @@ import path from 'node:path';
 import vm from 'node:vm';
 import { fileURLToPath } from 'node:url';
 
+// ESM named imports off the CJS module on purpose (the knip learning): the
+// cross-check test at the bottom runs the REAL declaration the route serves, so a
+// rule change cannot pass this file while breaking the panel.
+import {
+  ALWAYS_ON_CORE,
+  RULED_TEAM_SHAPES,
+  starterBundleAnswerTable,
+  optionalModules,
+  effectiveModules,
+} from '../modules/provisioning/starter-bundles.js';
+
 const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
 const LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
 const HUB = fs.readFileSync(path.join(LANDING, 'projects.html'), 'utf8');
@@ -59,6 +70,39 @@ const PAYLOAD = {
   ],
 };
 
+// The `byTeamShape` half of the same payload (BV1.R22, task 1002341): the bundle
+// re-resolved for each About-step answer, with the adjustments that got it there.
+//
+// Deliberately only TWO types carry it. The rest are left without so the
+// degradation path is exercised by the same fixture — a payload from a server that
+// predates R22, or a team shape no rule fires on, must fall through to the
+// unadjusted bundle rather than preselecting nothing. The real table for every
+// type is pinned against the real module further down ("the picker and the server
+// resolve the same set").
+const TAILORED = {
+  ...PAYLOAD,
+  bundles: PAYLOAD.bundles.map((b) => {
+    if (b.type === 'game') {
+      return { ...b, byTeamShape: {
+        // solo: the shared environment comes off
+        solo: { bundle: ['discord'], adjustments: [{ rule: 'building-alone-needs-no-shared-environment', effect: 'remove', module: 'dev-box', reason: 'You are building this alone, so the shared cloud environment is off.' }] },
+        // small-team: the rule wants dev-box, the bundle already has it — a rule
+        // that changed nothing claims nothing
+        'small-team': { bundle: ['dev-box', 'discord'], adjustments: [] },
+        community: { bundle: ['dev-box', 'discord'], adjustments: [] },
+      } };
+    }
+    if (b.type === 'research') {
+      return { ...b, byTeamShape: {
+        solo: { bundle: ['agents'], adjustments: [] },
+        'small-team': { bundle: ['agents', 'dev-box'], adjustments: [{ rule: 'a-team-shares-one-environment', effect: 'add', module: 'dev-box', reason: 'A small team gets one shared environment to build in.' }] },
+        community: { bundle: ['agents', 'discord'], adjustments: [{ rule: 'a-community-needs-somewhere-to-gather', effect: 'add', module: 'discord', reason: 'You said an open community is building this, so somewhere for it to gather is switched on.' }] },
+      } };
+    }
+    return b;
+  }),
+};
+
 function makeEl(id) {
   const classes = new Set();
   const attrs = new Map();
@@ -88,13 +132,26 @@ function rowsOf(html) {
   return out;
 }
 
+// The reason lines the panel painted, in order (task 1002341). Parsed out of the
+// markup for the same reason rowsOf is: a selector that resolves against markup
+// nobody wrote proves nothing.
+function whyOf(html) {
+  const out = [];
+  const re = /<span>([^<]*)<\/span>/g;
+  let m;
+  while ((m = re.exec(html))) out.push(m[1]);
+  return out;
+}
+
 // Boot the picker with a given draft state. `fetchOk: false` drives the
-// couldn't-load branch. Returns the handles the assertions drive it through.
-function boot({ state: seed = {}, fetchOk = true } = {}) {
+// couldn't-load branch; `payload` swaps in a different server answer (TAILORED
+// carries the R22 byTeamShape half). Returns the handles the assertions drive it
+// through.
+function boot({ state: seed = {}, fetchOk = true, payload = PAYLOAD } = {}) {
   const els = new Map();
   const $ = (id) => { if (!els.has(id)) els.set(id, makeEl(id)); return els.get(id); };
   const form = makeEl('panel-modules-form');
-  const state = { step: 4, projType: null, modules: null, ...seed };
+  const state = { step: 4, projType: null, teamShape: null, modules: null, ...seed };
   const shown = [];
   let saves = 0;
   let fetches = 0;
@@ -112,7 +169,7 @@ function boot({ state: seed = {}, fetchOk = true } = {}) {
     renderReview: () => { reviews++; },
     API: '/api/bongos',
     fetch: () => { fetches++; return Promise.resolve(fetchOk
-      ? { ok: true, json: () => Promise.resolve(PAYLOAD) }
+      ? { ok: true, json: () => Promise.resolve(payload) }
       : { ok: false, json: () => Promise.resolve(null) }); },
     Promise, JSON, Math, Object, Array, String, Number, console,
   };
@@ -134,6 +191,8 @@ function boot({ state: seed = {}, fetchOk = true } = {}) {
     render: () => sandbox.renderModules(),
     open: async function () { sandbox.renderModules(); for (let i = 0; i < 20; i++) await Promise.resolve(); },
     rows: () => rowsOf(band.innerHTML),
+    why: () => whyOf($('modWhy').innerHTML),
+    whyShown: () => $('modWhy').classList.contains('on'),
     coreNote: () => $('modCoreNote').textContent,
     coreShown: () => $('modCoreNote').classList.contains('on'),
     click: (key) => {
@@ -367,3 +426,157 @@ test('the review reads an answered picker back, empty included', async () => {
   await none.settle();
   assert.equal(none.extrasRow(), 'None — just the core', 'a deliberate "none" is stated as one');
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// BV1.R22 (task 1002341) — the About step's answer reaches the preselect, and
+// the panel says why. ADR 0243.
+// ─────────────────────────────────────────────────────────────────────────────
+
+test('the team shape adjusts the type bundle, and the panel says why in the owner\'s words', async () => {
+  // Arrange — "a game", then "just me" one panel later
+  const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: TAILORED });
+
+  // Act
+  await h.open();
+
+  // Assert — the shared environment came off, and the reason is on screen
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['discord'],
+    'solo drops the dev box the game bundle would have preselected');
+  assert.equal(h.whyShown(), true);
+  assert.deepEqual(h.why(), ['You are building this alone, so the shared cloud environment is off.']);
+});
+
+test('a rule that changed nothing claims nothing', async () => {
+  // small-team ADDS dev-box, and the game bundle already carries it. A reason
+  // shown for a change that did not happen is a claim the owner cannot check.
+  const h = boot({ state: { projType: 'game', teamShape: 'small-team' }, payload: TAILORED });
+  await h.open();
+
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['dev-box', 'discord']);
+  assert.deepEqual(h.why(), [], 'no adjustment, no sentence');
+  assert.equal(h.whyShown(), false, 'and no empty block sitting on the panel');
+});
+
+test('an added module is preselected and explained', async () => {
+  const h = boot({ state: { projType: 'research', teamShape: 'community' }, payload: TAILORED });
+  await h.open();
+
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['agents', 'discord']);
+  assert.deepEqual(h.why(), ['You said an open community is building this, so somewhere for it to gather is switched on.']);
+});
+
+test('answering the About step later re-preselects, with no second read', async () => {
+  // The two questions live on two earlier panels and are both changeable. The
+  // whole table arrived in one read precisely so going back costs nothing.
+  const h = boot({ state: { projType: 'research' }, payload: TAILORED });
+  await h.open();
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['agents'], 'unanswered: the raw bundle');
+
+  h.state.teamShape = 'small-team';
+  h.render();
+
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['agents', 'dev-box']);
+  assert.equal(h.fetches(), 1, 'and the answer cost no round trip');
+});
+
+test('Skip after an answered About step still yields the set the panel showed', async () => {
+  // ADR 0240 §2's property, extended to the interview's answer (ADR 0243): the
+  // preselect and the server's fallback are the same declaration, so skipping
+  // must still answer NOTHING and still land the tailored set.
+  const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: TAILORED });
+  await h.open();
+
+  h.skip();
+
+  assert.deepEqual(h.shown, [5]);
+  assert.equal(h.state.modules, null, 'skipping answers nothing, tailored or not');
+  assert.equal(h.forCreate(), undefined, 'so the create request still carries no modules key');
+  assert.deepEqual(h.picked(), ['discord'], 'while the set they were shown is still the set they get');
+});
+
+test('once the owner has answered, the reasons go — the panel stops arguing', async () => {
+  const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: TAILORED });
+  await h.open();
+  assert.equal(h.why().length, 1);
+
+  h.click('dev-box');
+
+  assert.deepEqual(h.state.modules, ['dev-box', 'discord'], 'their toggle stands over the rule');
+  assert.deepEqual(h.why(), [], 'and the rule stops explaining a set that is no longer its own');
+  assert.equal(h.whyShown(), false);
+});
+
+test('a payload with no byTeamShape degrades to the untailored bundle, never to nothing', async () => {
+  // A server that predates R22 still serves `bundles[].bundle`. The panel must
+  // preselect that rather than empty out — untailored is never wrong, only less.
+  const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: PAYLOAD });
+  await h.open();
+
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['dev-box', 'discord']);
+  assert.deepEqual(h.why(), []);
+});
+
+test('an off-vocabulary team shape adjusts nothing', async () => {
+  // A value that was valid when the draft was stored and has since left the
+  // vocabulary reads as no answer, exactly as normalizeProjectDetail drops one.
+  const h = boot({ state: { projType: 'game', teamShape: 'a-huge-corporation' }, payload: TAILORED });
+  await h.open();
+
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['dev-box', 'discord']);
+  assert.deepEqual(h.why(), []);
+});
+
+test('a couldn\'t-load read clears any reasons it had already painted', async () => {
+  const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: TAILORED });
+  await h.open();
+  assert.equal(h.why().length, 1);
+
+  h.sandbox.starterBundles = null;
+  h.render();
+
+  assert.deepEqual(h.why(), [], 'a stale reason for a set no longer on screen is a lie');
+  assert.equal(h.whyShown(), false);
+});
+
+test('a reason goes through the page escaper like every other rendered value', async () => {
+  const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: TAILORED });
+  await h.open();
+  h.sandbox.starterBundles = {
+    core: [], optional: [],
+    bundles: [{ type: 'game', bundle: [], byTeamShape: { solo: { bundle: [], adjustments: [{ reason: '<img src=x onerror=alert(1)>' }] } } }],
+  };
+  h.render();
+
+  const html = h.sandbox.$('modWhy').innerHTML;
+  assert.ok(!html.includes('<img'), 'a hostile reason cannot inject markup');
+  assert.ok(html.includes('&lt;img src=x onerror=alert(1)&gt;'), 'it is shown escaped');
+});
+
+// The pin that makes the two ends of ADR 0243 unable to drift. Everything above
+// runs the picker against a FIXTURE; this one runs it against the REAL payload the
+// route serves, and asserts the panel's preselect is the same set the server would
+// resolve for a row with those answers and a skipped picker. If a rule is ever
+// added, changed or moved, one of these twenty combinations fails here rather than
+// silently handing an owner a project that is not the one they were shown.
+test('the picker and the server resolve the same set for every answer an owner can give', async () => {
+  const LIVE = { core: [...ALWAYS_ON_CORE], bundles: starterBundleAnswerTable(), optional: optionalModules() };
+  const shapes = [null, ...RULED_TEAM_SHAPES];
+
+  for (const preset of LIVE.bundles) {
+    for (const teamShape of shapes) {
+      const h = boot({ state: { projType: preset.type, teamShape }, payload: LIVE });
+      await h.open();
+
+      // what the server gives a project that answered the interview and then
+      // skipped the picker — `modules: null`, resolved at read time
+      const server = effectiveModules({ type: preset.type, modules: null, detail: teamShape ? { team_shape: teamShape } : {} });
+
+      assert.deepEqual(h.picked(), server.selected,
+        `type=${preset.type} team_shape=${teamShape}: the panel preselects what the server resolves`);
+      assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), server.selected,
+        `type=${preset.type} team_shape=${teamShape}: and the toggles show it`);
+      assert.deepEqual(h.why().length, server.adjustments.length,
+        `type=${preset.type} team_shape=${teamShape}: one sentence per adjustment the server made`);
+    }
+  }
+});