@bongos/core 1.25.17 → 1.25.18

package/tests/genesis_work.mjs

@@ -222,10 +222,81 @@ if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
 
   await test('a stage that has not adopted questions still takes a page and a link', async () => {
     const deps = { store: memStore() };
-    const r = await gw.setPage('charter', 'Monarchy to start.', 1, deps);
+    const r = await gw.setPage('legalize', 'Credits only to start.', 1, deps);
     assert.equal(r.work.adopted, false);
-    assert.equal(r.work.page, 'Monarchy to start.');
-    assert.equal((await gw.setAnswer('charter', 'anything', { text: 'x' }, 1, deps)).reason, 'unknown_question');
+    assert.equal(r.work.page, 'Credits only to start.');
+    assert.equal((await gw.setAnswer('legalize', 'anything', { text: 'x' }, 1, deps)).reason, 'unknown_question');
+  });
+
+  // ── the charter stage (task 1005119) ──────────────────────────────────────
+  // A stand-in government port that records what it was handed, so the test sees
+  // exactly which answers reach the recommender.
+  const fakeGov = () => {
+    const calls = [];
+    return { calls, async charterAdvice(input) { calls.push(input); return { charter: { key: 'monarchy' }, input }; } };
+  };
+  const charterDeps = (extra = {}) => ({ store: memStore(), government: fakeGov(), getSetting: async () => null, ...extra });
+
+  await test('charter: a closed answer must be one of its choices, and a label reads back as its key', async () => {
+    const deps = charterDeps();
+    const bad = await gw.setAnswer('charter', 'final_say', { text: 'my cat' }, 1, deps);
+    assert.equal(bad.reason, 'not_a_choice');
+    assert.deepEqual(bad.expected, ['founder', 'trusted', 'everyone', 'council']);
+    const r = await gw.setAnswer('charter', 'final_say', { text: 'Everyone on the project' }, 1, deps);
+    const q = qOf(r, 'final_say');
+    assert.equal(q.answer.text, 'everyone', 'stored as the key');
+    assert.equal(q.answer.choice_label, 'Everyone on the project');
+    assert.ok(q.choices.some((c) => c.key === 'council'), 'the choices ride the view');
+    // prose questions take any words
+    const p = await gw.setAnswer('charter', 'feel', { text: 'Calm and careful.' }, 1, deps);
+    assert.equal(qOf(p, 'feel').answer.text, 'Calm and careful.');
+  });
+
+  await test('charter: every question is skippable and answerable "not sure yet"', async () => {
+    const deps = charterDeps();
+    for (const q of gw.QUESTIONS.charter) {
+      assert.equal((await gw.setAnswer('charter', q.id, { state: 'not_sure' }, 1, deps)).ok, true, q.id);
+      assert.equal((await gw.setAnswer('charter', q.id, { state: 'skipped' }, 1, deps)).ok, true, q.id);
+    }
+  });
+
+  await test('charter: only given answers reach the recommender, closed as keys and prose as words', async () => {
+    const gov = fakeGov();
+    const deps = charterDeps({ government: gov, getSetting: async () => ({ value: JSON.stringify({ expected_builders: 6 }) }) });
+    await gw.setAnswer('charter', 'final_say', { text: 'trusted' }, 1, deps);
+    await gw.setAnswer('charter', 'agreement', { state: 'not_sure' }, 1, deps);
+    await gw.setAnswer('charter', 'speed', { state: 'skipped' }, 1, deps);
+    await gw.setAnswer('charter', 'leave_behaviour', { text: 'Lying about shipped work.' }, 1, deps);
+    const r = await gw.readStage('charter', deps);
+    const last = gov.calls[gov.calls.length - 1];
+    assert.deepEqual(last.answers, { final_say: 'trusted' }, 'not sure yet and skipped are not sent');
+    assert.deepEqual(last.prose, { leave_behaviour: 'Lying about shipped work.' });
+    assert.equal(last.headcount, 6, "the founder's expected headcount from the plan");
+    assert.equal(r.work.advice.charter.key, 'monarchy', 'the advice rides the stage');
+  });
+
+  await test('charter: no government module, or a failing one, still reads the stage (advice null)', async () => {
+    const none = await gw.readStage('charter', charterDeps({ government: null }));
+    assert.equal(none.ok, true);
+    assert.equal(none.work.advice, null);
+    const broken = await gw.readStage('charter', charterDeps({ government: { charterAdvice: async () => { throw new Error('db down'); } } }));
+    assert.equal(broken.work.advice, null);
+    const other = await gw.readStage('strategize', charterDeps());
+    assert.equal(other.work.advice, undefined, 'only the charter stage carries advice');
+  });
+
+  await test('charter: the assisted brief lists the keys to record for each closed question', async () => {
+    const p = gw.assistPrompt('charter');
+    assert.match(p, /\[final_say\]/);
+    assert.match(p, /Record one of: founder \(Me, the founder\) · trusted/);
+    assert.match(p, /\[leave_behaviour\]/);
+  });
+
+  await test('charter: the planning read path shows a closed answer in words, not its key', async () => {
+    const deps = charterDeps();
+    await gw.setAnswer('charter', 'agreement', { text: 'consent' }, 1, deps);
+    const { markdown } = await gw.readContext(deps);
+    assert.match(markdown, /How much agreement should a decision need\?\*\*\n  It passes unless someone objects/);
   });
 
   await test('an empty project gives the planning read path nothing to print', async () => {

package/tests/government_charter_advice.mjs

@@ -0,0 +1,150 @@
+// tests/government_charter_advice.mjs — the genesis charter stage's recommendation
+// from the founder's own answers (task 1005119).
+//
+// The rules held here:
+//   • ONE recommender: the answers widen recommendedCharter; with none it answers
+//     exactly as the size ladder always has, for every type and size;
+//   • every recommendation is an adoptable form, says why in the founder's answers,
+//     and a Foundation still brings its council rank;
+//   • the principles point at a strictness preset (or none), and saying what a preset
+//     does is part of the answer;
+//   • the drafted bylaws list the recommended preset's own laws word for word, so the
+//     prose and the law book agree, and say plainly when no laws are switched on;
+//   • the closed answers' keys are the genesis questions' choices (two modules, one
+//     vocabulary, held equal here because neither may import the other).
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+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 reco = require(path.join(ROOT, 'modules', 'government', 'recommendations.js'));
+const presets = require(path.join(ROOT, 'modules', 'government', 'presets.js'));
+const charter = require(path.join(ROOT, 'modules', 'government', 'charter.js'));
+const advice = require(path.join(ROOT, 'modules', 'government', 'charter-advice.js'));
+const gw = require(path.join(ROOT, 'modules', 'onboarding', 'genesis-work.js'));
+
+const TYPES = [...reco.PROJECT_TYPES.map((t) => t.key), undefined];
+const SIZES = [0, 1, 2, 3, 8, 9, 49, 50, 149, 150, 1000];
+
+test('the answer keys are exactly the charter questions\' choices', () => {
+  const closed = Object.fromEntries(gw.QUESTIONS.charter.filter((q) => q.choices).map((q) => [q.id, q.choices.map((c) => c.key)]));
+  const expected = { ...reco.CHARTER_ANSWERS, ...presets.PRINCIPLE_ANSWERS };
+  assert.deepEqual(Object.keys(closed).sort(), Object.keys(expected).sort());
+  for (const [id, keys] of Object.entries(expected)) assert.deepEqual(closed[id], [...keys], id);
+});
+
+test('with no answers (or only "not sure"), the ladder answers exactly as before', () => {
+  for (const type of TYPES) {
+    for (const n of SIZES) {
+      const plain = reco.recommendedCharter(n, type);
+      for (const a of [undefined, {}, { final_say: 'maybe', agreement: null }]) {
+        const r = reco.recommendedCharter(n, type, a);
+        assert.equal(r.key, plain.key);
+        assert.equal(r.why, plain.why);
+        assert.equal(r.from_answers, false);
+      }
+    }
+  }
+});
+
+test('the founder\'s final say picks the form, and why quotes them', () => {
+  const r = reco.recommendedCharter(1, 'game', { final_say: 'everyone' });
+  assert.equal(r.key, 'direct-democracy', 'a solo founder who wants everyone deciding is not told monarchy');
+  assert.match(r.why, /You said everyone on the project should have the final say/);
+  assert.equal(r.from_answers, true);
+  const council = reco.recommendedCharter(5, 'research', { final_say: 'council' });
+  assert.equal(council.key, 'foundation');
+  assert.equal(council.council_rank, 'steering-committee', 'a Foundation still brings its council');
+});
+
+test('the other answers move the franchise when the final say is not given', () => {
+  assert.equal(reco.recommendedCharter(5, null, { answers_to: 'yes' }).key, 'foundation');
+  const back = reco.recommendedCharter(1, null, { step_back: 'yes' });
+  assert.equal(back.key, 'timocratic-republic');
+  assert.match(back.why, /step back/);
+  assert.equal(reco.recommendedCharter(5, null, { strangers: 'yes' }).key, 'timocratic-republic');
+  const fast = reco.recommendedCharter(5, null, { speed: 'fast' });
+  assert.equal(fast.key, 'direct-democracy', 'speed alone keeps the ladder\'s form');
+  assert.match(fast.why, /Who votes follows your size/, 'the part the answers did not decide says the ladder decided it');
+});
+
+test('how much agreement tunes the pass rule and says where it is set', () => {
+  const r = reco.recommendedCharter(20, null, { agreement: 'majority' });
+  assert.equal(r.key, 'timocratic-republic');
+  assert.equal(r.pass_rule, 'majority');
+  assert.equal(r.pass_rule_tuned, true);
+  assert.match(r.why, /legislation stage/);
+  const solo = reco.recommendedCharter(1, null, { final_say: 'founder', agreement: 'unanimous' });
+  assert.equal(solo.pass_rule, 'first_ratifier', 'a board of one is decided by its one yes');
+  assert.match(solo.why, /only voter/);
+});
+
+test('every answer combination recommends an adoptable form whose settings build a proposal', () => {
+  const A = reco.CHARTER_ANSWERS;
+  const available = charter.FORMS.filter((f) => f.available).map((f) => f.key);
+  const live = { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true };
+  for (const fs of [undefined, ...A.final_say]) for (const ag of [undefined, ...A.agreement]) for (const yn of [undefined, 'yes', 'no']) {
+    const r = reco.recommendedCharter(5, 'business', { final_say: fs, agreement: ag, strangers: yn, answers_to: yn, step_back: yn });
+    assert.ok(available.includes(r.key), r.key);
+    assert.ok(typeof r.why === 'string' && r.why.length > 10);
+    const built = charter.buildCharterProposal(live, { franchise: r.franchise, passRule: r.pass_rule, councilRank: r.council_rank });
+    assert.equal(built.ok, true, JSON.stringify(r));
+    assert.equal(charter.readCharter(built.proposal).franchise, r.franchise);
+  }
+});
+
+test('principles point at a preset, or at none', () => {
+  assert.equal(presets.recommendedPreset({}), null, 'no preset is a fine answer');
+  assert.equal(presets.recommendedPreset({ trust_level: 'a_lot' }).key, 'open');
+  assert.equal(presets.recommendedPreset({ trust_level: 'some' }).key, 'guild');
+  assert.equal(presets.recommendedPreset({ trust_level: 'little' }).key, 'factory');
+  assert.equal(presets.recommendedPreset({ trust_level: 'a_lot', catch_or_fix: 'catch_early' }).key, 'guild');
+  assert.equal(presets.recommendedPreset({ trust_level: 'little', catch_or_fix: 'move_fast' }).key, 'guild');
+  const p = presets.recommendedPreset({ trust_level: 'some' });
+  assert.match(p.why, /You said/);
+  assert.match(p.is, /not a style guide/);
+  assert.ok(p.laws.length > 0);
+});
+
+test('the draft names the recommended preset\'s own laws word for word', () => {
+  const a = advice.buildAdvice({
+    answers: { final_say: 'trusted', trust_level: 'little' },
+    prose: { feel: 'Calm and careful.', leave_behaviour: 'Lying about shipped work.', write_down: 'We never ship on Fridays.' },
+    headcount: 12,
+  });
+  assert.equal(a.charter.key, 'timocratic-republic');
+  assert.equal(a.preset.key, 'factory');
+  const factory = presets.PRESETS.find((p) => p.key === 'factory');
+  for (const law of factory.laws) assert.ok(a.draft_md.includes(`**${law.text}.** ${law.effect_on_ai}`), law.text);
+  assert.ok(a.preset.locks.some((l) => l.setting === 'wandering'), 'what it would lock is said');
+  assert.match(a.draft_md, /Timocratic Republic/);
+  assert.match(a.draft_md, /Calm and careful\./);
+  assert.match(a.draft_md, /Lying about shipped work\./);
+  assert.match(a.draft_md, /We never ship on Fridays\./);
+});
+
+test('with no preset the draft says no laws are switched on', () => {
+  const a = advice.buildAdvice({ answers: {}, headcount: 1 });
+  assert.equal(a.preset, null);
+  assert.match(a.draft_md, /No laws are switched on/);
+  assert.equal(a.charter.key, 'monarchy');
+  assert.doesNotMatch(a.draft_md, /Code of conduct/, 'no section for words the founder has not written');
+});
+
+test('the port entry reads the head count and the law book', async () => {
+  const calls = [];
+  const db = {
+    countActiveBuilders: async () => { calls.push('count'); return 40; },
+    listLaws: async () => { calls.push('laws'); return []; },
+  };
+  const live = await advice.charterAdvice({ answers: {}, prose: { feel: '  ' } }, { db });
+  assert.equal(live.headcount, 40);
+  assert.equal(live.charter.key, 'timocratic-republic');
+  assert.ok(calls.includes('laws'));
+  const expected = await advice.charterAdvice({ answers: {}, headcount: 2 }, { db });
+  assert.equal(expected.headcount, 2, 'the founder\'s expected number wins over the live count');
+  assert.equal(expected.charter.key, 'monarchy');
+});

package/tests/landing_guide_hall.mjs

@@ -0,0 +1,364 @@
+// tests/landing_guide_hall.mjs — the start-a-project guide, plain (builders' hall) version,
+// and the switch between it and the game scene (task 1005276, goal 1000106).
+//
+// The two presentations share ONE conversation (assets/guide-core.js): the state machine,
+// the server's client rules and the doors are pinned by tests/landing_guide_scene.mjs. What
+// this file holds is the hall half and the switch, RUN under a small DOM stub:
+//   * the hall walk: open → chat → the first send held → the cap → the plan asked for and
+//     drawn under the talk → "Sign up and get started"; Escape hands focus back;
+//   * the fallback (a "form" start) and a retry error that gives the words back;
+//   * which one a door opens: the game unless this browser picked the plain one; the switch
+//     both ways mid-chat keeps the same chat (no second start) and is remembered;
+//   * the switch is offered only when the other presentation is on the page;
+//   * the markup and the sheet: hidden labelled dialog, the honeypot out of the tab order,
+//     the core loaded first, tokens only (no typed colour, size, corner, shadow or breakpoint).
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
+const HTML = fs.readFileSync(path.join(LANDING, 'index.html'), 'utf8').replace(/\r\n/g, '\n');
+const CSS = fs.readFileSync(path.join(LANDING, 'assets', 'guide-hall.css'), 'utf8').replace(/\r\n/g, '\n');
+const HALL_SRC = fs.readFileSync(path.join(LANDING, 'assets', 'guide-hall.js'), 'utf8');
+const Core = require(path.join(LANDING, 'assets', 'guide-core.js'));
+const Scene = require(path.join(LANDING, 'assets', 'guide-scene.js'));
+const Hall = require(path.join(LANDING, 'assets', 'guide-hall.js'));
+
+// ── a small DOM: the two dialogs, each with its named parts ───────────────────────
+const GAME_PARTS = ['log', 'err', 'form', 'text', 'website', 'send', 'end', 'go', 'left', 'segs', 'plan-body', 'plan-toggle', 'plan-close', 'close', 'skip', 'make-plan', 'plan-again', 'saved', 'switch'];
+const HALL_PARTS = ['log', 'err', 'form', 'text', 'website', 'send', 'end', 'go', 'left', 'body', 'plan', 'plan-body', 'saved', 'close', 'make-plan', 'plan-again', 'switch'];
+
+function makeDom({ game = true, hall = true } = {}) {
+  const listeners = new Map();
+  const on = (target) => (type, fn) => { if (!listeners.has(target)) listeners.set(target, {}); (listeners.get(target)[type] ||= []).push(fn); };
+  const fire = (target, type, ev) => ((listeners.get(target) || {})[type] || []).forEach((fn) => fn(ev));
+  const doc = { activeElement: null };
+  function node(tag = 'div') {
+    const n = {
+      tagName: tag.toUpperCase(), children: [], className: '', textContent: '', hidden: false, disabled: false, value: '', maxLength: 0, attrs: {}, scrollTop: 0, scrollHeight: 0, offsetTop: 0, offsetParent: {},
+      get firstChild() { return this.children[0] || null; },
+      appendChild(c) { this.children.push(c); return c; },
+      removeChild(c) { this.children.splice(this.children.indexOf(c), 1); return c; },
+      setAttribute(k, v) { this.attrs[k] = String(v); }, getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; },
+      removeAttribute(k) { delete this.attrs[k]; },
+      classList: { set: new Set(), add(c) { this.set.add(c); }, remove(c) { this.set.delete(c); }, toggle(c, v) { if (v) this.set.add(c); else this.set.delete(c); }, contains(c) { return this.set.has(c); } },
+      focus() { doc.activeElement = n; },
+      querySelectorAll() { return []; },
+      querySelector() { return null; },
+    };
+    n.addEventListener = on(n);
+    Object.defineProperty(n, 'innerHTML', { set() { throw new Error('innerHTML is not allowed'); } });
+    return n;
+  }
+  function dialog(attr, names) {
+    const parts = {};
+    names.forEach((k) => { parts[k] = node(); });
+    const root = node();
+    root.hidden = true;
+    root.querySelector = (sel) => {
+      const m = sel.match(new RegExp('^\\[' + attr + '="([^"]+)"\\]$'));
+      return m ? parts[m[1]] || null : null;
+    };
+    return { root, parts };
+  }
+  const g = game ? dialog('data-gd', GAME_PARTS) : null;
+  if (g) g.parts['plan-toggle'].offsetParent = null;   // desktop: the plan stands beside the talk
+  const h = hall ? dialog('data-gh', HALL_PARTS) : null;
+  Object.assign(doc, {
+    documentElement: node('html'),
+    head: node('head'),
+    getElementById: (id) => (id === 'guide' && g ? g.root : id === 'guideHall' && h ? h.root : null),
+    createElement: (t) => node(t),
+    querySelector: () => null,
+  });
+  doc.addEventListener = on(doc);
+  return { doc, game: g, hall: h, fire, node };
+}
+
+function makeWin(mods, routes) {
+  const calls = [];
+  const timers = [];
+  const win = {
+    __MODULES__: mods,
+    localStorage: { data: {}, getItem(k) { return k in this.data ? this.data[k] : null; }, setItem(k, v) { this.data[k] = String(v); }, removeItem(k) { delete this.data[k]; } },
+    setTimeout: (fn, ms) => { timers.push({ fn, ms }); },
+    fetch: (url, opts = {}) => {
+      calls.push({ url, method: opts.method || 'GET', body: opts.body ? JSON.parse(opts.body) : null, headers: opts.headers || {} });
+      const r = routes(url, opts);
+      return Promise.resolve({ status: r.status, json: () => Promise.resolve(r.body) });
+    },
+  };
+  return { win, calls, timers };
+}
+const ON = { enabled: { 'front-door-guide': true } };
+const tick = () => new Promise((r) => setImmediate(r));
+const settle = async (n = 4) => { for (let i = 0; i < n; i++) await tick(); };
+function click(dom, door) {
+  let prevented = false;
+  const ev = { target: { closest: (sel) => (sel === '[data-guide-door]' ? door : null) }, button: 0, preventDefault() { prevented = true; }, get defaultPrevented() { return prevented; } };
+  dom.fire(dom.doc, 'click', ev);
+  return prevented;
+}
+// boot both, in the page's script order (the core is required by each)
+function bootAll(win, dom) { Scene.boot(win, dom.doc); Hall.boot(win, dom.doc); }
+
+const planAnswer = {
+  ok: true, mode: 'plan', message: 'Here is your plan.', next: { action: 'sign_up', label: 'Sign up and get started' }, saved: { message: 'Saved.' },
+  conversation: { messages_used: 2, messages_left: 0 },
+  plan: { summary: 'A booking site for a dance school.', how_it_works: ['Students pick a class'], steps: [{ title: 'Sign up', detail: 'Make your account' }], modules: [], needs: [], open_questions: ['Payments?'], cost_and_time: 'Cost and time depend on you.' },
+};
+function chatRoutes(over = {}) {
+  let left = 2;
+  return (url, opts) => {
+    const m = (opts.method || 'GET') + ' ' + url;
+    if (over[m]) return over[m](opts);
+    if (url.endsWith('/status')) return { status: 200, body: { ok: true, mode: 'chat', limits: { max_messages: 2, max_message_chars: 1000 } } };
+    if (m === 'POST /api/bongos/front-door-guide/conversations') return { status: 201, body: { ok: true, mode: 'chat', greeting: 'Hi!', conversation: { id: '9', token: 'tk', messages_used: 0, messages_left: 2, max_message_chars: 1000 }, saved: { message: 'This chat is saved on this device.', keep_days: 30 } } };
+    if (url.endsWith('/plan')) return { status: 200, body: planAnswer };
+    left -= 1;
+    return left > 0
+      ? { status: 200, body: { ok: true, mode: 'chat', reply: { text: 'Tell me more.' }, conversation: { messages_used: 1, messages_left: left } } }
+      : { status: 200, body: { ok: true, mode: 'ended', reason: 'message_cap', next_step: 'plan', message: 'That is all.', reply: { text: 'Thanks.' }, conversation: { messages_used: 2, messages_left: 0 } } };
+  };
+}
+const texts = (list) => list.children.map((li) => li.children.map((c) => c.textContent).join(' | '));
+
+// ── module off ─────────────────────────────────────────────────────────────────────
+test('module off: the hall reads nothing and takes no door', async () => {
+  const dom = makeDom({ game: false });
+  const { win, calls } = makeWin({ enabled: { 'front-door-guide': false } }, () => ({ status: 500, body: {} }));
+  Hall.boot(win, dom.doc);
+  await tick();
+  assert.equal(calls.length, 0);
+  assert.equal(click(dom, dom.node('a')), false);
+  assert.equal(dom.hall.root.hidden, true);
+});
+
+// ── the hall walk ──────────────────────────────────────────────────────────────────
+test('the hall walk: open, the first send held, the cap asks for the plan, the plan under the talk, sign up', async () => {
+  const dom = makeDom();
+  const { win, calls, timers } = makeWin(ON, chatRoutes());
+  win.localStorage.data[Core.VIEW_KEY] = 'hall';
+  bootAll(win, dom);
+  await tick();
+  const door = dom.node('a');
+  assert.equal(click(dom, door), true, 'the door is taken');
+  const P = dom.hall.parts;
+  assert.equal(dom.hall.root.hidden, false, 'this browser picked the plain one');
+  assert.equal(dom.game.root.hidden, true, 'and the game stays down');
+  assert.ok(dom.doc.documentElement.classList.contains('gd-open'), 'the page under it does not scroll');
+  assert.deepEqual(texts(P.log), ['Guide | Your guide is thinking…'], 'the waiting line is words');
+  await settle();
+  assert.equal(dom.hall.root.getAttribute('data-phase'), 'chat');
+  assert.deepEqual(calls[1].body, { website: '' }, 'the hidden field is sent as it stands');
+  assert.deepEqual(JSON.parse(win.localStorage.data[Core.STORE_KEY]), { id: '9', token: 'tk' }, 'the same chat key the hand-off reads');
+  assert.deepEqual(texts(P.log), ['Guide | Hi!']);
+  assert.equal(P.left.textContent, '2 of 2 messages left');
+  assert.equal(P.saved.textContent, 'This chat is saved on this device.');
+  assert.equal(P.plan.hidden, true, 'no plan section while talking');
+  assert.equal(P['make-plan'].hidden, true);
+  assert.equal(dom.doc.activeElement, P.text, 'focus lands in the box');
+  assert.equal(P.switch.hidden, false, 'the game is offered');
+
+  P.text.value = 'A booking site';
+  dom.fire(P.form, 'submit', { preventDefault() {} });
+  assert.equal(P.text.value, '');
+  assert.equal(dom.hall.root.getAttribute('data-phase'), 'sending');
+  assert.ok(timers[0].ms > 1000, 'the first message waits out the bot check');
+  timers.shift().fn();
+  await settle();
+  assert.deepEqual(calls[2].body, { token: 'tk', text: 'A booking site', website: '' });
+  assert.equal(P.left.textContent, '1 of 2 messages left');
+  assert.equal(P['make-plan'].hidden, false, 'after a message the plan can be asked for early');
+
+  // Enter sends too
+  P.text.value = 'Students book';
+  dom.fire(P.text, 'keydown', { key: 'Enter', shiftKey: false, preventDefault() {} });
+  assert.equal(timers[0].ms, 0, 'later messages never wait');
+  timers.shift().fn();
+  await settle(6);
+  assert.ok(calls.some((c) => c.url.endsWith('/conversations/9/plan')), 'POST …/plan once the cap ended the chat');
+  assert.equal(dom.hall.root.getAttribute('data-phase'), 'ended');
+  assert.equal(P.form.hidden, true);
+  assert.equal(P.end.hidden, false);
+  assert.equal(P.plan.hidden, false, 'the plan sits under the talk');
+  const plan = P['plan-body'].children.map((c) => c.textContent);
+  assert.equal(plan[0], 'A booking site for a dance school.');
+  assert.ok(plan.includes('How it works') && plan.includes('Steps') && plan.includes('Still to decide'));
+  assert.equal(plan.at(-1), 'Cost and time depend on you.');
+  assert.equal(P.left.textContent, 'No messages left');
+  assert.equal(P.go.textContent, 'Sign up and get started');
+  assert.equal(P['plan-again'].hidden, true);
+  assert.equal(dom.doc.activeElement, P.go, 'focus moves to the way on');
+
+  dom.fire(dom.hall.root, 'keydown', { key: 'Escape', preventDefault() {} });
+  assert.equal(dom.hall.root.hidden, true);
+  assert.equal(dom.doc.activeElement, door, 'focus goes back to the door');
+  assert.ok(!dom.doc.documentElement.classList.contains('gd-open'));
+});
+
+test('the hall: a "form" start is the plain door, never an error', async () => {
+  const dom = makeDom();
+  const { win } = makeWin(ON, chatRoutes({ 'POST /api/bongos/front-door-guide/conversations': () => ({ status: 200, body: { ok: true, mode: 'form', reason: 'daily_budget', message: 'Our guide is busy today.' } }) }));
+  win.localStorage.data[Core.VIEW_KEY] = 'hall';
+  bootAll(win, dom);
+  await tick();
+  click(dom, dom.node('a'));
+  await settle();
+  const P = dom.hall.parts;
+  assert.equal(dom.hall.root.getAttribute('data-phase'), 'fallback');
+  assert.deepEqual(texts(P.log), ['Guide | Our guide is busy today.']);
+  assert.equal(P.err.hidden, true);
+  assert.equal(P.form.hidden, true);
+  assert.equal(P.go.textContent, 'Start a project');
+  assert.equal(P.left.hidden, true, 'no count on the fallback');
+  assert.equal(P.saved.hidden, true);
+});
+
+test('the hall: too long says so and gives the words back; an empty box says so and sends nothing', async () => {
+  const dom = makeDom();
+  const { win, calls, timers } = makeWin(ON, chatRoutes({ 'POST /api/bongos/front-door-guide/conversations/9/messages': () => ({ status: 400, body: { ok: false, error: 'too_long', max_message_chars: 500 } }) }));
+  win.localStorage.data[Core.VIEW_KEY] = 'hall';
+  bootAll(win, dom);
+  await tick();
+  click(dom, dom.node('a'));
+  await settle();
+  const P = dom.hall.parts;
+  P.text.value = '   ';
+  dom.fire(P.form, 'submit', { preventDefault() {} });
+  assert.equal(P.err.textContent, Core.COPY.empty);
+  assert.equal(timers.length, 0, 'nothing sent');
+  P.text.value = 'my long words';
+  dom.fire(P.form, 'submit', { preventDefault() {} });
+  timers.shift().fn();
+  await settle();
+  assert.equal(P.err.hidden, false);
+  assert.equal(P.err.textContent, 'That is too long. Keep it under 500 characters.');
+  assert.equal(P.text.value, 'my long words', 'the words come back');
+  assert.equal(P.text.maxLength, 500);
+  assert.equal(calls.filter((c) => c.url.endsWith('/messages')).length, 1);
+});
+
+// ── which one, and the switch ──────────────────────────────────────────────────────
+test('a door opens the game when this browser has not picked; the switch carries the chat both ways and is remembered', async () => {
+  const dom = makeDom();
+  const { win, calls, timers } = makeWin(ON, chatRoutes());
+  bootAll(win, dom);
+  await tick();
+  click(dom, dom.node('a'));
+  await settle();
+  assert.equal(dom.game.root.hidden, false, 'the game by default');
+  assert.equal(dom.hall.root.hidden, true);
+  assert.equal(dom.game.parts.switch.hidden, false, '"Use the simple version" is there');
+
+  dom.game.parts.text.value = 'A booking site';
+  dom.fire(dom.game.parts.form, 'submit', { preventDefault() {} });
+  timers.shift().fn();
+  await settle();
+
+  dom.fire(dom.game.parts.switch, 'click', {});
+  assert.equal(dom.game.root.hidden, true);
+  assert.equal(dom.hall.root.hidden, false);
+  assert.ok(dom.doc.documentElement.classList.contains('gd-open'));
+  assert.equal(win.localStorage.data[Core.VIEW_KEY], 'hall', 'the pick is kept on this browser');
+  assert.deepEqual(texts(dom.hall.parts.log), ['Guide | Hi!', 'You | A booking site', 'Guide | Tell me more.'], 'the same chat');
+  assert.equal(dom.hall.parts.left.textContent, '1 of 2 messages left');
+  assert.equal(dom.doc.activeElement, dom.hall.parts.text);
+  assert.equal(calls.filter((c) => c.method === 'POST' && c.url.endsWith('/conversations')).length, 1, 'never a second chat');
+
+  // keep talking in the plain one: the same conversation id
+  dom.hall.parts.text.value = 'Students book';
+  dom.fire(dom.hall.parts.form, 'submit', { preventDefault() {} });
+  timers.shift().fn();
+  await settle(6);
+  assert.equal(calls.filter((c) => c.url.endsWith('/conversations/9/messages')).length, 2);
+  assert.equal(dom.hall.root.getAttribute('data-phase'), 'ended');
+
+  // and back to the game, plan and all
+  dom.fire(dom.hall.parts.switch, 'click', {});
+  assert.equal(dom.hall.root.hidden, true);
+  assert.equal(dom.game.root.hidden, false);
+  assert.equal(win.localStorage.data[Core.VIEW_KEY], 'game');
+  assert.equal(dom.game.root.getAttribute('data-phase'), 'ended');
+  assert.equal(dom.game.parts['plan-body'].children[0].textContent, 'A booking site for a dance school.');
+
+  // closed and opened again: the last pick
+  dom.fire(dom.game.root, 'keydown', { key: 'Escape', preventDefault() {} });
+  dom.fire(dom.game.parts.switch, 'click', {});            // nothing open: the press opens nothing
+  assert.equal(dom.hall.root.hidden, true);
+  assert.equal(win.localStorage.data[Core.VIEW_KEY], 'game');
+  win.localStorage.data[Core.VIEW_KEY] = 'hall';
+  click(dom, dom.node('a'));
+  assert.equal(dom.hall.root.hidden, false);
+  assert.equal(dom.game.root.hidden, true);
+});
+
+test('the switch is offered only when the other one is on the page', async () => {
+  const gameOnly = makeDom({ hall: false });
+  const a = makeWin(ON, chatRoutes());
+  Scene.boot(a.win, gameOnly.doc);
+  await tick();
+  click(gameOnly, gameOnly.node('a'));
+  assert.equal(gameOnly.game.parts.switch.hidden, true);
+
+  const hallOnly = makeDom({ game: false });
+  const b = makeWin(ON, chatRoutes());
+  Hall.boot(b.win, hallOnly.doc);
+  await tick();
+  click(hallOnly, hallOnly.node('a'));
+  assert.equal(hallOnly.hall.root.hidden, false, 'with no game the plain one opens');
+  assert.equal(hallOnly.hall.parts.switch.hidden, true);
+});
+
+test('a stored pick that is not a presentation falls back to the game', async () => {
+  const dom = makeDom();
+  const { win } = makeWin(ON, chatRoutes());
+  win.localStorage.data[Core.VIEW_KEY] = 'bogus';
+  bootAll(win, dom);
+  await tick();
+  click(dom, dom.node('a'));
+  assert.equal(dom.game.root.hidden, false);
+});
+
+// ── markup and sheet ───────────────────────────────────────────────────────────────
+test('the plain dialog is markup, hidden, labelled, with the honeypot out of the tab order and the same closing action', () => {
+  assert.match(HTML, /<div class="gh" id="guideHall" role="dialog" aria-modal="true" aria-labelledby="ghTitle" hidden>/);
+  assert.match(HTML, /<input class="gh__hp" type="text" name="website" data-gh="website" tabindex="-1" autocomplete="off" aria-hidden="true">/);
+  assert.match(HTML, /<label class="gh__label" for="ghText">Your message<\/label>/);
+  assert.match(HTML, /<a class="door door--go" data-gh="go" href="\/projects\?view=new">Sign up and get started<\/a>/);
+  assert.match(HTML, /<button type="button" class="gh__link" data-gh="switch">Use the game version<\/button>/);
+  assert.match(HTML, /<button type="button" class="gd__switch" data-gd="switch" hidden>Use the simple version<\/button>/);
+  assert.match(HTML, /<script src="\/assets\/guide-core\.js"><\/script>\n<script src="\/assets\/guide-scene\.js"><\/script>\n<script src="\/assets\/guide-hall\.js"><\/script>/);
+  assert.match(HTML, /<link rel="stylesheet" href="\/assets\/guide-hall\.css">/);
+  assert.ok(HTML.indexOf('/assets/world.css') < HTML.indexOf('/assets/guide-hall.css'));
+});
+
+test('the hall script writes no innerHTML and asks the server nothing itself', () => {
+  const code = HALL_SRC.replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.doesNotMatch(code, /innerHTML/);
+  assert.doesNotMatch(code, /fetch\(|localStorage|sessionStorage/, 'the routes and the storage are the core\'s');
+});
+
+test('the sheet: tokens only, no :root, no breakpoint, no !important, no motion', () => {
+  const code = CSS.replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.doesNotMatch(code, /#[0-9a-f]{3,8}\b/i, 'no hex colour');
+  assert.doesNotMatch(code, /\brgba?\((?!0, 0, 0,)/, 'the only literal is black with alpha (the scrim)');
+  assert.doesNotMatch(code, /font-size:\s*\d/, 'type from the scale');
+  assert.doesNotMatch(code, /border-radius:\s*\d/, 'corners from the scale');
+  assert.doesNotMatch(code, /:root|@media|!important|animation|transition/);
+});
+
+test('every control in the plain dialog clears the 24px floor', () => {
+  for (const [sel, min] of [['.gh__x', /width: 40px; height: 40px/], ['.gh__link', /min-height: 24px/]]) {
+    const rule = CSS.slice(CSS.indexOf(sel + ' {'));
+    assert.match(rule.slice(0, rule.indexOf('}')), min, sel);
+  }
+  // the presses are the landing's own door pills (48px, index.html .door)
+  assert.match(HTML, /\.door\{display:inline-flex;align-items:center;justify-content:center;min-height:48px;/);
+});

package/tests/landing_guide_scene.mjs

@@ -31,6 +31,8 @@ const LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
 const HTML = fs.readFileSync(path.join(LANDING, 'index.html'), 'utf8').replace(/\r\n/g, '\n');
 const CSS = fs.readFileSync(path.join(LANDING, 'assets', 'guide-scene.css'), 'utf8').replace(/\r\n/g, '\n');
 const JS_SRC = fs.readFileSync(path.join(LANDING, 'assets', 'guide-scene.js'), 'utf8');
+// the conversation's own half (the routes, the storage) is shared with the plain twin since task 1005276
+const CORE_SRC = fs.readFileSync(path.join(LANDING, 'assets', 'guide-core.js'), 'utf8');
 const G = require(path.join(LANDING, 'assets', 'guide-scene.js'));
 
 const chatStart = (over = {}) => ({
@@ -462,7 +464,7 @@ test('the scene is markup, hidden, a labelled modal dialog, with the honeypot ou
   assert.match(HTML, /<button type="button" class="gd__more" data-gd="make-plan" hidden>Make my plan<\/button>/);
   assert.match(HTML, /<button type="button" class="gd__more" data-gd="plan-again" hidden>Make my plan<\/button>/);
   assert.match(HTML, /<p class="gd__saved" data-gd="saved" hidden><\/p>/);
-  assert.match(HTML, /<script src="\/assets\/guide-scene\.js"><\/script>/);
+  assert.match(HTML, /<script src="\/assets\/guide-core\.js"><\/script>\n<script src="\/assets\/guide-scene\.js"><\/script>/, 'the shared core loads first');
   assert.match(HTML, /<link rel="stylesheet" href="\/assets\/guide-scene\.css">/);
   // the guide is the Patron sprite the hall already serves, not a second drawing
   assert.match(HTML, /src="\/modules\/hall-ui\/public\/characters\/patron\.png"/);
@@ -474,11 +476,12 @@ test('a signed-in visitor keeps the plain doors: the /me read takes the hook off
 });
 
 test('the script writes no innerHTML and talks only to the guide routes', () => {
-  assert.doesNotMatch(JS_SRC.replace(/\/\*[\s\S]*?\*\//g, ''), /innerHTML/);
-  const urls = [...JS_SRC.matchAll(/API \+ '([^']+)'/g)].map((m) => m[1]);
+  for (const src of [JS_SRC, CORE_SRC]) assert.doesNotMatch(src.replace(/\/\*[\s\S]*?\*\//g, ''), /innerHTML/);
+  const urls = [...CORE_SRC.matchAll(/API \+ '([^']+)'/g)].map((m) => m[1]);
   assert.deepEqual([...new Set(urls)].sort(), ['/conversations', '/conversations/', '/status']);
-  assert.match(JS_SRC, /convUrl\('\/plan'\)/, 'the plan route');
-  assert.doesNotMatch(JS_SRC, /sessionStorage/, 'the chat is kept in local storage, as the server\'s contract says');
+  assert.doesNotMatch(JS_SRC, /fetch\(/, 'the scene asks the server nothing itself: the core does');
+  assert.match(CORE_SRC, /convUrl\('\/plan'\)/, 'the plan route');
+  assert.doesNotMatch(CORE_SRC + JS_SRC, /sessionStorage/, 'the chat is kept in local storage, as the server\'s contract says');
   assert.equal(G.API, '/api/bongos/front-door-guide');
 });