@bongos/core 1.25.15 → 1.25.17

package/tests/landing_guide_scene.mjs

@@ -0,0 +1,504 @@
+// tests/landing_guide_scene.mjs — the start-a-project guide, game version, on the landing
+// (task 1005275, goal 1000106).
+//
+// The client of modules/front-door-guide (tasks 1005272 chat, 1005273 plan). What this file
+// holds:
+//   * the client states, through the pure state machine: open (starting → chat), sending,
+//     cap reached (→ planning → ended with the plan), the fallback (form, a lost chat, a
+//     failed start), the retry errors that keep the visitor's words, and a resumed chat;
+//   * the plan read from the server's Plan shape, and read as optional;
+//   * the server's client rules: the honeypot sent as it stands, the first message held
+//     MIN_FIRST_MS after the start, the chat's id + token kept in LOCAL storage and resumed
+//     with GET …/conversations/:id, the plan asked for with POST …/plan once the chat ends;
+//   * boot() RUN under a small DOM stub: module off → no read and no door taken; status
+//     "form" → the door stays a plain link; status "chat" → the door opens the scene, the
+//     first send waits, the cap asks for the plan, "Sign up and get started"; a held chat
+//     is resumed on load, never started again, and a 404 forgets it;
+//   * the markup and the sheet: the doors keep their href, the scene is hidden, no
+//     innerHTML, every colour a var()/color-mix() of the fifteen, no :root, no !important
+//     (so world.css's reduced-motion switch reaches the waiting dots).
+
+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-scene.css'), 'utf8').replace(/\r\n/g, '\n');
+const JS_SRC = fs.readFileSync(path.join(LANDING, 'assets', 'guide-scene.js'), 'utf8');
+const G = require(path.join(LANDING, 'assets', 'guide-scene.js'));
+
+const chatStart = (over = {}) => ({
+  type: 'started', status: 201, now: 1000,
+  body: { ok: true, mode: 'chat', greeting: 'Hi! What would you like to build?', conversation: { id: '7', token: 'tok', messages_used: 0, messages_left: 3, max_message_chars: 1000 }, ...over },
+});
+const open = () => G.reduce(G.reduce(G.initial(), { type: 'start' }), chatStart());
+
+// ── the module switch ──────────────────────────────────────────────────────────────
+test('the guide is on only when the injected module set says front-door-guide is true', () => {
+  assert.equal(G.guideOn({ enabled: { 'front-door-guide': true } }), true);
+  assert.equal(G.guideOn({ enabled: { 'front-door-guide': false } }), false);
+  assert.equal(G.guideOn({ enabled: {} }), false);
+  assert.equal(G.guideOn(undefined), false);
+});
+
+// ── open ───────────────────────────────────────────────────────────────────────────
+test('open: starting, then chat with the greeting, the conversation and the count', () => {
+  const s0 = G.reduce(G.initial(), { type: 'start' });
+  assert.equal(s0.phase, 'starting');
+  const s = G.reduce(s0, chatStart());
+  assert.equal(s.phase, 'chat');
+  assert.deepEqual(s.conv, { id: '7', token: 'tok' });
+  assert.equal(s.left, 3);
+  assert.equal(s.total, 3);
+  assert.deepEqual(s.messages, [{ role: 'guide', text: 'Hi! What would you like to build?' }]);
+  assert.equal(s.plan, null, 'no plan field yet: none shown');
+});
+
+// ── sending ────────────────────────────────────────────────────────────────────────
+test('sending: the visitor line shows at once, the reply lands and the count drops', () => {
+  const s1 = G.reduce(open(), { type: 'send', text: 'A booking site' });
+  assert.equal(s1.phase, 'sending');
+  assert.deepEqual(s1.messages.at(-1), { role: 'visitor', text: 'A booking site' });
+  const s2 = G.reduce(s1, { type: 'answer', status: 200, body: { ok: true, mode: 'chat', reply: { text: 'Who books?' }, conversation: { messages_used: 1, messages_left: 2 } } });
+  assert.equal(s2.phase, 'chat');
+  assert.equal(s2.left, 2);
+  assert.equal(s2.total, 3);
+  assert.deepEqual(s2.messages.at(-1), { role: 'guide', text: 'Who books?' });
+});
+
+test('a refused reply (declined: true) is shown like any reply', () => {
+  const s = G.reduce(G.reduce(open(), { type: 'send', text: 'x' }), { type: 'answer', status: 200, body: { ok: true, mode: 'chat', declined: true, reply: { text: 'I can only help plan a project.' }, conversation: { messages_used: 1, messages_left: 2 } } });
+  assert.equal(s.phase, 'chat');
+  assert.equal(s.messages.at(-1).text, 'I can only help plan a project.');
+});
+
+// ── cap reached ────────────────────────────────────────────────────────────────────
+test('cap reached: the last reply, the server\'s line, no messages left, then the plan is asked for', () => {
+  const s = G.reduce(G.reduce(open(), { type: 'send', text: 'last one' }), { type: 'answer', status: 200, body: {
+    ok: true, mode: 'ended', reason: 'message_cap', message: 'That is all the messages this chat has.', next_step: 'plan',
+    reply: { text: 'Here is a first plan.' }, conversation: { messages_used: 3, messages_left: 0 },
+  } });
+  assert.equal(s.phase, 'planning');
+  assert.equal(s.left, 0);
+  assert.deepEqual(s.messages.slice(-2), [{ role: 'guide', text: 'Here is a first plan.' }, { role: 'note', text: 'That is all the messages this chat has.' }]);
+  assert.equal(G.COPY.left(0, 3), 'No messages left');
+});
+
+test('a chat answer that leaves nothing is the end too, and the visitor budget ends it without a reply', () => {
+  const a = G.reduce(G.reduce(open(), { type: 'send', text: 'x' }), { type: 'answer', status: 200, body: { ok: true, mode: 'chat', reply: { text: 'ok' }, conversation: { messages_used: 3, messages_left: 0 } } });
+  assert.equal(a.phase, 'planning');
+  const b = G.reduce(G.reduce(open(), { type: 'send', text: 'x' }), { type: 'answer', status: 200, body: { ok: true, mode: 'ended', reason: 'visitor_budget', next_step: 'plan', message: 'That is as far as this chat can go.' } });
+  assert.equal(b.phase, 'planning');
+  assert.equal(b.messages.at(-1).role, 'note');
+});
+
+// ── fallback ───────────────────────────────────────────────────────────────────────
+test('fallback: a "form" start, a "form" answer, a lost chat and a failed start are the plain door, never an error', () => {
+  const formStart = G.reduce(G.initial(), { type: 'started', status: 200, body: { ok: true, mode: 'form', reason: 'daily_budget', message: 'Use the short form.' } });
+  assert.equal(formStart.phase, 'fallback');
+  assert.equal(formStart.fallback, 'Use the short form.');
+  assert.equal(formStart.error, '');
+
+  const formMid = G.reduce(G.reduce(open(), { type: 'send', text: 'x' }), { type: 'answer', status: 200, body: { ok: true, mode: 'form', reason: 'monthly_budget', message: 'Budget spent.' } });
+  assert.equal(formMid.phase, 'fallback');
+  assert.equal(formMid.fallback, 'Budget spent.');
+
+  const lost = G.reduce(G.reduce(open(), { type: 'send', text: 'x' }), { type: 'answer', status: 404, body: { ok: false, error: 'not_found' } });
+  assert.equal(lost.phase, 'fallback');
+  assert.equal(lost.fallback, G.COPY.lost);
+
+  const noNet = G.reduce(G.reduce(G.initial(), { type: 'start' }), { type: 'started', status: 0, body: {} });
+  assert.equal(noNet.phase, 'fallback');
+  assert.equal(noNet.fallback, G.COPY.fallback);
+});
+
+// ── the retry errors keep the visitor's words ─────────────────────────────────────
+test('too long, too fast, empty and a dropped request each say so and give the words back', () => {
+  const sent = G.reduce(open(), { type: 'send', text: 'my words' });
+  const long = G.reduce(sent, { type: 'answer', status: 400, body: { ok: false, error: 'too_long', max_message_chars: 500 } });
+  assert.equal(long.phase, 'chat');
+  assert.equal(long.restore, 'my words');
+  assert.equal(long.error, 'That is too long. Keep it under 500 characters.');
+  assert.equal(long.maxChars, 500);
+  assert.ok(!long.messages.some((m) => m.role === 'visitor'), 'the unsent line leaves the log');
+
+  const fast = G.reduce(sent, { type: 'answer', status: 429, body: { ok: false, error: 'busy', retry_after_seconds: 2 } });
+  assert.equal(fast.error, 'Too quick. Try again in 2 seconds.');
+  assert.equal(fast.restore, 'my words');
+
+  const empty = G.reduce(sent, { type: 'answer', status: 400, body: { ok: false, error: 'empty' } });
+  assert.equal(empty.error, G.COPY.empty);
+
+  const dropped = G.reduce(sent, { type: 'failed' });
+  assert.equal(dropped.phase, 'chat');
+  assert.equal(dropped.error, G.COPY.failed);
+  assert.equal(dropped.restore, 'my words');
+});
+
+// ── the first send waits ──────────────────────────────────────────────────────────
+test('the first message waits MIN_FIRST_MS after the start; later ones never wait', () => {
+  assert.ok(G.MIN_FIRST_MS >= 1500, 'the server refuses anything sooner than 1500ms');
+  const s = open(); // started at 1000
+  assert.equal(G.firstSendWait(s, 1000), G.MIN_FIRST_MS);
+  assert.equal(G.firstSendWait(s, 1000 + G.MIN_FIRST_MS + 1), 0);
+  const after = G.reduce(s, { type: 'send', text: 'x' });
+  assert.equal(G.firstSendWait(after, 1001), 0);
+});
+
+// ── the plan ───────────────────────────────────────────────────────────────────────
+const PLAN_BODY = {
+  summary: 'A booking site for a small yoga studio.', project_type: 'business',
+  how_it_works: ['Students book a spot.'], modules: [{ key: 'agents', label: 'Extra agents', summary: 'x', why: 'It fits.' }],
+  steps: [{ title: 'Sign up', detail: 'Create your account.' }], needs: [{ item: 'A payments account', detail: 'To take cards.' }],
+  open_questions: ['Refunds?'], cost_and_time: 'This plan does not estimate cost or time.',
+};
+const planAnswer = { ok: true, mode: 'plan', plan: PLAN_BODY, next: { action: 'sign_up', label: 'Sign up and get started' }, message: 'Here is your plan.', saved: { message: 'This chat is saved.', keep_days: 30 }, conversation: { messages_used: 2, messages_left: 1 } };
+
+test('the plan: the server\'s Plan becomes a summary, sections in order and the cost line', () => {
+  const p = G.readPlan(PLAN_BODY);
+  assert.equal(p.summary, 'A booking site for a small yoga studio.');
+  assert.deepEqual(p.sections, [
+    { heading: 'How it works', items: ['Students book a spot.'] },
+    { heading: 'Steps', items: ['Sign up: Create your account.'] },
+    { heading: 'Modules to start with', items: ['Extra agents: It fits.'] },
+    { heading: 'You will need', items: ['A payments account: To take cards.'] },
+    { heading: 'Still to decide', items: ['Refunds?'] },
+  ]);
+  assert.equal(p.note, 'This plan does not estimate cost or time.');
+  assert.equal(G.readPlan(null), null);
+  assert.equal(G.readPlan('  '), null);
+  assert.equal(G.readPlan(42), null);
+  assert.equal(G.readPlan({ project_type: 'game' }), null, 'nothing to show is no plan');
+  assert.equal(G.readPlan('Just words.').summary, 'Just words.');
+});
+
+test('planning → ended: the plan, the closing label and the saved line land; the counter reads none left', () => {
+  const s0 = G.reduce(G.reduce(open(), { type: 'send', text: 'x' }), { type: 'answer', status: 200, body: { ok: true, mode: 'chat', reply: { text: 'ok' }, conversation: { messages_used: 1, messages_left: 2 } } });
+  const s1 = G.reduce(s0, { type: 'plan' });
+  assert.equal(s1.phase, 'planning');
+  const s2 = G.reduce(s1, { type: 'planned', status: 200, body: planAnswer });
+  assert.equal(s2.phase, 'ended');
+  assert.equal(s2.plan.summary, 'A booking site for a small yoga studio.');
+  assert.equal(s2.next, 'Sign up and get started');
+  assert.equal(s2.saved, 'This chat is saved.');
+  assert.equal(s2.left, 0);
+});
+
+test('the plan call: too early goes back to the chat, a form answer is the fallback, a failure can be asked again', () => {
+  const chat = G.reduce(open(), { type: 'plan' });
+  const early = G.reduce(chat, { type: 'planned', status: 409, body: { ok: false, error: 'too_early' } });
+  assert.equal(early.phase, 'chat');
+  assert.equal(early.error, G.COPY.tooEarly);
+  const form = G.reduce(chat, { type: 'planned', status: 200, body: { ok: true, mode: 'form', reason: 'daily_budget', message: 'Budget spent.' } });
+  assert.equal(form.phase, 'fallback');
+  assert.equal(form.fallback, 'Budget spent.');
+  const failed = G.reduce(chat, { type: 'planned', status: 0, body: {} });
+  assert.equal(failed.phase, 'ended');
+  assert.equal(failed.plan, null, 'ended with no plan: the end strip offers Make my plan again');
+  assert.equal(failed.error, G.COPY.planFailed);
+  const lost = G.reduce(chat, { type: 'planned', status: 404, body: { ok: false, error: 'not_found' } });
+  assert.equal(lost.phase, 'fallback');
+});
+
+test('an ended answer that says next_step sign_up with the plan in hand goes straight to the end', () => {
+  const s = G.reduce(G.reduce(open(), { type: 'send', text: 'x' }), { type: 'answer', status: 200, body: { ok: true, mode: 'ended', reason: 'planned', next_step: 'sign_up', plan: PLAN_BODY, message: 'Done.', conversation: { messages_used: 1, messages_left: 0 } } });
+  assert.equal(s.phase, 'ended');
+  assert.ok(s.plan);
+});
+
+// ── a returning visitor ─────────────────────────────────────────────────────────────
+test('resumed: the transcript, the plan and the counts come back; an ended chat lands on the end', () => {
+  const body = { ok: true, conversation: { id: '7', status: 'ended', end_reason: 'planned', messages_used: 2, messages_left: 1, max_message_chars: 1000 }, transcript: [{ role: 'visitor', text: 'A booking site' }, { role: 'guide', text: 'Who books?' }, { role: 'system', text: 'dropped' }], plan: PLAN_BODY, saved: { message: 'Saved.' } };
+  const s = G.reduce(G.initial(), { type: 'resumed', status: 200, body, conv: { id: '7', token: 'tok' }, now: 5 });
+  assert.equal(s.phase, 'ended');
+  assert.deepEqual(s.messages, [{ role: 'visitor', text: 'A booking site' }, { role: 'guide', text: 'Who books?' }]);
+  assert.deepEqual(s.conv, { id: '7', token: 'tok' });
+  assert.equal(s.left, 1);
+  assert.equal(s.saved, 'Saved.');
+  assert.equal(G.firstSendWait(s, 6), 0, 'a chat with a message in it is past the bot check');
+  const open2 = G.reduce(G.initial(), { type: 'resumed', status: 200, body: { ...body, plan: null, conversation: { ...body.conversation, status: 'open', messages_used: 0, messages_left: 3 }, transcript: [] }, conv: { id: '7', token: 'tok' }, now: 5 });
+  assert.equal(open2.phase, 'chat');
+  assert.equal(G.firstSendWait(open2, 5), G.MIN_FIRST_MS, 'nothing said yet: the bot check still applies');
+  assert.equal(G.reduce(G.initial(), { type: 'resumed', status: 500, body: {} }).phase, 'closed');
+});
+
+// ── boot(), run under a small DOM stub ────────────────────────────────────────────
+function makeDom() {
+  const listeners = new Map();
+  const on = (target) => (type, fn) => { const k = target; if (!listeners.has(k)) listeners.set(k, {}); (listeners.get(k)[type] ||= []).push(fn); };
+  const fire = (target, type, ev) => ((listeners.get(target) || {})[type] || []).forEach((fn) => fn(ev));
+  function node(tag = 'div') {
+    const n = {
+      tagName: tag.toUpperCase(), children: [], className: '', textContent: '', hidden: false, disabled: false, value: '', maxLength: 0, attrs: {}, scrollTop: 0, scrollHeight: 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, on) { if (on) 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;
+  }
+  const parts = {};
+  ['log', 'err', 'form', 'text', 'website', 'send', 'end', 'go', 'left', 'segs', 'plan-body', 'plan-toggle', 'plan-close', 'close', 'skip', 'make-plan', 'plan-again', 'saved'].forEach((k) => { parts[k] = node(); });
+  // desktop by default: the Plan button is the one-column layout's only, so it is not rendered
+  parts['plan-toggle'].offsetParent = null;
+  const img = node('img');
+  const scene = node();
+  scene.hidden = true;
+  scene.querySelector = (sel) => {
+    const m = sel.match(/^\[data-gd="([^"]+)"\]$/);
+    if (m) return parts[m[1]];
+    if (sel === '.gd__face img') return img;
+    return null;
+  };
+  const doc = {
+    activeElement: null,
+    documentElement: node('html'),
+    head: node('head'),
+    getElementById: (id) => (id === 'guide' ? scene : null),
+    createElement: (t) => node(t),
+    querySelector: () => null,
+  };
+  doc.addEventListener = on(doc);
+  return { doc, scene, parts, 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 tick = () => new Promise((r) => setImmediate(r));
+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;
+}
+
+test('module off: boot reads nothing and the doors stay plain links', async () => {
+  const dom = makeDom();
+  const { win, calls } = makeWin({ enabled: { 'front-door-guide': false } }, () => ({ status: 500, body: {} }));
+  G.boot(win, dom.doc);
+  await tick();
+  assert.equal(calls.length, 0, 'no status read with the module off');
+  assert.equal(click(dom, dom.node('a')), false, 'the click is not taken');
+  assert.equal(dom.scene.hidden, true);
+});
+
+test('status "form" (no key, budget spent): the door is the plain link it always was', async () => {
+  const dom = makeDom();
+  const { win, calls } = makeWin({ enabled: { 'front-door-guide': true } }, () => ({ status: 200, body: { ok: true, mode: 'form', reason: 'no_key', message: 'Use the form.' } }));
+  G.boot(win, dom.doc);
+  await tick();
+  assert.deepEqual(calls.map((c) => c.url), ['/api/bongos/front-door-guide/status']);
+  assert.equal(click(dom, dom.node('a')), false);
+  assert.equal(dom.scene.hidden, true);
+  assert.equal(calls.length, 1, 'no conversation started');
+});
+
+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 } } };
+  };
+}
+
+test('status "chat": the door opens the scene, the first send waits, the cap asks for the plan, the chat is held in local storage', async () => {
+  const dom = makeDom();
+  const { win, calls, timers } = makeWin({ enabled: { 'front-door-guide': true } }, chatRoutes());
+  G.boot(win, dom.doc);
+  await tick();
+  const door = dom.node('a');
+  assert.equal(click(dom, door), true, 'the click is taken');
+  assert.equal(dom.scene.hidden, false);
+  assert.ok(dom.doc.documentElement.classList.contains('gd-open'));
+  await tick(); await tick();
+  assert.equal(dom.scene.getAttribute('data-phase'), 'chat');
+  assert.equal(calls[1].url, '/api/bongos/front-door-guide/conversations');
+  assert.deepEqual(calls[1].body, { website: '' }, 'the hidden field is sent as it stands');
+  assert.deepEqual(JSON.parse(win.localStorage.data[G.STORE_KEY]), { id: '9', token: 'tk' }, 'held in LOCAL storage');
+  assert.equal(dom.parts.saved.textContent, 'This chat is saved on this device.');
+  assert.equal(dom.parts.left.textContent, '2 of 2 messages left');
+  assert.equal(dom.parts['make-plan'].hidden, true, 'nothing said yet: no plan to ask for');
+
+  // the first message: held for the bot check
+  dom.parts.text.value = 'A booking site';
+  dom.fire(dom.parts.form, 'submit', { preventDefault() {} });
+  assert.equal(dom.scene.getAttribute('data-phase'), 'sending');
+  assert.ok(timers[0].ms > 1000, `held ${timers[0].ms}ms`);
+  timers.shift().fn();
+  await tick(); await tick();
+  assert.deepEqual(calls[2].body, { token: 'tk', text: 'A booking site', website: '' });
+  assert.equal(dom.parts.left.textContent, '1 of 2 messages left');
+  assert.equal(dom.parts['make-plan'].hidden, false, 'after a message the visitor may end early for the plan');
+
+  // the second: no wait; it reaches the cap, and the plan is asked for by itself
+  dom.parts.text.value = 'Students book';
+  dom.fire(dom.parts.form, 'submit', { preventDefault() {} });
+  assert.equal(timers[0].ms, 0);
+  timers.shift().fn();
+  await tick(); await tick(); await tick(); await tick();
+  const planCall = calls.find((c) => c.url.endsWith('/conversations/9/plan'));
+  assert.ok(planCall, 'POST …/plan once the chat ended');
+  assert.deepEqual(planCall.body, { token: 'tk', website: '' });
+  assert.equal(dom.scene.getAttribute('data-phase'), 'ended');
+  assert.equal(dom.parts.form.hidden, true);
+  assert.equal(dom.parts.end.hidden, false);
+  assert.equal(dom.parts.go.textContent, 'Sign up and get started');
+  assert.equal(dom.parts['plan-again'].hidden, true, 'the plan is in: nothing to ask again');
+  assert.ok(dom.parts['plan-body'].children.length > 3, 'the plan is drawn');
+  assert.equal(dom.parts.left.textContent, 'No messages left');
+  assert.equal(dom.doc.activeElement, dom.parts.go, 'focus moves to the way on');
+
+  // Escape closes and hands focus back to the door
+  dom.fire(dom.scene, 'keydown', { key: 'Escape', preventDefault() {} });
+  assert.equal(dom.scene.hidden, true);
+  assert.equal(dom.doc.activeElement, door);
+  assert.ok(!dom.doc.documentElement.classList.contains('gd-open'));
+});
+
+test('"Make my plan" ends the chat early and asks for the plan', async () => {
+  const dom = makeDom();
+  const { win, calls, timers } = makeWin({ enabled: { 'front-door-guide': true } }, chatRoutes());
+  G.boot(win, dom.doc);
+  await tick();
+  click(dom, dom.node('a'));
+  await tick(); await tick();
+  dom.parts.text.value = 'A booking site';
+  dom.fire(dom.parts.form, 'submit', { preventDefault() {} });
+  timers.shift().fn();
+  await tick(); await tick();
+  dom.fire(dom.parts['make-plan'], 'click', {});
+  assert.equal(dom.scene.getAttribute('data-phase'), 'planning');
+  await tick(); await tick(); await tick();
+  assert.equal(calls.filter((c) => c.url.endsWith('/plan')).length, 1);
+  assert.equal(dom.scene.getAttribute('data-phase'), 'ended');
+});
+
+test('a held chat is resumed on load and opened as it was, never started again', async () => {
+  const dom = makeDom();
+  const resumed = { ok: true, conversation: { id: '4', status: 'open', messages_used: 1, messages_left: 1, max_message_chars: 1000 }, transcript: [{ role: 'visitor', text: 'Mine' }, { role: 'guide', text: 'Yours' }], plan: null, saved: { message: 'Saved.' } };
+  const { win, calls } = makeWin({ enabled: { 'front-door-guide': true } }, (url) => {
+    if (url.endsWith('/status')) return { status: 200, body: { ok: true, mode: 'form', reason: 'daily_budget' } };
+    if (url.endsWith('/conversations/4')) return { status: 200, body: resumed };
+    return { status: 500, body: {} };
+  });
+  win.localStorage.data[G.STORE_KEY] = JSON.stringify({ id: '4', token: 'held' });
+  G.boot(win, dom.doc);
+  await tick(); await tick();
+  const read = calls.find((c) => c.url.endsWith('/conversations/4'));
+  assert.ok(read, 'GET …/conversations/:id on load');
+  assert.equal(read.headers['x-guide-token'], 'held');
+  // even with today's budget spent, the chat this browser holds is still theirs to see
+  assert.equal(click(dom, dom.node('a')), true);
+  await tick();
+  assert.ok(!calls.some((c) => c.method === 'POST'), 'no new chat started');
+  assert.equal(dom.scene.getAttribute('data-phase'), 'chat');
+  assert.equal(dom.parts.log.children.length, 2);
+});
+
+test('a held chat the server no longer has is forgotten', async () => {
+  const dom = makeDom();
+  const { win } = makeWin({ enabled: { 'front-door-guide': true } }, (url) => (url.endsWith('/status') ? { status: 200, body: { ok: true, mode: 'chat' } } : { status: 404, body: { ok: false, error: 'not_found' } }));
+  win.localStorage.data[G.STORE_KEY] = JSON.stringify({ id: '4', token: 'gone' });
+  G.boot(win, dom.doc);
+  await tick(); await tick();
+  assert.equal(win.localStorage.data[G.STORE_KEY], undefined);
+});
+
+test('a modified click (new tab) is never taken', async () => {
+  const dom = makeDom();
+  const { win } = makeWin({ enabled: { 'front-door-guide': true } }, () => ({ status: 200, body: { ok: true, mode: 'chat' } }));
+  G.boot(win, dom.doc);
+  await tick();
+  let prevented = false;
+  dom.fire(dom.doc, 'click', { target: { closest: () => dom.node('a') }, button: 0, ctrlKey: true, preventDefault() { prevented = true; }, defaultPrevented: false });
+  assert.equal(prevented, false);
+});
+
+// ── the markup and the sheet ──────────────────────────────────────────────────────
+test('both Start a project doors carry the guide hook and keep their href', () => {
+  const doors = [...HTML.matchAll(/<a class="door door--go" href="([^"]+)"( data-guide-door)?>Start a project<\/a>/g)];
+  assert.equal(doors.length, 2);
+  doors.forEach((d) => { assert.equal(d[1], '/projects?view=new'); assert.ok(d[2], 'carries data-guide-door'); });
+});
+
+test('the scene is markup, hidden, a labelled modal dialog, with the honeypot out of the tab order', () => {
+  assert.match(HTML, /<div class="gd" id="guide" role="dialog" aria-modal="true" aria-labelledby="gdTitle" hidden>/);
+  assert.match(HTML, /<input class="gd__hp" type="text" name="website" data-gd="website" tabindex="-1" autocomplete="off" aria-hidden="true">/);
+  assert.match(HTML, /<label class="vh" for="gdText">Your message<\/label>/);
+  assert.match(HTML, /data-gd="go" href="\/projects\?view=new">Sign up and get started<\/a>/);
+  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, /<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"/);
+  assert.ok(fs.existsSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'characters', 'patron.png')));
+});
+
+test('a signed-in visitor keeps the plain doors: the /me read takes the hook off', () => {
+  assert.match(HTML, /if \(!me \|\| !me\.github_login\) return;\n\s+\/\* the start-a-project guide is for a visitor who has not signed up \(task 1005275\) \*\/\n\s+document\.querySelectorAll\('\[data-guide-door\]'\)\.forEach\(function \(d\) \{ d\.removeAttribute\('data-guide-door'\); \}\);/);
+});
+
+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]);
+  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.equal(G.API, '/api/bongos/front-door-guide');
+});
+
+test('the sheet: the fifteen only, no :root, no dark rule of its own, no !important, motion inside the world switch', () => {
+  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, /:root/);
+  assert.doesNotMatch(code, /data-mode|prefers-color-scheme/);
+  assert.doesNotMatch(code, /!important/);
+  // the waiting dots animate; world.css (linked first on the landing) stops every animation
+  assert.match(code, /animation: gd-wait/);
+  const world = fs.readFileSync(path.join(LANDING, 'assets', 'world.css'), 'utf8');
+  assert.match(world, /prefers-reduced-motion: reduce[\s\S]*animation: none !important; transition: none !important;/);
+  assert.ok(HTML.indexOf('/assets/world.css') < HTML.indexOf('/assets/guide-scene.css'));
+});
+
+test('every control in the scene clears the 24px floor', () => {
+  for (const [sel, min] of [['.gd__x', /width: 40px; height: 40px/], ['.gd__send, .gd__go, .gd__planbtn', /min-height: 48px/], ['.gd__skip', /min-height: 24px/], ['.gd__more', /min-height: 40px/]]) {
+    const rule = CSS.slice(CSS.indexOf(sel + ' {'));
+    assert.match(rule.slice(0, rule.indexOf('}')), min, sel);
+  }
+});

