@bongos/core 1.19.773 → 1.19.775

package/tests/provisioning_module_selection.mjs

@@ -235,12 +235,12 @@ await ta('POST /instances: the picker\'s ids ride the create request through to
 
   // Act — the body the wizard files
   const res = await post('/provisioning/instances', {
-    slug: 'mercury', hosting_shape: 'standalone', type: 'game', modules: ['dev-box', 'discord'],
+    slug: 'mercury', hosting_shape: 'standalone', type: 'game', modules: ['agents', 'discord'],
   });
 
   // Assert
   assert.equal(res.status, 201, `expected 201, got ${res.status} ${res.raw}`);
-  assert.deepEqual(lastCreateArgs && lastCreateArgs.modules, ['dev-box', 'discord']);
+  assert.deepEqual(lastCreateArgs && lastCreateArgs.modules, ['agents', 'discord']);
 });
 
 await ta('POST /instances: an omitted modules key is still a valid create — skipping is supported, not an error', async () => {
@@ -324,17 +324,17 @@ await ta('PATCH /detail: the reply carries modules, resolved from the row the UP
   detailRow = { id: 41, owner_builder_id: 7, slug: 'mercury', status: 'active', type: 'game', modules: null, detail: {} };
   lastUpdatedRow = null;
 
-  // Act — the owner says they are building it alone
-  const res = await patch('/provisioning/instances/41/detail', { detail: { team_shape: 'solo' } });
+  // Act — the owner says an open community is building it
+  const res = await patch('/provisioning/instances/41/detail', { detail: { team_shape: 'community' } });
 
   // Assert — the field is there, and it is the POST-patch resolution: a route
-  // that answered off `inst` instead of `updated` would still say 'dev-box'.
+  // that answered off `inst` instead of `updated` would still omit 'discord'.
   assert.equal(res.status, 200, res.raw);
   assert.ok(lastUpdatedRow, 'the route ran the update');
   assert.deepEqual(res.body.modules, effectiveModules(lastUpdatedRow));
-  assert.deepEqual(res.body.modules.selected, ['discord'], 'solo drops the shared dev box out of the game bundle');
+  assert.deepEqual(res.body.modules.selected, ['discord'], 'community keeps the gathering place in the game bundle');
   assert.equal(res.body.modules.source, 'bundle');
-  assert.ok(res.body.modules.adjustments.some((a) => a.module === 'dev-box'), 'and the change carries its reason');
+  assert.deepEqual(res.body.modules.adjustments, [], 'the game bundle already carried it, so nothing is claimed');
   detailRow = null; lastUpdatedRow = null;
 });
 
@@ -387,14 +387,14 @@ await ta('PATCH /detail: an owner who skipped the picker can add one module late
 await ta('PATCH /detail: a module can be REMOVED later too — the list replaces, it never merges', async () => {
   // The half a merging write would make impossible, which is why
   // updateInstanceDetail replaces `modules` and merges `detail`.
-  detailRow = { id: 41, owner_builder_id: 7, slug: 'mercury', status: 'active', type: 'game', modules: ['dev-box', 'discord'], detail: {} };
+  detailRow = { id: 41, owner_builder_id: 7, slug: 'mercury', status: 'active', type: 'game', modules: ['agents', 'discord'], detail: {} };
   lastUpdatedRow = null;
 
   const res = await patch('/provisioning/instances/41/detail', { modules: ['discord'] });
 
   assert.equal(res.status, 200, res.raw);
   assert.deepEqual(lastUpdatedRow.modules, ['discord']);
-  assert.deepEqual(res.body.modules.selected, ['discord'], 'dev-box is gone, not still merged in');
+  assert.deepEqual(res.body.modules.selected, ['discord'], 'agents is gone, not still merged in');
   assert.equal(res.body.modules.source, 'chosen');
   detailRow = null; lastUpdatedRow = null;
 });
@@ -517,17 +517,17 @@ await ta('PATCH /detail: another builder’s project is a 404, not a module chan
 // — not merely "close to one".
 
 await ta('PATCH /detail: answer then CLEAR — the row reads back exactly as one that was never asked', async () => {
-  // Arrange — a game project that skipped the picker, so its modules resolve from
+  // Arrange — a research project that skipped the picker, so its modules resolve from
   // the bundle and the interview answer is the only thing that can move them.
-  const virgin = { id: 41, owner_builder_id: 7, slug: 'mercury', status: 'active', type: 'game', modules: null, detail: {} };
+  const virgin = { id: 41, owner_builder_id: 7, slug: 'mercury', status: 'active', type: 'research', modules: null, detail: {} };
   const neverAnswered = effectiveModules(virgin);
   assert.equal(neverAnswered.source, 'bundle', 'the fixture really is an unanswered project');
 
   detailRow = { ...virgin };
   lastUpdatedRow = null;
-  const answered = await patch('/provisioning/instances/41/detail', { detail: { team_shape: 'solo' } });
+  const answered = await patch('/provisioning/instances/41/detail', { detail: { team_shape: 'community' } });
   assert.equal(answered.status, 200, answered.raw);
-  assert.deepEqual(answered.body.detail, { team_shape: 'solo' });
+  assert.deepEqual(answered.body.detail, { team_shape: 'community' });
   assert.notDeepEqual(answered.body.modules.selected, neverAnswered.selected,
     'the fixture is only meaningful if the answer really moved the bundle');
 
@@ -543,7 +543,7 @@ await ta('PATCH /detail: answer then CLEAR — the row reads back exactly as one
   assert.deepEqual(cleared.body.detail, {}, 'and the read surface says the interview is unanswered');
   assert.deepEqual(cleared.body.modules, neverAnswered, 'source, preset and adjustments are the never-answered ones');
   assert.equal(cleared.body.modules.source, 'bundle');
-  assert.deepEqual(cleared.body.modules.selected, bundleForProjectType('game').bundle, 'the UNADJUSTED preset');
+  assert.deepEqual(cleared.body.modules.selected, bundleForProjectType('research').bundle, 'the UNADJUSTED preset');
   assert.deepEqual(cleared.body.modules.adjustments, [], 'no rule fired, so nothing claims to have');
   assert.deepEqual(cleared.body.publish, answered.body.publish, 'clearing an answer is not a publish change');
   detailRow = null; lastUpdatedRow = null;

package/tests/provisioning_recommendations.mjs

@@ -101,42 +101,34 @@ test('an open community adds somewhere to gather to a bundle that lacks one', ()
   assert.ok(recs.bundle.adjustments[0].reason.length > 0, 'an adjustment always says why');
 });
 
-test('a small team adds the shared build environment', () => {
-  // Arrange
-  const answers = { type: 'research', team_shape: 'small-team' };
-
-  // Act
-  const recs = recommendationsForDetails(answers);
-
-  // Assert
-  assert.deepEqual(recs.bundle.bundle, ['agents', 'dev-box']);
-  assert.deepEqual(recs.bundle.adjustments.map((a) => a.module), ['dev-box']);
-});
-
-test('a solo builder drops the shared build environment from the bundle', () => {
-  // Arrange — the business bundle is `agents` + `dev-box`, so the removal bites.
-  const answers = { type: 'business', team_shape: 'solo' };
+test('a community adds the gathering place to a bundle that lacks it', () => {
+  // The surviving bundle rule's ADD path. The two rules that added and removed
+  // `dev-box` by team shape went with the module (task 1003886), which leaves
+  // `effect: 'remove'` declared in adjustBundle but named by no live rule - it is
+  // kept for the next rule that needs it, not because anything exercises it today.
+  // Arrange - the research bundle is `agents` alone, so the addition bites.
+  const answers = { type: 'research', team_shape: 'community' };
 
   // Act
   const recs = recommendationsForDetails(answers);
 
   // Assert
-  assert.deepEqual(recs.bundle.bundle, ['agents']);
-  assert.equal(recs.bundle.adjustments.length, 1);
-  assert.equal(recs.bundle.adjustments[0].effect, 'remove');
-  assert.equal(recs.bundle.adjustments[0].module, 'dev-box');
+  assert.deepEqual(recs.bundle.bundle, ['agents', 'discord']);
+  assert.deepEqual(recs.bundle.adjustments.map((a) => a.module), ['discord']);
+  assert.equal(recs.bundle.adjustments[0].effect, 'add');
 });
 
 test('a rule does not fire for a team shape it does not name', () => {
-  // Arrange — `solo` removes dev-box; `community` must leave it exactly alone.
-  const answers = { type: 'business', team_shape: 'community' };
+  // Arrange - `community` adds discord; `solo` names no rule, so the business
+  // bundle must come back exactly as declared.
+  const answers = { type: 'business', team_shape: 'solo' };
 
   // Act
   const recs = recommendationsForDetails(answers);
 
   // Assert
-  assert.ok(recs.bundle.bundle.includes('dev-box'), 'the solo removal did not leak onto another shape');
-  assert.deepEqual(recs.bundle.adjustments.map((a) => a.rule), ['a-community-needs-somewhere-to-gather']);
+  assert.deepEqual(recs.bundle.bundle, ['agents'], 'the community addition did not leak onto another shape');
+  assert.deepEqual(recs.bundle.adjustments, [], 'and nothing is claimed');
 });
 
 test('a rule whose module the bundle already carries records no adjustment', () => {
@@ -304,8 +296,8 @@ test('a caller may mutate the result without corrupting the declaration', () =>
 
   // Assert
   const second = recommendationsForDetails({ type: 'game', team_shape: 'small-team' });
-  assert.deepEqual(second.bundle.bundle, ['dev-box', 'discord']);
-  assert.deepEqual(second.bundle.modules, [...ALWAYS_ON_CORE, 'dev-box', 'discord']);
+  assert.deepEqual(second.bundle.bundle, ['discord']);
+  assert.deepEqual(second.bundle.modules, [...ALWAYS_ON_CORE, 'discord']);
   assert.equal(second.invites.seeking.limit, 3);
 });
 

package/tests/provisioning_restart.mjs

@@ -56,11 +56,11 @@ t("INTENT_ACTIONS includes 'restart', in lockstep with the provisioning_011 CHEC
   const sql = readFileSync(new URL('../modules/provisioning/migrations/provisioning_011_restart.sql', import.meta.url), 'utf8');
   const m = /CHECK \(action IN \(([^)]*)\)\)/.exec(sql);
   assert.ok(m, 'the migration widens the action CHECK');
-  const inSql = m[1].split(',').map((s) => s.trim().replace(/^'|'$/g, '')).sort();
-  // The NEWEST migration owns the strict set equality — the CHECK a live DB
-  // ends up with is the last one applied, so this is the assertion that would
-  // catch an action added in code but never admitted by the schema.
-  assert.deepEqual(inSql, [...provisioning.INTENT_ACTIONS].sort(), 'the CHECK and INTENT_ACTIONS carry the same set');
+  const inSql = m[1].split(',').map((s) => s.trim().replace(/^'|'$/g, ''));
+  assert.ok(inSql.includes('restart'), 'this migration is the one that admitted it');
+  // The NEWEST action migration owns the strict set equality (provisioning_016,
+  // tests/provisioning_disconnect.mjs); an older one is a prefix of the set.
+  for (const a of inSql) assert.ok(provisioning.INTENT_ACTIONS.includes(a), `${a} is still an INTENT_ACTION`);
   assert.match(sql, /INSERT INTO schema_migrations \(version\) VALUES \('provisioning_011_restart'\)/, 'self-registers');
 });
 

package/tests/provisioning_starter_bundles.mjs

@@ -37,6 +37,7 @@ import {
   OPTIONAL_MODULES,
   STARTER_BUNDLES,
   HUB_ONLY_MODULES,
+  RETIRED_MODULES,
   RULED_TEAM_SHAPES,
   bundleForProjectType,
   allStarterBundles,
@@ -335,6 +336,9 @@ test('the opt-in catalog declared for the picker IS the on-disk opt-in set', ()
   const onDisk = manifestsOnDisk();
   const optInOnDisk = [...onDisk.values()]
     .filter((m) => m.default !== true && !HUB_ONLY_MODULES.includes(m.key))
+    // A RETIRED module is still on disk while its removal lands, and must already
+    // be gone from the catalog — so it is the one permitted absence (task 1003886).
+    .filter((m) => !RETIRED_MODULES.includes(m.key))
     .map((m) => m.key)
     .sort();
 
@@ -346,6 +350,24 @@ test('the opt-in catalog declared for the picker IS the on-disk opt-in set', ()
     'the picker\'s catalog has drifted from the manifests — a module was added, removed, or flipped its default');
 });
 
+test('a RETIRED module is withdrawn everywhere an owner could still reach it', () => {
+  // The retirement is only real if it holds at every offer point at once. A key
+  // left in any one of them is still a module a new project can end up with,
+  // which is exactly what the withdrawal exists to stop (task 1003886).
+  for (const key of RETIRED_MODULES) {
+    assert.ok(!OPTIONAL_MODULES.some((m) => m.key === key),
+      `retired module "${key}" is still a row the creation picker offers`);
+    for (const [type, bundle] of Object.entries(STARTER_BUNDLES)) {
+      assert.ok(!bundle.modules.includes(key),
+        `retired module "${key}" is still preselected by the "${type}" bundle`);
+    }
+    // Posting it directly is a real answer that resolves to nothing, not a
+    // non-answer: the key is DROPPED, exactly as an unknown one would be.
+    assert.deepEqual(normalizeModuleSelection([key]), [],
+      `retired module "${key}" is still accepted when an owner posts it directly`);
+  }
+});
+
 test('every opt-in module carries owner-facing copy, and no module jargon rides along', () => {
   for (const row of OPTIONAL_MODULES) {
     assert.ok(row.label && row.label.length <= 40, `"${row.key}" needs a short label`);
@@ -411,24 +433,24 @@ test('effectiveModules: an answered picker wins over the bundle, including "none
 });
 
 test('effectiveModules: a skipped picker after an ANSWERED interview yields the TAILORED bundle', () => {
-  // BV1.R22 / ADR 0243 — the property ADR 0240 §2 leans the skip on ("the
+  // BV1.R22 / ADR 0243 — the property ADR 0240 leans the skip on ("the
   // preselect and the fallback are the same declaration"), now that the panel
   // preselects the team-shape-adjusted set. Without this the picker would show a
-  // solo owner one thing and the project would quietly get another.
-  const eff = effectiveModules({ type: 'game', modules: null, detail: { team_shape: 'solo' } });
+  // community owner one thing and the project would quietly get another.
+  const eff = effectiveModules({ type: 'research', modules: null, detail: { team_shape: 'community' } });
 
-  assert.deepEqual(eff.selected, ['discord'], 'the shared environment the rule removes is not silently restored');
+  assert.deepEqual(eff.selected, ['agents', 'discord'], 'the gathering place the rule adds is really there');
   assert.equal(eff.source, 'bundle', 'and it is still an UNANSWERED set, not a stored one');
-  assert.deepEqual(eff.adjustments.map((a) => a.module), ['dev-box']);
-  assert.match(eff.adjustments[0].reason, /building this alone/, 'carrying the reason the panel showed');
+  assert.deepEqual(eff.adjustments.map((a) => a.module), ['discord']);
+  assert.match(eff.adjustments[0].reason, /open community/, 'carrying the reason the panel showed');
 });
 
 test("effectiveModules: the owner's own answer is never re-adjusted by a rule", () => {
   // A rule corrects a PRESELECT the owner did not make. Once they have toggled,
   // re-applying it would overrule them with an answer they had already refused.
-  const eff = effectiveModules({ type: 'game', modules: ['dev-box'], detail: { team_shape: 'solo' } });
+  const eff = effectiveModules({ type: 'research', modules: [], detail: { team_shape: 'community' } });
 
-  assert.deepEqual(eff.selected, ['dev-box'], 'solo removes dev-box, and the owner put it back');
+  assert.deepEqual(eff.selected, [], 'community adds discord, and the owner switched everything off');
   assert.equal(eff.source, 'chosen');
   assert.deepEqual(eff.adjustments, [], 'and no reason is handed back for a choice they made themselves');
 });
@@ -439,7 +461,7 @@ test('effectiveModules: a detail that says nothing usable adjusts nothing', () =
   // importing it.
   for (const detail of [undefined, null, {}, { team_shape: null }, { team_shape: 'a-huge-corporation' }, 'not-an-object', []]) {
     const eff = effectiveModules({ type: 'game', modules: null, detail });
-    assert.deepEqual(eff.selected, ['dev-box', 'discord'], `detail=${JSON.stringify(detail)} falls back to the type's bundle`);
+    assert.deepEqual(eff.selected, ['discord'], `detail=${JSON.stringify(detail)} falls back to the type's bundle`);
     assert.deepEqual(eff.adjustments, []);
   }
 });

package/tests/public_landing_projects.mjs

@@ -138,7 +138,8 @@ test('the delete section is served live, and never claims to erase (task 1003042
   assert.match(body, /id="mDelWhat"/, 'the teardown-vs-delete fold is served');
   assert.match(body, /does <b>not<\/b> erase the project/i,
     'the distinction survives to the wire, not just the source');
-  assert.match(body, /no permanent-delete button/i, 'the absent capability is admitted');
+  assert.match(body, /use <b>Disconnect from Bongos entirely<\/b> below/, 'the true delete is its own card (task 1003249), and the fold says where');
+  assert.match(body, /id="mDisconnect"/, 'and that card is served');
   // the confirmation asks for the project's own name — the heaviest gate on the page
   assert.match(body, /Type the project’s name to confirm/, 'the typed confirmation is served');
   assert.match(body, /data-del-yes disabled/, 'and the act starts unreachable');
@@ -146,8 +147,8 @@ test('the delete section is served live, and never claims to erase (task 1003042
 
 test('the served teardown copy no longer claims the address goes quiet (task 1003042)', async () => {
   const { body } = await request('/projects', 'game.test.local');
-  // teardown has no DNS or Caddy leg: the hostname keeps resolving and 502s, so
-  // this sentence was false on the wire. Task 1002897 owns actually releasing it.
+  // teardown parks the hostname and removes its Caddy block (task 1002897) but
+  // keeps the address for a revive, so "reserved" stays and "goes quiet" never did.
   assert.doesNotMatch(body, /the address stops answering/,
     'no served copy may promise a silence the runner does not deliver');
   assert.match(body, /stays reserved for this project/,

package/tests/render_prefs.mjs

@@ -118,5 +118,157 @@ t('describeForApi reflects an explicit OFF override', () => {
   assert.equal(d.override, false);
 });
 
+// ---- the card-richness ladder (task 1002518) --------------------------------
+// The boolean became four rungs, and the rung a builder gets with no override is
+// DERIVED from their interaction profile. These pin both halves, plus the
+// compatibility surface every pinned CLI still reads.
+
+console.log('\nthe ladder:');
+
+t('LEVELS is ordered least → most rich, and rank follows the order', () => {
+  assert.deepEqual(r.LEVELS, ['minimal', 'text', 'standard', 'rich']);
+  assert.ok(r.levelRank('minimal') < r.levelRank('text'));
+  assert.ok(r.levelRank('text') < r.levelRank('standard'));
+  assert.ok(r.levelRank('standard') < r.levelRank('rich'));
+});
+
+t('the predicates say what each rung draws', () => {
+  // minimal: nothing but the confirmation line.
+  assert.equal(r.showsCard('minimal'), false);
+  assert.equal(r.showsWidget('minimal'), false);
+  // text: the monospace card, no HTML.
+  assert.equal(r.showsCard('text'), true);
+  assert.equal(r.showsWidget('text'), false);
+  // standard: the widget, summary folded.
+  assert.equal(r.showsWidget('standard'), true);
+  assert.equal(r.widgetExpanded('standard'), false);
+  // rich: the widget, summary open.
+  assert.equal(r.showsWidget('rich'), true);
+  assert.equal(r.widgetExpanded('rich'), true);
+});
+
+t('cardFlags bundles the three answers a card emitter needs', () => {
+  assert.deepEqual(r.cardFlags('rich'), { level: 'rich', showCard: true, showWidget: true, expanded: true });
+  assert.deepEqual(r.cardFlags('minimal'), { level: 'minimal', showCard: false, showWidget: false, expanded: false });
+});
+
+t('an unknown level rank-resolves to standard rather than throwing', () => {
+  // Defensive: a level string from an instance ahead of this code must degrade,
+  // not crash a ship. standard is the historical default rendering.
+  assert.equal(r.levelRank('nonsense'), r.levelRank('standard'));
+});
+
+console.log('\nderivation from the interaction profile:');
+
+const withProfile = (interaction) => ({ interaction });
+
+t('the DEFAULT builder (non-technical, concise) derives the RICHEST card', () => {
+  // The point of the task: the reader who most needs explanation, and who by
+  // definition never opened Settings, must not get the terser card.
+  assert.equal(r.derivedLevel({}), 'rich');
+  assert.equal(r.derivedLevel(null), 'rich');
+  assert.equal(r.resolveLevel({}), 'rich');
+});
+
+t('technical_level is the primary axis', () => {
+  assert.equal(r.derivedLevel(withProfile({ technical_level: 'non_technical' })), 'rich');
+  assert.equal(r.derivedLevel(withProfile({ technical_level: 'mixed' })), 'standard');
+  assert.equal(r.derivedLevel(withProfile({ technical_level: 'engineer' })), 'text');
+});
+
+t('machinery:quiet drops a rung — an expert who asked for less gets terse or none', () => {
+  assert.equal(r.derivedLevel(withProfile({ technical_level: 'engineer', machinery: 'quiet' })), 'minimal');
+  assert.equal(r.derivedLevel(withProfile({ technical_level: 'non_technical', machinery: 'quiet' })), 'standard');
+});
+
+t('verbosity:detailed raises a rung', () => {
+  assert.equal(r.derivedLevel(withProfile({ technical_level: 'engineer', verbosity: 'detailed' })), 'standard');
+});
+
+t('verbosity:concise does NOT drop a rung (it is the default — see the derivation note)', () => {
+  // Taxing the default would push the accessible-by-default builder from rich
+  // down to standard, inverting the whole point of deriving from the profile.
+  assert.equal(
+    r.derivedLevel(withProfile({ technical_level: 'non_technical', verbosity: 'concise' })),
+    r.derivedLevel(withProfile({ technical_level: 'non_technical' })),
+  );
+});
+
+t('the ladder clamps at both ends', () => {
+  // non_technical (rich) + detailed would be rank 4; engineer (text) + quiet
+  // twice over would go below 0. Neither may fall off the ladder.
+  assert.equal(r.derivedLevel(withProfile({ technical_level: 'non_technical', verbosity: 'detailed' })), 'rich');
+  assert.equal(r.derivedLevel(withProfile({ technical_level: 'engineer', machinery: 'quiet', verbosity: 'concise' })), 'minimal');
+});
+
+t('derivedReason names the fields that actually moved the level', () => {
+  const plain = r.derivedReason({});
+  assert.match(plain, /technical level: non-technical/);
+  assert.ok(!/machinery/.test(plain), 'a default field is not listed as a reason');
+  const quiet = r.derivedReason(withProfile({ technical_level: 'engineer', machinery: 'quiet' }));
+  assert.match(quiet, /machinery: quiet/);
+});
+
+console.log('\noverrides beat derivation:');
+
+t('an explicit level override wins over the profile', () => {
+  const eng = { interaction: { technical_level: 'engineer' }, widgets: 'rich' };
+  assert.equal(r.derivedLevel(eng), 'text', 'the profile would have said text');
+  assert.equal(r.resolveLevel(eng), 'rich', 'the override wins');
+  assert.equal(r.overrideLevel(eng), 'rich');
+});
+
+t('clearing the override falls back to the derived level', () => {
+  const cleared = r.applyPatch({ widgets: 'minimal', interaction: { technical_level: 'mixed' } }, { widgets: null });
+  assert.ok(!('widgets' in cleared));
+  assert.equal(r.resolveLevel(cleared), 'standard', 'back to what the profile says');
+  assert.equal(r.overrideLevel(cleared), null);
+});
+
+console.log('\nlegacy boolean compatibility (a pinned CLI / an older hall build):');
+
+t('a stored legacy boolean keeps the exact card it always meant', () => {
+  assert.equal(r.overrideLevel({ widgets: true }), 'standard');
+  assert.equal(r.overrideLevel({ widgets: false }), 'text');
+  // And it still beats the profile, because it IS an explicit choice.
+  assert.equal(r.resolveLevel({ widgets: false, interaction: { technical_level: 'non_technical' } }), 'text');
+});
+
+t('validatePatch still accepts booleans, normalising them to a level on the way in', () => {
+  assert.equal(r.validatePatch({ widgets: true }).patch.widgets, 'standard');
+  assert.equal(r.validatePatch({ widgets: false }).patch.widgets, 'text');
+});
+
+t('validatePatch accepts every level and rejects a non-level string', () => {
+  for (const lvl of r.LEVELS) {
+    assert.equal(r.validatePatch({ widgets: lvl }).ok, true, `accept ${lvl}`);
+  }
+  const bad = r.validatePatch({ widgets: 'verbose' });
+  assert.equal(bad.ok, false);
+  assert.equal(bad.errors[0].error, 'invalid_value');
+});
+
+t('widgetsEnabled — the boolean every pinned CLI reads — tracks the ladder', () => {
+  assert.equal(r.widgetsEnabled({ widgets: 'minimal' }), false);
+  assert.equal(r.widgetsEnabled({ widgets: 'text' }), false);
+  assert.equal(r.widgetsEnabled({ widgets: 'standard' }), true);
+  assert.equal(r.widgetsEnabled({ widgets: 'rich' }), true);
+});
+
+t('describeForApi keeps the legacy keys AND adds the ladder', () => {
+  const d = r.describeForApi({ interaction: { technical_level: 'engineer' } });
+  // legacy half — an older CLI reads only these and is correct
+  assert.equal(d.widgets_enabled, false, 'engineer derives text, so no widget');
+  assert.equal(d.default_enabled, true);
+  assert.equal(d.override, null, 'derived, not chosen');
+  // ladder half
+  assert.equal(d.level, 'text');
+  assert.equal(d.derived_level, 'text');
+  assert.equal(d.override_level, null);
+  assert.match(d.derived_reason, /technical level: engineer/);
+  assert.deepEqual(d.levels.map((l) => l.value), r.LEVELS);
+  assert.ok(d.levels.every((l) => l.label && l.blurb), 'every rung is labelled for the UI');
+});
+
 console.log(`\n${passed} passed, ${failed} failed`);
 process.exit(failed === 0 ? 0 : 1);