package/tests/provisioning_app_status.mjs

@@ -193,6 +193,7 @@ await ta('it knocks only on an onrender.com address, and follows no redirect', a
 await ta('a sweep marks only answering apps live, compare-and-set on the state it read', async () => {
   const writes = [];
   const db = { query: async (sql, params) => {
+    if (/app_host->'sandbox'/.test(sql)) return { rows: [] }; // the sandbox read (task 1005289)
     if (/^\s*SELECT/.test(sql)) {
       assert.match(sql, /app_host->>'state' IN \('deploying', 'linked'\)/);
       return { rows: [
@@ -213,7 +214,7 @@ await ta('a sweep marks only answering apps live, compare-and-set on the state i
 await ta('the knocks run a few at a time, never all at once and never one by one', async () => {
   let inFlight = 0, peak = 0;
   const rows = Array.from({ length: 12 }, (_, i) => ({ id: i + 1, slug: `a${i}`, app_host: { state: 'deploying', serviceUrl: `https://a${i}.onrender.com` } }));
-  const db = { query: async (sql) => (/^\s*SELECT/.test(sql) ? { rows } : { rowCount: 1 }) };
+  const db = { query: async (sql) => (/app_host->'sandbox'/.test(sql) ? { rows: [] } : /^\s*SELECT/.test(sql) ? { rows } : { rowCount: 1 }) };
   const fetchImpl = async () => { inFlight++; peak = Math.max(peak, inFlight); await new Promise((r) => setTimeout(r, 5)); inFlight--; return res(200); };
   const out = await liveness.sweepOnce({ pool: db, fetchImpl, log: () => {} });
   assert.deepEqual(out, { checked: 12, live: 12 });
@@ -233,7 +234,7 @@ await ta('a run that starts while the previous sweep is in flight is skipped (ta
   const [firstOut, second] = await Promise.all([first, secondRun]);
   assert.deepEqual(second, { skipped: true });
   assert.deepEqual(firstOut, { checked: 0, live: 0 });
-  assert.equal(reads, 1, 'the overlapping run never touched the database');
+  assert.equal(reads, 2, 'the overlapping run never touched the database (the one run read the apps, then the sandboxes)');
   assert.deepEqual(await liveness.tick({ pool: { query: async () => ({ rows: [] }) }, log: () => {} }), { checked: 0, live: 0 },
     'once the first finished, the next run goes ahead');
 });

package/tests/provisioning_render_route.mjs

@@ -95,7 +95,7 @@ await ta('the owner queues it: ciphertext only, the request recorded on the row,
   assert.equal(r.status, 200, r.raw);
   assert.equal(enqueueCalls.length, 1);
   assert.equal(enqueueCalls[0].keyEnc, `v1.sealed(${KEY.length})`);
-  assert.deepEqual(enqueueCalls[0].appHost, { platform: 'render', mode: 'greenfield', ownerId: 'tea-abcdefgh1234', state: 'requested', error: null,
+  assert.deepEqual(enqueueCalls[0].appHost, { platform: 'render', mode: 'greenfield', ownerId: 'tea-abcdefgh1234', state: 'requested', error: null, sandboxWanted: true,
     runtime: 'node', startCommand: 'npm start', buildCommand: 'npm ci', database: true, webPlan: 'standard' });
   assert.equal(events.length, 1);
   noKeyAnywhere(enqueueCalls, events, r.body);

package/tests/provisioning_teardown_intent.mjs

@@ -256,6 +256,56 @@ await ta('a mid-flight provision is a 409 conflict — never the false "teardown
   assert.doesNotMatch(String(res.body.error.message), /already queued/i, 'the old lie is gone');
 });
 
+// The owner's Render key on a teardown removes the project's sandbox (task 1005289, ADR 0406 §7).
+const renderSandbox = require('../modules/provisioning/render-sandbox.js');
+const secretBox = require('../src/bongos/secret-box.js');
+let lentCalls = [];
+renderSandbox.lendKeyToTeardown = async (_db, intentId, keyEnc) => { lentCalls.push({ intentId, keyEnc }); return true; };
+function postWithKey(path, key) {
+  return new Promise((resolve, reject) => {
+    const req = http.request(`${base}${path}`, { method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': 2, 'x-render-key': key } }, (res) => {
+      let d = ''; res.on('data', (c) => { d += c; });
+      res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(d), raw: d }));
+    });
+    req.on('error', reject);
+    req.end('{}');
+  });
+}
+const RKEY = 'rnd_abcdefghijklmnopqrstuvwx';
+console.log('\nPOST /provisioning/instances/:id/teardown — the Render key for the sandbox:');
+await ta('a well-formed key is sealed and lent to the teardown just queued, never echoed', async () => {
+  const realConf = secretBox.isConfigured, realEnc = secretBox.encrypt;
+  secretBox.isConfigured = () => true; secretBox.encrypt = (p) => `v1.sealed(${p.length})`;
+  try {
+    lentCalls = [];
+    teardownOutcome = { intent: { id: 31, action: 'teardown', state: 'pending' }, created: true, superseded: false };
+    const res = await postWithKey('/provisioning/instances/16/teardown', RKEY);
+    assert.equal(res.status, 200, res.raw);
+    assert.equal(res.body.sandbox_key_lent, true);
+    assert.deepEqual(lentCalls, [{ intentId: 31, keyEnc: `v1.sealed(${RKEY.length})` }], 'ciphertext only, on THIS teardown');
+    assert.ok(!res.raw.includes(RKEY), 'the key is never sent back');
+  } finally { secretBox.isConfigured = realConf; secretBox.encrypt = realEnc; }
+});
+await ta('a malformed key, an already-queued teardown, or no safe seal: nothing lent, the teardown still answers', async () => {
+  const realConf = secretBox.isConfigured, realEnc = secretBox.encrypt;
+  secretBox.encrypt = (p) => `v1.sealed(${p.length})`;
+  try {
+    secretBox.isConfigured = () => true;
+    lentCalls = [];
+    teardownOutcome = { intent: { id: 32, action: 'teardown', state: 'pending' }, created: true, superseded: false };
+    let res = await postWithKey('/provisioning/instances/16/teardown', 'not-a-key');
+    assert.equal(res.status, 200); assert.equal(res.body.sandbox_key_lent, false);
+    teardownOutcome = { intent: { id: 32, action: 'teardown', state: 'pending' }, created: false, superseded: false };
+    res = await postWithKey('/provisioning/instances/16/teardown', RKEY);
+    assert.equal(res.status, 200); assert.equal(res.body.sandbox_key_lent, false, 'not on a teardown queued earlier');
+    secretBox.isConfigured = () => false;
+    teardownOutcome = { intent: { id: 33, action: 'teardown', state: 'pending' }, created: true, superseded: false };
+    res = await postWithKey('/provisioning/instances/16/teardown', RKEY);
+    assert.equal(res.status, 200); assert.equal(res.body.sandbox_key_lent, false, 'never stored unsealed');
+    assert.equal(lentCalls.length, 0);
+  } finally { secretBox.isConfigured = realConf; secretBox.encrypt = realEnc; }
+});
+
 console.log('\nPOST /provisioning/instances/:id/force-teardown — same truthful mapping (archon):');
 
 await ta('force-teardown surfaces the same 409 conflict instead of a false success', async () => {

package/tests/render_api.mjs

@@ -127,10 +127,13 @@ await ta('listOwners returns every workspace the key reaches, unwrapped', async
 });
 
 console.log('\nno delete:');
-await ta('there is no delete method, and the verb is refused', async () => {
+await ta('there is no delete method but the sandbox one, and the verb is refused', async () => {
   const { api, calls } = live({});
   const methods = Object.getOwnPropertyNames(RenderApi.prototype);
-  assert.ok(!methods.some((m) => /delete|destroy|remove|suspend/i.test(m)), `no destructive method: ${methods.join(', ')}`);
+  // ADR 0406 §7 / task 1005289: the ONE destructive method removes a free `…-sandbox`
+  // service the platform made (tests/render_sandbox.mjs proves it refuses anything else).
+  const destructive = methods.filter((m) => /delete|destroy|remove|suspend/i.test(m));
+  assert.deepEqual(destructive, ['deleteSandboxService'], `no other destructive method: ${methods.join(', ')}`);
   await assert.rejects(api._req('DELETE', '/services/srv-1'), /never deletes/);
   assert.equal(calls.length, 0);
 });