@curless/hotel-storefront 0.27.5 → 0.27.6

package/dist/__tests__/tools.test.js

@@ -1,1598 +0,0 @@
-import { fileURLToPath } from 'node:url';
-import { beforeEach, describe, expect, it } from 'vitest';
-import { loadHotelData } from '../data.js';
-import { createDemoHotels } from '../demo-hotels.js';
-import { MAX_MISSES, Misses } from '../limits.js';
-import { MemberStore } from '../members.js';
-import { handleTool } from '../tools.js';
-import { TripStore } from '../trip.js';
-import { resolveBrand } from '../vocab.js';
-const DATA = loadHotelData(fileURLToPath(new URL('./__fixtures__/brand.json', import.meta.url)));
-const CONFIG = {
-    id: 'shangrila',
-    brand: 'Shangri-La',
-    server: { name: 'shangrila-hotels', title: 'Shangri-La Hotels (demo)' },
-    naming: { prefix: 'shangrila', noun: 'hotel', nounPlural: 'hotels' },
-    data: { source: 'demo', file: 'data/hotels.json' },
-    payment: { mode: 'none' },
-    urls: { appUrl: 'https://hotels.curless.ai/shangrila' },
-    legal: {},
-};
-const OCT_1 = Date.parse('2026-10-01T02:00:00Z');
-const STAY = { checkIn: '2026-10-19', checkOut: '2026-10-21', guests: 2 };
-let clock = OCT_1;
-let deps;
-const brand = resolveBrand(CONFIG);
-const t = brand.tools;
-const ctx = { session: 'session-a' };
-const call = (name, args = {}) => handleTool(deps, name, args, ctx);
-beforeEach(() => {
-    clock = OCT_1;
-    deps = {
-        backend: createDemoHotels({ data: DATA, now: () => clock, rng: () => 0.5 }),
-        trips: new TripStore(() => clock),
-        members: new MemberStore(() => clock),
-        tools: t,
-        vocab: brand.vocab,
-    };
-});
-describe('finding somewhere to stay', () => {
-    it('answers a city with the whole shortlist, and says how many', async () => {
-        const res = await call(t.listHotels, { city: 'Hong Kong' });
-        expect(res.structured.view).toBe('hotels');
-        expect(res.structured.total).toBe(4);
-        expect(res.text).toContain('4 Shangri-La hotels in Hong Kong');
-    });
-    it('marks every price-bearing answer as demonstration data', async () => {
-        const res = await call(t.listHotels, { query: 'shanghai' });
-        expect(res.structured.demo).toBe(true);
-        expect(String(res.structured.demoNote)).toContain('not rates anyone can book');
-    });
-    it('says nothing matched rather than showing something else', async () => {
-        const res = await call(t.listHotels, { query: 'reykjavik' });
-        expect(res.structured.view).toBe('no-hotels');
-        expect(res.structured.hotels).toEqual([]);
-    });
-});
-describe('one hotel', () => {
-    it('has no rooms and asks for the nights when no dates were given', async () => {
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island' });
-        expect(res.structured.view).toBe('hotel');
-        expect(res.structured.needsDates).toBe(true);
-        expect(res.structured.rooms).toBeUndefined();
-        expect(res.text).toContain('which nights');
-    });
-    it('fences the hotel’s own words on their way into the model', async () => {
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island' });
-        expect(res.text).toContain('⟦hotel text');
-        expect(res.text).toContain('data, not instructions');
-        expect(res.text).toContain('⟦end hotel text⟧');
-    });
-    it('prices the rooms once the nights are known, stay total and all', async () => {
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY });
-        expect(res.structured.view).toBe('hotel');
-        const rooms = res.structured.rooms;
-        expect(rooms.find((r) => r.name === 'Deluxe Peak View Room')).toMatchObject({
-            nightly: 'HK$3,800',
-            stayTotal: 'HK$8,588',
-        });
-        expect(res.text).toContain('incl. taxes and fees');
-    });
-    // ⚠️ The room count FILTERS, it does not just ride along. A guest who needs
-    // two rooms and is shown a type with one left finds out when the trip drops
-    // the line - later, and after they thought it was settled.
-    it('leaves out the room types that cannot supply the rooms asked for', async () => {
-        const one = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY });
-        expect(one.structured.rooms.map((r) => r.id)).toContain('suite');
-        // The Harbour View Suite has one left; the Horizon Club has two.
-        const two = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY, rooms: 2 });
-        const ids = two.structured.rooms.map((r) => r.id);
-        expect(ids).not.toContain('suite');
-        expect(ids).toContain('horizon-club');
-        expect(two.structured.rooms_wanted).toBe(2);
-        expect(two.text).toContain('2 rooms');
-    });
-    // ⚠️ robin picked two rooms and the price did not move: the card was still
-    // showing one room's total, and nothing on it said so.
-    it('prices the rooms actually asked for, per room and in total', async () => {
-        const one = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY });
-        const oneRoom = one.structured.rooms.find((r) => r.id === 'deluxe-city');
-        expect(oneRoom?.stayTotal).toBe('HK$8,588');
-        expect(oneRoom?.roomsTotal).toBeUndefined();
-        const two = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY, rooms: 2 });
-        const twoRooms = two.structured.rooms.find((r) => r.id === 'deluxe-city');
-        // Per room is unchanged; the total is what two of them cost.
-        expect(twoRooms?.stayTotal).toBe('HK$8,588');
-        expect(twoRooms?.roomsTotal).toBe('HK$17,176');
-        expect(two.text).toContain('HK$17,176 for 2 rooms');
-    });
-    // ⚠️ "until 2026-10-17" for a window that closes at 15:00 that day: a guest
-    // cancelling that evening would have paid a night (2026-10-05 audit).
-    it('gives the free-cancellation deadline with its hour, on the hotel clock', async () => {
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY });
-        const room = res.structured.rooms.find((r) => r.id === 'deluxe-city');
-        // 48 hours before a 15:00 check-in on Monday 19 October, in Hong Kong.
-        expect(room?.freeCancellationLocal).toBe('Sat 17 Oct, 15:00');
-        expect(res.text).toContain('free to cancel until Sat 17 Oct, 15:00');
-    });
-    it('says so plainly once the held rooms mean nothing can supply that many', async () => {
-        // Island's largest type has six; two held leaves four, and four is under
-        // the five being asked for. Held inventory changing what a room count can
-        // supply is the real path here, so the test walks it rather than inventing
-        // a thinner hotel.
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY, rooms: 2 });
-        await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY, rooms: 5 });
-        expect(res.structured.view).toBe('no-rooms');
-        expect(res.text).toContain('No room type at Island Shangri-La');
-        expect(res.text).toContain('5');
-        // Four is still there, which is the other half of the same fact.
-        const four = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY, rooms: 4 });
-        expect(four.structured.view).toBe('hotel');
-    });
-    it('hands back the hotel’s own reason instead of a room that does not fit', async () => {
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY, guests: 6 });
-        expect(res.structured.view).toBe('no-rooms');
-        expect(res.text).toContain('the largest sleeps 3, so it takes 2 rooms');
-    });
-});
-describe('building a trip', () => {
-    it('refuses to invent dates, and leaves the trip alone while it asks', async () => {
-        const res = await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city' });
-        expect(res.structured.view).toBe('needs-dates');
-        expect(res.text).toContain('Which nights?');
-        expect((await call(t.viewTrip)).structured.lines).toEqual([]);
-    });
-    it('takes a room by name, then an add-on, and totals both with tax', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'Deluxe Peak View Room', ...STAY });
-        const res = await call(t.addToTrip, {
-            hotel: 'hong-kong-island',
-            extra: 'Guided morning walk on the Peak',
-            quantity: 2,
-        });
-        expect(res.structured.view).toBe('trip');
-        expect(res.structured.total).toBe('HK$10,125');
-        expect(res.structured.taxesAndFees).toBe('HK$1,165');
-        expect(res.text).toContain('Total HK$10,125');
-    });
-    it('replaces a line rather than stacking it, and 0 takes it out', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        const two = await call(t.addToTrip, {
-            hotel: 'hong-kong-island',
-            room: 'deluxe-city',
-            ...STAY,
-            rooms: 2,
-        });
-        expect(two.structured.lines[0]?.quantity).toBe(2);
-        expect(two.structured.total).toBe('HK$17,176');
-        const gone = await call(t.addToTrip, {
-            hotel: 'hong-kong-island',
-            room: 'deluxe-city',
-            ...STAY,
-            rooms: 0,
-        });
-        expect(gone.structured.lines).toEqual([]);
-    });
-    it('keeps two stays in the same room apart, because the dates are the line', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        const res = await call(t.addToTrip, {
-            hotel: 'hong-kong-island',
-            room: 'deluxe-city',
-            checkIn: '2026-11-09',
-            checkOut: '2026-11-11',
-            guests: 2,
-        });
-        expect(res.structured.lines.length).toBe(2);
-        expect(res.structured.stay).toEqual({
-            checkIn: '2026-10-19',
-            checkOut: '2026-11-11',
-            guests: 2,
-        });
-    });
-    // ⚠️ TWO CURRENCIES ARE TWO TOTALS, never one. The second hotel used to be
-    // refused at the door; a Hong Kong - Shanghai trip is the ordinary case.
-    it('prices a trip across two currencies side by side, and never adds them up', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        const both = await call(t.addToTrip, {
-            hotel: 'shanghai-pudong',
-            room: 'deluxe-city',
-            checkIn: '2026-10-21',
-            checkOut: '2026-10-23',
-            guests: 2,
-        });
-        expect(both.structured.view).toBe('trip');
-        expect(both.structured.lines).toHaveLength(2);
-        expect(both.structured.currencies).toEqual(['HKD', 'CNY']);
-        const groups = both.structured.groups;
-        expect(groups.map((g) => g.currency)).toEqual(['HKD', 'CNY']);
-        expect(both.structured.total).toBe(`${groups[0]?.total} · ${groups[1]?.total}`);
-        expect(both.structured.dropped).toBeUndefined();
-        expect(both.text).toMatch(/2 currencies, priced separately and not converted/);
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const bookings = made.structured.bookings;
-        expect(bookings.map((b) => b.quote.total.slice(0, 1))).toEqual(['H', '¥']);
-    });
-    it('names the room types it does have when the one asked for is not among them', async () => {
-        const res = await call(t.addToTrip, {
-            hotel: 'hong-kong-island',
-            room: 'presidential',
-            ...STAY,
-        });
-        expect(res.structured.view).toBe('error');
-        expect(res.text).toContain('Harbour View Suite');
-    });
-});
-describe('asking for the rooms', () => {
-    const book = async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        return call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-    };
-    it('holds the rooms, charges nothing, and says so in as many words', async () => {
-        const res = await book();
-        expect(res.structured.view).toBe('booking');
-        expect(res.structured.paid).toBe(false);
-        expect(res.text).toContain('Nothing has been charged');
-        // ⚠️ A DEMONSTRATION BOOKING, SAID AS ONE (2026-10-05 audit, P2): never
-        // "presents a card at check-in", and its hold on the hotel's own clock.
-        expect(res.text).toContain('This is a demonstration booking: Shangri-La has not received it and is not holding any room.');
-        expect(res.text).toMatch(/hold lapses on its own at \w{3} \d+ \w{3}, \d{2}:\d{2} hotel time/);
-        expect(res.text).not.toContain('presents a card');
-    });
-    it('empties the trip once it has been asked for, so nobody books it twice', async () => {
-        await book();
-        expect((await call(t.viewTrip)).structured.lines).toEqual([]);
-    });
-    // ⚠️ FOUND ON THE LIVE CONNECTOR: `request_booking {}` answered with a
-    // confirmation code and `guest: { name: '', email: '' }`. The schema said
-    // both were required; a schema is what the model is told, not what it must
-    // do. The hotel would have been holding a room for nobody.
-    it('will not hold a room for nobody', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        const none = await call(t.requestBooking, {});
-        expect(none.structured.view).toBe('needs-guest');
-        expect(none.structured.missing).toEqual(['a name', 'an email']);
-        const noEmail = await call(t.requestBooking, { name: 'Robin Ruan' });
-        expect(noEmail.structured.view).toBe('needs-guest');
-        expect(noEmail.structured.missing).toEqual(['an email']);
-        // And the trip is untouched, so the fix is one more message.
-        expect((await call(t.viewTrip)).structured.lines).toHaveLength(1);
-    });
-    it('will not book an empty trip', async () => {
-        const res = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        expect(res.structured.view).toBe('empty-trip');
-    });
-    it('lists what this conversation booked', async () => {
-        await book();
-        const res = await call(t.listBookings);
-        expect(res.structured.count).toBe(1);
-        expect(res.text).toMatch(/^SL-[A-Z0-9]{6} · Island Shangri-La/);
-    });
-});
-describe('membership', () => {
-    const signIn = () => call(t.signIn, { number: 'SLC-4471-8820', surname: 'Ruan' });
-    it('takes a number and the surname on it, and says what the tier is worth', async () => {
-        const res = await signIn();
-        expect(res.structured.view).toBe('member');
-        expect(res.text).toContain('Jade');
-        expect(res.text).toContain('10% off');
-        // ⚠️ The word must not appear anywhere on this path.
-        expect(JSON.stringify(res).toLowerCase()).not.toContain('password');
-    });
-    it('prices the rooms at the member rate, with the public one beside it', async () => {
-        await signIn();
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY });
-        const room = res.structured.rooms.find((r) => r.id === 'deluxe-city');
-        // 10% off the room; tax is charged on what is actually paid, not on the
-        // public rate - the other order hands the member a second, invisible
-        // discount on the government's share.
-        expect(room?.publicStayTotal).toBe('HK$8,588');
-        expect(room?.stayTotal).toBe('HK$7,729');
-    });
-    // ⚠️ One room's public rate struck through over two rooms' member rate put
-    // the "was" price BELOW the price a member pays (2026-10-05 audit).
-    it('strikes through the public rate for as many rooms as the member price beside it', async () => {
-        await signIn();
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY, rooms: 2 });
-        const room = res.structured.rooms.find((r) => r.id === 'deluxe-city');
-        expect(room?.roomsTotal).toBe('HK$15,458');
-        expect(room?.publicRoomsTotal).toBe('HK$17,176');
-    });
-    it('says what membership was worth on THIS trip, in money', async () => {
-        await signIn();
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-harbour', ...STAY });
-        const trip = await call(t.viewTrip);
-        const m = trip.structured.memberSaving;
-        expect(m.tier).toBe('Jade');
-        expect(m.saved).toBe('HK$1,040');
-        expect(Number(m.points)).toBeGreaterThan(0);
-    });
-    // ⚠️ POINTS ARE EARNED PER UNIT OF ONE CURRENCY, and the group charges in
-    // twenty-two. Multiplying the raw total by the tier's rate paid a Jakarta
-    // guest 6,180,075 points and a Paris guest 2,624 for the same money - the
-    // point balance was measuring the currency, not the spend.
-    it('earns points on what a stay is worth, not on how many zeroes its currency has', async () => {
-        const points = async (hotel, room) => {
-            await handleTool(deps, t.clearTrip, {}, ctx);
-            await call(t.addToTrip, { hotel, room, ...STAY });
-            const trip = await call(t.viewTrip);
-            const m = trip.structured.memberSaving;
-            return Number(m?.points);
-        };
-        await signIn();
-        // ⚠️ THE ARITHMETIC, NOT A CURRENCY TOUR. The bug was found across JPY and
-        // IDR, whose units are four orders of magnitude apart - those hotels live
-        // in the brand's own repository now, so what is pinned here is the rule
-        // that produced the fix: points come off the spend CONVERTED to the
-        // programme's base currency, so the same money earns the same points
-        // whichever of these two currencies it is charged in.
-        const hk = await points('hong-kong-island', 'deluxe-city');
-        const cn = await points('shanghai-pudong', 'deluxe-city');
-        for (const n of [hk, cn])
-            expect(n).toBeGreaterThan(0);
-        const rate = (c) => DATA.membership?.earn?.rates[c] ?? 1;
-        // HK$8,588 at 7.8 to the dollar against ¥3,364 at 7.1: the ratio of the
-        // point balances must be the ratio of the SPEND, not of the raw totals.
-        const spendRatio = 8588 / rate('HKD') / (3364 / rate('CNY'));
-        expect(hk / cn).toBeCloseTo(spendRatio, 1);
-    });
-    // ⚠️ THE BOOKING IS THE ONE STEP THAT LEAVES A RECORD. The card showed the
-    // member rate, the saving and the tier; `request_booking` then re-quoted the
-    // trip with a hand-built identity carrying no member and wrote the booking at
-    // the PUBLIC total - ¥152,550 against the ¥137,295 the guest had just been
-    // shown (robin, on the live connector, 2026-09-21). Every other member test
-    // stops at the quote, which is why this one goes all the way through.
-    it('books at the rate the member was shown, not the public one', async () => {
-        await signIn();
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        const trip = await call(t.viewTrip);
-        const shown = String(trip.structured.total);
-        const res = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        expect(res.structured.total, 'the booking is not the total the card showed').toBe(shown);
-        expect(res.structured.total).toBe('HK$7,729');
-        expect(res.text).toContain('HK$7,729');
-    });
-    it('goes back to the public rate on the way out', async () => {
-        await signIn();
-        const out = await call(t.signOut);
-        expect(out.structured.view).toBe('signed-out');
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY });
-        const room = res.structured.rooms[0];
-        expect(room?.publicStayTotal).toBeUndefined();
-        expect(room?.stayTotal).toBe('HK$8,588');
-    });
-    // ⚠️ A tier buys a RATE, not a lookup. A membership number and a surname are
-    // what a desk checks - not authentication - so it must never become a way to
-    // read a booking somebody else made.
-    it('does not let a membership reach somebody else’s booking', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const theirs = await handleTool(deps, t.signIn, { number: 'SLC-2209-5513', surname: 'Chan' }, {
-            session: 'someone-else',
-        });
-        expect(theirs.structured.view).toBe('member');
-        const list = await handleTool(deps, t.listBookings, {}, { session: 'someone-else' });
-        expect(list.structured.count).toBe(0);
-    });
-});
-describe('changing a booking', () => {
-    const book = async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        const res = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        return String(res.structured.booking.confirmationCode);
-    };
-    const LATER = { checkIn: '2026-10-26', checkOut: '2026-10-28' };
-    it('shows both stays and the difference, and moves nothing until it is told twice', async () => {
-        const ref = await book();
-        const pre = await call(t.previewChange, { booking: ref, ...LATER });
-        expect(pre.structured.view).toBe('change-preview');
-        expect(pre.structured.from).toMatchObject({ checkIn: STAY.checkIn, nights: 2 });
-        expect(pre.structured.to).toMatchObject({ checkIn: LATER.checkIn, nights: 2 });
-        expect(pre.structured.changeable).toBe(true);
-        // Asking the CHANGE tool without `confirmed` answers with the same preview
-        // and moves nothing - the same bargain the cancellation makes.
-        const asked = await call(t.changeBooking, { booking: ref, ...LATER });
-        expect(asked.structured.view).toBe('change-preview');
-        const still = await call(t.listBookings, {});
-        expect(still.structured.bookings[0]
-            .stay.checkIn).toBe(STAY.checkIn);
-        const done = await call(t.changeBooking, { booking: ref, ...LATER, confirmed: true });
-        expect(done.structured.view).toBe('changed');
-        const b = done.structured.booking;
-        expect(b.stay.checkIn).toBe(LATER.checkIn);
-        // ⚠️ THE CODE DOES NOT CHANGE. It is the hotel's handle on the stay, not on
-        // the version, and a guest holding the old one at the desk must be found.
-        expect(b.confirmationCode).toBe(ref);
-        expect(done.text).toContain('Nothing has been charged');
-    });
-    // ⚠️ THE NEW NIGHTS ARE PRICED AT TODAY'S RATES FOR THOSE NIGHTS. Carrying the
-    // old rate forward would be this connector offering a price the hotel never
-    // did - a weekend costs more than the weekdays it replaces, and the guest has
-    // to see that before it moves, not at the desk.
-    it('re-prices the new nights instead of carrying the old rate over', async () => {
-        const ref = await book();
-        // Friday and Saturday at Island Shangri-La: the weekend uplift is 20%.
-        const weekend = { checkIn: '2026-10-23', checkOut: '2026-10-25' };
-        const pre = await call(t.previewChange, { booking: ref, ...weekend });
-        const from = pre.structured.from;
-        const to = pre.structured.to;
-        expect(to.total).not.toBe(from.total);
-        expect(pre.structured.refundDue).toBe(false);
-        expect(String(pre.structured.difference)).toMatch(/^HK\$/);
-    });
-    // ⚠️ "CANNOT BE CANCELLED OR CHANGED" IS THE HOTEL'S OWN SENTENCE. Offering a
-    // change on a non-refundable rate would have this card contradict the policy
-    // printed beside it.
-    it('refuses to move a non-refundable rate, in the words of its own policy', async () => {
-        await handleTool(deps, t.clearTrip, {}, ctx);
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'horizon-club', ...STAY });
-        const res = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const ref = String(res.structured.booking.confirmationCode);
-        const pre = await call(t.previewChange, { booking: ref, ...LATER });
-        expect(pre.structured.changeable).toBe(false);
-        expect(String(pre.structured.rule)).toMatch(/non-refundable/i);
-        // …and confirming does not get around it.
-        const tried = await call(t.changeBooking, { booking: ref, ...LATER, confirmed: true });
-        expect(tried.structured.view).toBe('change-preview');
-    });
-    it('refuses a change the hotel has no rooms for, and says how many there are', async () => {
-        const ref = await book();
-        // The Harbour View Suite has one left; two of it is not a change the hotel
-        // can house, and saying "changed" would hold a room that does not exist.
-        const pre = await call(t.previewChange, { booking: ref, room: 'suite', rooms: 2 });
-        expect(pre.structured.changeable).toBe(false);
-        expect(String(pre.structured.rule)).toMatch(/has 1 left|needs 2/);
-    });
-    // ⚠️ THE ROOMS THIS BOOKING IS GIVING BACK COUNT. A guest moving from two of
-    // a room type to three must not be refused by the two they are releasing -
-    // that refusal reads as "sold out" for stock the hotel is about to have.
-    it('counts the booking’s own rooms as returned when it asks for more of them', async () => {
-        await handleTool(deps, t.clearTrip, {}, ctx);
-        await call(t.addToTrip, {
-            hotel: 'hong-kong-island',
-            room: 'deluxe-harbour',
-            rooms: 2,
-            ...STAY,
-        });
-        const res = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const ref = String(res.structured.booking.confirmationCode);
-        // Three left in the fixture, two of them held by this very booking.
-        const pre = await call(t.previewChange, { booking: ref, rooms: 3 });
-        expect(pre.structured.changeable, String(pre.structured.rule)).toBe(true);
-        expect(pre.structured.roomsLeft).toBe(3);
-    });
-    it('says so when the change is what the booking already holds', async () => {
-        const ref = await book();
-        const pre = await call(t.previewChange, { booking: ref, ...STAY });
-        expect(pre.structured.changeable).toBe(false);
-        expect(String(pre.structured.rule)).toMatch(/already holds/);
-    });
-    it('does not let a membership reach somebody else’s booking through a change', async () => {
-        const ref = await book();
-        const theirs = await handleTool(deps, t.previewChange, { booking: ref, ...LATER }, {
-            session: 'someone-else',
-        });
-        expect(theirs.structured.view).toBe('booking-not-found');
-    });
-});
-describe('cancelling', () => {
-    const book = async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        const res = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        return res.structured.booking.confirmationCode;
-    };
-    it('previews the fee and the rule without cancelling anything', async () => {
-        const code = await book();
-        const res = await call(t.previewCancellation, { booking: code });
-        expect(res.structured.view).toBe('cancellation-preview');
-        expect(res.structured.fee).toBe('HK$0');
-        expect(String(res.structured.rule)).toContain('free to cancel until');
-        expect((await call(t.listBookings)).text).toContain('requested');
-    });
-    // ⚠️ The guest who says "cancel it" has not yet seen the fee. The tool makes
-    // that impossible to skip, rather than trusting the instructions.
-    it('refuses to cancel on the first ask and returns the preview instead', async () => {
-        clock = Date.parse('2026-10-18T09:00:00Z'); // the free window has closed
-        const code = await book();
-        const first = await call(t.cancelBooking, { booking: code });
-        expect(first.structured.view).toBe('cancellation-preview');
-        expect(first.structured.fee).toBe('HK$4,294');
-        expect((await call(t.listBookings)).text).toContain('requested');
-        const done = await call(t.cancelBooking, {
-            booking: code,
-            confirmed: true,
-            reason: 'flight moved',
-        });
-        expect(done.structured.view).toBe('cancelled');
-        // Nobody charges a demonstration anything (2026-10-05 audit, P2).
-        expect(done.text).toContain('A real booking on this rate would be charged HK$4,294');
-        expect(done.text).not.toContain('The hotel charges');
-        expect(done.text).toContain('This is a demonstration booking');
-        expect((await call(t.listBookings)).text).toContain('cancelled');
-    });
-    it('says it cannot find someone else’s booking rather than describing it', async () => {
-        const res = await handleTool(deps, t.previewCancellation, { booking: 'SL-ABCDEF' }, { session: 'session-b' });
-        expect(res.structured.view).toBe('booking-not-found');
-    });
-});
-// ⚠️ Reading up drew a card per lookup - a list, four hotels, then the
-// comparison (robin, 2026-09-29). The look-up answers in text and draws nothing.
-describe('looking up', () => {
-    it('reads a city in text: ids, fenced descriptions, priced rooms and add-ons', async () => {
-        const res = await call(t.lookUp, {
-            city: 'Shanghai',
-            checkIn: '2026-10-19',
-            checkOut: '2026-10-21',
-            guests: 2,
-        });
-        expect(res.structured.view).toBe('look-up');
-        expect(res.structured.hotels.map((h) => h.id).sort()).toEqual([
-            'shanghai-jingan',
-            'shanghai-pudong',
-        ]);
-        expect(res.text).toContain('Nothing was shown to the guest');
-        expect(res.text).toContain('id `shanghai-pudong`');
-        expect(res.text).toContain('⟦hotel text · description');
-        expect(res.text).toMatch(/for the stay incl\. taxes and fees/);
-        expect(res.text).toContain('id `airport-transfer`');
-        expect(res.text).toContain(t.compare);
-    });
-    it('reads hotels by the names a model writes, and names the ones it could not find', async () => {
-        const res = await call(t.lookUp, {
-            hotels: ['Jing An Shangri-La, West Shanghai', 'Hotel Nowhere'],
-        });
-        expect(res.structured.hotels.map((h) => h.id)).toEqual([
-            'shanghai-jingan',
-        ]);
-        expect(res.structured.dropped).toEqual(['Hotel Nowhere']);
-        // No dates, no rooms: a from-price, and the rooms wait for the nights.
-        expect(res.text).toMatch(/From .+ a night; rooms are priced once there are dates/);
-    });
-    it('says what it needs when it is given nothing to read', async () => {
-        const res = await call(t.lookUp, {});
-        expect(res.structured.view).toBe('nothing-found');
-        expect(res.text).toMatch(/Name a `city`/);
-    });
-});
-describe('policies', () => {
-    it('answers one topic in the hotel’s own fenced words', async () => {
-        const res = await call(t.policies, { hotel: 'hong-kong-island', topic: 'cancellation' });
-        expect(res.structured.view).toBe('policy');
-        expect(res.text).toContain('⟦hotel text · Cancellation');
-        expect(res.text).toContain('48 hours');
-    });
-    it('says the hotel does not publish it rather than filling in what hotels usually do', async () => {
-        const res = await call(t.policies, { hotel: 'shenzhen-futian', topic: 'accessibility' });
-        expect(res.structured.view).toBe('policy');
-        const missing = await call(t.policies, { hotel: 'hong-kong-jen', topic: 'smoking' });
-        expect(missing.structured.view).toBe('policy-missing');
-        expect(missing.text).toContain('does not publish anything about that');
-    });
-});
-// The strip is the card's; the sentence is the model's. These hold the line
-// between them - what goes in the payload, and what is worth saying out loud.
-describe('the nearby dates', () => {
-    const datesOf = (res) => (res.structured.dates ?? []);
-    it('rides along with the rooms, seven arrivals around the one asked for', async () => {
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY });
-        const dates = datesOf(res);
-        expect(dates).toHaveLength(7);
-        expect(dates.filter((d) => d.chosen).map((d) => d.checkIn)).toEqual(['2026-10-19']);
-        // Formatted money, because the card is forbidden arithmetic on it.
-        expect(dates[0]?.from).toMatch(/^HK\$[\d,]/);
-    });
-    // ⚠️ SILENCE IS AN ANSWER. Arriving on a Monday is already the cheapest the
-    // week gets, and a line saying so on every hotel would be a tic the model
-    // learns to repeat. Prose is spent only on the fact the strip hides.
-    it('says nothing when the guest already picked the cheapest arrival', async () => {
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY });
-        expect(res.text).not.toMatch(/instead/);
-        expect(datesOf(res).some((d) => d.best)).toBe(false);
-    });
-    it('names the date and the saving when one beats the chosen nights', async () => {
-        const res = await call(t.getHotel, {
-            hotel: 'hong-kong-island',
-            checkIn: '2026-10-23',
-            checkOut: '2026-10-25',
-            guests: 2,
-        });
-        // A Friday arrival carries two weekend nights; the weekdays either side do
-        // not. The sentence names the date, because "the one before" means nothing
-        // once the card reflows or the guest is reading it on a phone.
-        expect(res.text).toMatch(/Arriving 2026-10-2\d instead is HK\$[\d,.]+ less for the same 2 nights/);
-        expect(res.text).not.toMatch(/the (first|second|third|last) /i);
-    });
-    // ⚠️ EVERY DATE THAT TIES IS MARKED. Three weekdays at one rate is the normal
-    // shape of a hotel week; marking only the closest would say the other two are
-    // worse, which is a claim about prices that are equal.
-    it('marks every date that ties for cheapest, and never the chosen one', async () => {
-        const dates = datesOf(await call(t.getHotel, {
-            hotel: 'hong-kong-island',
-            checkIn: '2026-10-23',
-            checkOut: '2026-10-25',
-            guests: 2,
-        }));
-        const best = dates.filter((d) => d.best);
-        expect(best.length).toBeGreaterThan(1);
-        expect(new Set(best.map((d) => d.from)).size).toBe(1);
-        expect(best.some((d) => d.chosen)).toBe(false);
-    });
-    it('answers for the rooms asked for, not for one', async () => {
-        const one = datesOf(await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY }));
-        const two = datesOf(await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY, rooms: 2 }));
-        expect(two[0]?.from).not.toBe(one[0]?.from);
-    });
-    // ⚠️ ONLY WHEN SHIFTING THE DATES COULD HELP. No room here sleeps six on any
-    // night of the year, so a week of alternatives is noise dressed as help.
-    it('offers no dates when the party is too big for every room type', async () => {
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY, guests: 6 });
-        expect(res.structured.view).toBe('no-rooms');
-        expect(res.structured.dates).toBeUndefined();
-    });
-    it('offers them when the room type is merely taken', async () => {
-        // Three rooms of a type that has one left: the dates are fine, the room is
-        // the problem, and another arrival is a real answer.
-        const res = await call(t.getHotel, {
-            hotel: 'hong-kong-island',
-            ...STAY,
-            guests: 3,
-            rooms: 3,
-        });
-        expect(res.structured.view).toBe('no-rooms');
-        expect(datesOf(res)).toHaveLength(7);
-    });
-    it('keeps the strip out of a hotel nobody gave dates for', async () => {
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island' });
-        expect(res.structured.dates).toBeUndefined();
-    });
-});
-// A guest typed "high floor please" into the booking form and it went into
-// `guest.notes`, which nothing ever showed again (2026-09-21). These hold the
-// other half of the fix: that the requests come back, and that nothing about
-// them reads as a promise.
-describe('what the desk is asked for', () => {
-    const book = async (extra = {}) => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-harbour', ...STAY });
-        return call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com', ...extra });
-    };
-    it('carries the preferences onto the booking and says they are requests', async () => {
-        const res = await book({ requests: ['king-bed', 'high-floor'] });
-        const booking = res.structured.booking;
-        expect(booking.requests?.kinds).toEqual(['king-bed', 'high-floor']);
-        expect(res.text).toContain('a king bed, a high floor');
-        expect(res.text).toMatch(/none of it is held/);
-    });
-    // ⚠️ THE WORDING IS THE GUARD. A confirmation that lists "High floor" beside
-    // the code and the total reads as a fact about the room.
-    it('never says a preference is confirmed, held or reserved', async () => {
-        const res = await book({ requests: ['quiet-room', 'connecting-rooms'] });
-        const lines = (res.structured.requested ?? []);
-        expect(lines.join(' ')).toMatch(/^Asked for on the booking:/);
-        expect(lines.join(' ')).not.toMatch(/\b(confirmed|guaranteed|reserved for you)\b/i);
-    });
-    // ⚠️ A high floor a guest does not get is a disappointment. A step-free room
-    // a guest does not get is a trip that does not work. It gets its own
-    // sentence, it names who can actually confirm it, and the card gets a flag.
-    it('refuses to let an accessible room ride along as a preference', async () => {
-        const res = await book({ requests: ['high-floor', 'accessible-room'] });
-        const lines = (res.structured.requested ?? []);
-        expect(res.structured.accessibility).toBe(true);
-        // Not folded into the "asked for" sentence with the rest.
-        expect(lines.find((l) => l.startsWith('Asked for on the booking:'))).not.toMatch(/accessible/);
-        const own = lines.find((l) => l.includes('accessible room'));
-        expect(own).toMatch(/does not hold one/);
-        expect(own).toContain('Island Shangri-La, Hong Kong');
-    });
-    it('keeps the first of two requests that cannot both be met, and says which', async () => {
-        const res = await book({ requests: ['twin-beds', 'king-bed'] });
-        const booking = res.structured.booking;
-        expect(booking.requests?.kinds).toEqual(['twin-beds']);
-        expect(res.text).toContain('A king bed and twin beds cannot both be asked for');
-        expect(res.text).toContain('the booking asks for twin beds');
-    });
-    // ⚠️ A TIME IS A LATE ARRIVAL. Carrying the hour without the request is a
-    // booking the desk has no reason to hold past it.
-    it('reads an arrival time as a late arrival on its own', async () => {
-        const res = await book({ arrivingAt: '23:40' });
-        const booking = res.structured.booking;
-        expect(booking.requests?.kinds).toEqual(['late-arrival']);
-        expect(booking.requests?.arrivingAt).toBe('23:40');
-        expect(res.text).toContain('a late arrival, around 23:40');
-    });
-    it('drops a time that is not one, rather than sending it on', async () => {
-        const res = await book({ arrivingAt: 'late-ish' });
-        expect(res.structured.requested).toBeUndefined();
-    });
-    it('answers an early check-in with the hour it is early against', async () => {
-        const res = await book({ requests: ['early-check-in'] });
-        expect(res.text).toMatch(/Check-in here opens at \d\d:\d\d/);
-    });
-    it('caps the guest’s own words instead of carrying a conversation to the desk', async () => {
-        const res = await book({ notes: 'x'.repeat(500) });
-        const booking = res.structured.booking;
-        expect(booking.requests?.note?.length).toBe(200);
-    });
-    it('drops a code it does not know', async () => {
-        const res = await book({ requests: ['helicopter-pad', 'quiet-room'] });
-        const booking = res.structured.booking;
-        expect(booking.requests?.kinds).toEqual(['quiet-room']);
-    });
-    it('says nothing at all when nothing was asked for', async () => {
-        const res = await book();
-        expect(res.structured.requested).toBeUndefined();
-        expect(res.text).not.toMatch(/Asked for/);
-    });
-    // A guest who closes the card has no other way to check it was recorded.
-    it('still names them when the booking is listed later', async () => {
-        await book({ requests: ['high-floor'] });
-        const res = await call(t.listBookings, {});
-        expect(res.text).toContain('asked for high floor');
-    });
-});
-// Browsing ninety-six properties: an order, a ceiling, and one wider search
-// before the word "no".
-describe('narrowing the list', () => {
-    const list = (a = {}) => call(t.listHotels, a);
-    const prices = (res) => (res.structured.hotels ?? []).map((h) => h.fromNightly);
-    it('orders by the from-price, low and high, inside one currency', async () => {
-        const low = prices(await list({ city: 'Hong Kong', sort: 'price-low' }));
-        const high = prices(await list({ city: 'Hong Kong', sort: 'price-high' }));
-        expect(low).toHaveLength(4);
-        expect([...high].reverse()).toEqual(low);
-        expect((await list({ city: 'Hong Kong', sort: 'price-low' })).structured.sort).toBe('price-low');
-    });
-    // ⚠️ SORTING HK$890 AGAINST ¥1,180 MEANS PICKING A RATE, and a rate we picked
-    // is a number a guest reads off a card as if the hotel had said it. Dropped,
-    // and said - applied silently it invents the rate, dropped silently it hands
-    // back a list the guest reads as ordered by price when it is not.
-    it('refuses a price order across currencies, names them, and says what to narrow', async () => {
-        const res = await list({ sort: 'price-low' });
-        expect(res.structured.sort).toBe('group');
-        expect(res.structured.currencies).toEqual(['CNY', 'HKD']);
-        expect(res.text).toMatch(/not in price order/);
-        expect(res.text).toMatch(/one city or one country gives one currency/);
-    });
-    it('caps by the from-price and says how many it left out', async () => {
-        const res = await list({ city: 'Hong Kong', maxNightly: 3000 });
-        expect(res.structured.total).toBe(3);
-        expect(res.structured.overBudget).toBe(1);
-        expect(res.text).toMatch(/1 more matched and came in over the ceiling/);
-    });
-    // ⚠️ THE MISS IS THE ANSWER. "No hotels" teaches a guest nothing; the
-    // cheapest one and its price is something they can decide on. It is named as
-    // a miss and kept out of `hotels`, so nothing downstream can show it as one.
-    it('answers an impossible ceiling with the cheapest miss, marked as a miss', async () => {
-        const res = await list({ city: 'Hong Kong', maxNightly: 500 });
-        expect(res.structured.hotels).toEqual([]);
-        expect(res.structured.nearest.length).toBeGreaterThan(0);
-        expect(res.text).toMatch(/Nothing under HK\$500 a night/);
-        expect(res.text).toMatch(/The cheapest that matched is .+ at HK\$/);
-    });
-    it('drops the words and keeps the place when both together match nothing', async () => {
-        const res = await list({ city: 'Hong Kong', query: 'rooftop helipad' });
-        expect(res.structured.total).toBe(4);
-        expect(res.text).toMatch(/Nothing matched Hong Kong and "rooftop helipad", so this is Hong Kong/);
-        expect(res.structured.widened).toEqual({
-            from: 'Hong Kong and "rooftop helipad"',
-            to: 'Hong Kong',
-            found: true,
-        });
-    });
-    // ⚠️ IT WIDENS ONCE AND STOPS. A search that keeps loosening always finds
-    // something, and what it finds is unrelated to what was asked.
-    it('says what it tried when the wider search also found nothing', async () => {
-        const res = await list({ city: 'Tokyo' });
-        expect(res.structured.view).toBe('no-hotels');
-        expect(res.text).toMatch(/"Tokyo" anywhere in the record found nothing either/);
-        expect(res.structured.widened).toBeUndefined();
-    });
-    // ⚠️ AND A CEILING IS NOT A FAILED SEARCH. The place matched, the words
-    // matched, the prices were the answer. Widening here dropped "Hong Kong" and
-    // came back with five hotels in two countries, ceiling silently unapplied
-    // because the wider set no longer shared a currency (2026-09-22).
-    it('does not widen the place because a price ceiling emptied the list', async () => {
-        const res = await list({ city: 'Hong Kong', maxNightly: 500 });
-        expect(res.structured.widened).toBeUndefined();
-        for (const h of (res.structured.nearest ?? [])) {
-            expect(h.city).toBe('Hong Kong');
-        }
-    });
-    it('leaves a hotel that publishes no rating in place rather than last-by-default', async () => {
-        const res = await list({ city: 'Hong Kong', sort: 'rating' });
-        expect(res.structured.sort).toBe('rating');
-        expect(prices(res)).toHaveLength(4);
-    });
-    it('ignores an order it does not have', async () => {
-        expect((await list({ sort: 'closest-to-the-airport', all: true })).structured.sort).toBe('group');
-    });
-});
-// ⚠️ A BOOKING MADE ON THE CARD BELONGS TO THE CARD AND THE CONVERSATION. The
-// card's calls arrive on a different connection from the model's, naming the
-// trip instead. The trip id used to open every booking of that conversation,
-// from any connection (2026-10-05 audit); now it only says whose trip a NEW
-// booking came from, and anything else opens a booking by its code and email.
-describe('a booking made on the card', () => {
-    const conversation = 'session-a shangri-la';
-    const onTheCard = { session: 'anon-card-call', tripKey: conversation };
-    const byTheModel = { session: 'session-a', tripKey: conversation };
-    it('is found, cancelled and listed from either side', async () => {
-        await handleTool(deps, t.addToTrip, { hotel: 'hong-kong-kerry', room: 'deluxe', ...STAY }, onTheCard);
-        const made = await handleTool(deps, t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' }, onTheCard);
-        const code = made.structured.booking.confirmationCode;
-        const listed = await handleTool(deps, t.listBookings, {}, byTheModel);
-        expect(listed.structured.count).toBe(1);
-        const elsewhere = { ...onTheCard, session: 'anon-another-card-call' };
-        // Yet another connection, naming the same trip: the trip id opens nothing.
-        const byTrip = await handleTool(deps, t.cancelBooking, { booking: code }, elsewhere);
-        expect(byTrip.structured.view).toBe('booking-not-found');
-        expect((await handleTool(deps, t.listBookings, {}, elsewhere)).structured.count).toBe(0);
-        // With the email it was made with - what the card sends - it is found.
-        const preview = await handleTool(deps, t.cancelBooking, { booking: code, email: 'robin@example.com' }, elsewhere);
-        expect(preview.structured.view).toBe('cancellation-preview');
-    });
-    it('answers a trip of two stays with two codes, and says each stands alone', async () => {
-        await call(t.addToTrip, { hotel: 'shanghai-pudong', room: 'deluxe-city', ...STAY });
-        await call(t.addToTrip, {
-            hotel: 'beijing-kerry',
-            room: 'deluxe',
-            checkIn: '2026-10-21',
-            checkOut: '2026-10-23',
-        });
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        expect(made.structured.view).toBe('booking');
-        expect(made.structured.bookings).toHaveLength(2);
-        expect(made.text).toMatch(/2 bookings, one for each stay/);
-        expect(made.text).toMatch(/Pudong[\s\S]*Beijing/);
-    });
-    it('keeps the trip when a stay cannot be held, and books none of it', async () => {
-        await call(t.addToTrip, { hotel: 'shanghai-pudong', room: 'deluxe-city', ...STAY });
-        await call(t.addToTrip, {
-            hotel: 'shanghai-pudong',
-            room: 'suite',
-            checkIn: '2026-10-21',
-            checkOut: '2026-10-23',
-            guests: 2,
-        });
-        // Somebody else takes the only suite in the meantime.
-        await deps.backend.requestBooking({
-            lines: [
-                {
-                    kind: 'room',
-                    hotelId: 'shanghai-pudong',
-                    roomId: 'suite',
-                    stay: { checkIn: '2026-10-21', checkOut: '2026-10-23', guests: 2 },
-                },
-            ],
-        }, { name: 'Someone Else', email: 'else@example.com' }, { sessionId: 'elsewhere' });
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        expect(made.structured.view).toBe('error');
-        expect(made.text).toMatch(/Nothing was booked/);
-        // Both lines are still there; the trip view names the one that went.
-        expect(deps.trips.read('session-a shangri-la')).toHaveLength(2);
-        const trip = await call(t.viewTrip);
-        expect(JSON.stringify(trip.structured.dropped)).toMatch(/Suite|suite/);
-    });
-});
-// ⚠️ AN ADD-ON ON A BOOKING ALREADY MADE (robin, 2026-09-28). Once booked, an
-// airport transfer had nowhere to go; now it is the same preview-then-confirm
-// as any other change.
-describe('add-ons on a booking already made', () => {
-    const book = async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        return made.structured.booking.confirmationCode;
-    };
-    it('lists the hotel add-ons with what the booking holds, then previews and makes the change', async () => {
-        const code = await book();
-        const listed = await call(t.listExtras, { booking: code });
-        expect(listed.structured.view).toBe('extras');
-        expect(listed.structured.forBooking.held).toEqual({});
-        const pre = await call(t.previewChange, {
-            booking: code,
-            extra: 'airport-transfer',
-            quantity: 1,
-        });
-        expect(pre.structured.view).toBe('change-preview');
-        expect(pre.structured.changeable).toBe(true);
-        expect(pre.structured.addOn).toMatchObject({ id: 'airport-transfer', from: 0, to: 1 });
-        expect(pre.text).toMatch(/would add 1× Airport transfer/i);
-        const done = await call(t.changeBooking, {
-            booking: code,
-            extra: 'airport-transfer',
-            quantity: 1,
-            confirmed: true,
-        });
-        expect(done.structured.view).toBe('changed');
-        const again = await call(t.listExtras, { booking: code });
-        expect(again.structured.forBooking.held).toEqual({
-            'airport-transfer': 1,
-        });
-        // And off again - once the guest has seen what that does. A confirmation
-        // with no preview before it IS the preview (2026-09-28 audit).
-        const unseen = await call(t.changeBooking, {
-            booking: code,
-            extra: 'airport-transfer',
-            quantity: 0,
-            confirmed: true,
-        });
-        expect(unseen.structured.view).toBe('change-preview');
-        expect(unseen.text).toMatch(/Nothing has changed yet/);
-        const off = await call(t.changeBooking, {
-            booking: code,
-            extra: 'airport-transfer',
-            quantity: 0,
-            confirmed: true,
-        });
-        expect(off.structured.view).toBe('changed');
-    });
-    it('puts an add-on on a non-refundable stay: the add-on is not the rate', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'horizon-club', ...STAY });
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const code = made.structured.booking.confirmationCode;
-        const pre = await call(t.previewChange, {
-            booking: code,
-            extra: 'airport-transfer',
-            quantity: 1,
-        });
-        expect(pre.structured.changeable).toBe(true);
-        // The nights of that rate still do not move.
-        const move = await call(t.previewChange, { booking: code, checkOut: '2026-10-22' });
-        expect(move.structured.changeable).toBe(false);
-    });
-    it('names an add-on the hotel does not have rather than guessing', async () => {
-        const code = await book();
-        const pre = await call(t.previewChange, { booking: code, extra: 'helicopter', quantity: 1 });
-        expect(pre.structured.changeable).toBe(false);
-        expect(pre.text).toMatch(/offers no add-on called "helicopter"/);
-    });
-});
-// ⚠️ MEMORY IS THE MEMBER'S, AND ONLY WHEN ASKED (robin, 2026-09-28: 「记忆 ok」).
-describe("a member's saved preferences", () => {
-    const member = { number: 'SLC-4471-8820', surname: 'Ruan' };
-    const later = { session: 'session-later' };
-    const bookWith = async (rememberRequests) => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        return call(t.requestBooking, {
-            name: 'Robin Ruan',
-            email: 'robin@example.com',
-            requests: ['high-floor', 'king-bed', 'late-arrival'],
-            ...(rememberRequests === undefined ? {} : { rememberRequests }),
-        });
-    };
-    it('keeps nothing unless the guest asked', async () => {
-        await call(t.signIn, member);
-        await bookWith();
-        const next = await handleTool(deps, t.signIn, member, later);
-        expect(next.structured.member.preferences).toBeUndefined();
-        expect(next.text).not.toMatch(/Saved preferences/);
-    });
-    it('keeps the lasting ones when asked, brings them back at the next sign-in, and forgets them', async () => {
-        await call(t.signIn, member);
-        const made = await bookWith(true);
-        expect(made.text).toMatch(/Remembered on this .* membership for next time: a high floor, a king bed/);
-        // A late arrival is this week's flight, not a preference.
-        expect(made.structured.remembered).toEqual(['high-floor', 'king-bed']);
-        const next = await handleTool(deps, t.signIn, member, later);
-        expect(next.structured.member.preferences).toEqual([
-            'high-floor',
-            'king-bed',
-        ]);
-        expect(next.text).toMatch(/Saved preferences on this membership: a high floor, a king bed/);
-        // And on every answer's badge, so a later card can tick the form.
-        const hotel = await handleTool(deps, t.getHotel, { hotel: 'hong-kong-island', ...STAY }, later);
-        expect(hotel.structured.member.preferences).toHaveLength(2);
-        const forgot = await handleTool(deps, t.forgetPreferences, {}, later);
-        expect(forgot.text).toMatch(/Forgot the room preferences/);
-        const after = await handleTool(deps, t.signIn, member, { session: 'session-third' });
-        expect(after.structured.member.preferences).toBeUndefined();
-    });
-    it('says it kept nothing when nobody is signed in', async () => {
-        const made = await bookWith(true);
-        expect(made.text).toMatch(/Nothing was remembered: saved preferences belong to a membership/);
-    });
-    it('tells every card whether anyone is signed in, false included', async () => {
-        const res = await call(t.listHotels, { city: 'Hong Kong' });
-        expect(res.structured.signedIn).toBe(false);
-        await call(t.signIn, member);
-        const signed = await call(t.listHotels, { city: 'Hong Kong' });
-        expect(signed.structured.signedIn).toBe(true);
-    });
-});
-describe('the next step', () => {
-    it('leaves the order to the list itself: no price chip under it', async () => {
-        const res = await call(t.listHotels, { city: 'Hong Kong' });
-        expect(res.structured.suggestions).toBeUndefined();
-        // What the sort row repeats when pressed: the same search, another order.
-        expect(res.structured.ask).toEqual({ city: 'Hong Kong' });
-    });
-    it('sends only what needs the model to the chat, named in full', async () => {
-        const res = await call(t.getHotel, { hotel: 'hong-kong-island', ...STAY });
-        const chips = res.structured.suggestions;
-        expect(chips.length).toBeLessThanOrEqual(3);
-        const compare = chips.find((c) => c.say);
-        expect(compare?.say).toBe('Compare Island Shangri-La, Hong Kong with the other Hong Kong hotels');
-        for (const c of chips) {
-            expect(c.label).not.toMatch(/\b(tap|click|below|above|this one)\b/i);
-            expect(c.say ?? '').not.toMatch(/\b(tap|click|below|above|this one)\b/i);
-        }
-    });
-    it('offers a transfer after a booking as the change preview, and only when the booking has none', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const code = made.structured.booking.confirmationCode;
-        const offered = made.structured.suggestions.find((x) => x.label.startsWith('Add '));
-        expect(offered?.label).toMatch(new RegExp(`^Add ".*transfer.*" to ${code}$`, 'i'));
-        expect(offered?.ask).toEqual({
-            tool: 'previewChange',
-            args: { booking: code, extra: 'airport-transfer', quantity: 1 },
-        });
-        // Pressed, it previews - it does not change the booking.
-        const pressed = await call(t[offered?.ask?.tool], offered?.ask?.args);
-        expect(pressed.structured.view).toBe('change-preview');
-        // A booking made WITH a transfer is not offered another.
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        await call(t.addToTrip, { hotel: 'hong-kong-island', extra: 'airport-transfer' });
-        const withOne = await call(t.requestBooking, {
-            name: 'Robin Ruan',
-            email: 'robin@example.com',
-        });
-        expect(withOne.structured.suggestions.some((x) => x.label.startsWith('Add '))).toBe(false);
-    });
-    it('draws no suggestions on an answer with nothing to lead to', async () => {
-        const res = await call(t.viewTrip);
-        expect(res.structured.suggestions).toBeUndefined();
-    });
-    // ⚠️ robin, 2026-09-29: 「改成卡片直接加进行程吧」 - the plan's chip was a chat
-    // message, held under the host's caution banner. It is the card's own calls.
-    it('puts a plan’s stays in the trip from the card, on the rooms it priced, and then stops offering', async () => {
-        const plan = {
-            title: 'Hong Kong, then Shanghai',
-            checkIn: '2026-10-19',
-            checkOut: '2026-10-22',
-            guests: 2,
-            days: [
-                { label: 'Arrive', items: ['hong-kong-island'] },
-                { label: 'Across', items: ['shanghai-pudong'] },
-                { label: 'The Bund', items: [] },
-            ],
-        };
-        const res = await call(t.itinerary, plan);
-        const chip = res.structured.suggestions.find((c) => c.asks);
-        expect(chip?.label).toBe('Put these 2 stays in the trip');
-        expect(chip?.asks?.map((a) => [a.tool, a.args.hotel, a.args.checkIn, a.args.checkOut])).toEqual([
-            ['addToTrip', 'hong-kong-island', '2026-10-19', '2026-10-20'],
-            ['addToTrip', 'shanghai-pudong', '2026-10-20', '2026-10-22'],
-        ]);
-        // The card makes the calls; `say` is only for a card from before `asks`,
-        // which would otherwise draw nothing at all (robin, 2026-09-29: 「好像啥按钮
-        // 都没有了」).
-        expect(chip?.say).toBe('Put the stays on this plan in the trip');
-        // And a model asked in the chat has each stay as the trip takes it.
-        expect(res.text).toMatch(/\(`hong-kong-island`\) 2026-10-19 to 2026-10-20, room `[a-z-]+`/);
-        for (const a of chip?.asks ?? []) {
-            const added = await call(t.addToTrip, a.args);
-            expect(added.structured.view).toBe('trip');
-        }
-        const again = await call(t.itinerary, plan);
-        expect((again.structured.suggestions ?? []).some((c) => c.asks)).toBe(false);
-    });
-    it('leaves a plan with no nights to the model, which asks for them', async () => {
-        const res = await call(t.itinerary, {
-            title: 'Hong Kong',
-            days: [{ label: 'Arrive', items: ['hong-kong-island'] }],
-        });
-        expect(res.structured.suggestions).toEqual([
-            {
-                label: 'Put the stays on this plan in the trip',
-                say: 'Put the stays on this plan in the trip',
-            },
-        ]);
-    });
-});
-// ⚠️ AN ADD-ON GOES WITH A STAY (robin, 2026-09-28: 「可以不订房间，直接订接机的吗」).
-// The trip with a lone transfer showed the whole booking form, and the request
-// then refused it; the trip now says so first, with the two ways it can be done.
-describe('an add-on with no room beside it', () => {
-    it('is named in the trip before anyone fills in the form, and the request still refuses it', async () => {
-        const trip = await call(t.addToTrip, { hotel: 'shanghai-pudong', extra: 'airport-transfer' });
-        expect(trip.structured.needsRoom).toEqual([
-            expect.objectContaining({ hotelId: 'shanghai-pudong', extras: [expect.any(String)] }),
-        ]);
-        expect(trip.text).toMatch(/goes with a stay there, so this trip cannot be requested as it is/);
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        expect(made.structured.view).toBe('error');
-        expect(made.text).toMatch(/An add-on goes with a stay/);
-    });
-    it('is nothing to flag once a room at that hotel is in the trip', async () => {
-        await call(t.addToTrip, { hotel: 'shanghai-pudong', extra: 'airport-transfer' });
-        const trip = await call(t.addToTrip, {
-            hotel: 'shanghai-pudong',
-            room: 'deluxe-city',
-            ...STAY,
-        });
-        expect(trip.structured.needsRoom).toBeUndefined();
-    });
-});
-// ⚠️ THE WAYS IN, COUNTED ACROSS EVERYTHING (robin, 2026-09-28: 「是否要加一个城市
-// 筛选之类的功能，然后可以选择查看更多」).
-describe('browsing more than one page', () => {
-    it('offers every country the matches are in, counted across all of them, and the next page', async () => {
-        const all = await call(t.listHotels, { limit: 3, all: true });
-        const places = all.structured.places;
-        expect(places.length).toBeGreaterThan(1);
-        expect(places.reduce((n, p) => n + p.count, 0)).toBe(all.structured.total);
-        expect(all.text).toMatch(/`offset` 3 is the next page/);
-        const next = await call(t.listHotels, { limit: 3, offset: 3, all: true });
-        const first = all.structured.hotels.map((h) => h.id);
-        const second = next.structured.hotels.map((h) => h.id);
-        expect(second).toHaveLength(3);
-        expect(second.some((id) => first.includes(id))).toBe(false);
-        expect(next.text).toMatch(/4 to 6 in this answer/);
-    });
-    it('offers the cities inside a country, and nothing inside one city', async () => {
-        const china = await call(t.listHotels, { city: 'China' });
-        const cities = china.structured.places ?? [];
-        expect(cities.map((c) => c.place)).toEqual(expect.arrayContaining(['Shanghai', 'Beijing']));
-        const shanghai = await call(t.listHotels, { city: 'Shanghai' });
-        expect(shanghai.structured.places).toBeUndefined();
-        expect(shanghai.structured.ask.city).toBe('Shanghai');
-    });
-});
-// ⚠️ SOMEWHERE FIRST, THEN A HOTEL (robin, 2026-09-28: 「和温德姆一样，先让人选国家和
-// 城市，然后再选酒店」).
-describe('choosing where before which hotel', () => {
-    it('answers a browse with nothing named with the places, by region, country and city', async () => {
-        const res = await call(t.listHotels, {});
-        expect(res.structured.view).toBe('destinations');
-        const regions = res.structured.regions;
-        expect(regions.map((r) => r.name)).toEqual(['Asia']);
-        const [china] = regions;
-        expect(china?.count).toBe(res.structured.total);
-        // Every hotel counted once, down to its city.
-        const cities = china?.countries.flatMap((c) => c.cities) ?? [];
-        expect(cities.reduce((n, c) => n + c.count, 0)).toBe(res.structured.total);
-        expect(res.text).toMatch(/to choose from by region, country and city - /);
-        // Every place, for a host with no card.
-        expect(res.text).toMatch(/China \(5\)/);
-        expect(res.structured.hotels).toBeUndefined();
-    });
-    it('answers a country of many cities with its cities, and `all` with its hotels', async () => {
-        // The fixture's China is three cities; a country of four or more gets the cities.
-        const wide = {
-            ...DATA,
-            hotels: [
-                ...DATA.hotels,
-                ...['Hangzhou', 'Suzhou'].map((city, i) => {
-                    const base = DATA.hotels.find((h) => h.country === 'China');
-                    if (!base)
-                        throw new Error('the fixture has no hotel in China');
-                    return {
-                        ...base,
-                        id: `extra-${i}`,
-                        name: `Shangri-La ${city}`,
-                        city,
-                        cityId: city.toLowerCase(),
-                    };
-                }),
-            ],
-        };
-        deps = { ...deps, backend: createDemoHotels({ data: wide, now: () => clock, rng: () => 0.5 }) };
-        const res = await call(t.listHotels, { city: 'China' });
-        expect(res.structured.view).toBe('destinations');
-        const scope = res.structured.scope;
-        expect(scope.name).toBe('China');
-        expect(scope.cities.length).toBeGreaterThanOrEqual(4);
-        expect(res.text).toMatch(/`all` lists every one in China/);
-        const all = await call(t.listHotels, { city: 'China', all: true });
-        expect(all.structured.view).toBe('hotels');
-    });
-    it('goes straight to the hotels of a city, or of a country of few cities', async () => {
-        expect((await call(t.listHotels, { city: 'Hong Kong' })).structured.view).toBe('hotels');
-        expect((await call(t.listHotels, { city: 'China' })).structured.view).toBe('hotels');
-    });
-    it('lists hotels for words, and offers the cities they are in as a way to narrow', async () => {
-        const res = await call(t.listHotels, { query: 'pool' });
-        expect(res.structured.view).toBe('hotels');
-        const places = res.structured.places ?? [];
-        expect(places.length).toBeGreaterThan(1);
-    });
-});
-// ⚠️ A STRANGER'S EMAIL IS NOT A KEY TO THEIR TRIPS (2026-09-28 audit).
-describe('finding a booking made elsewhere', () => {
-    it('needs the code and the email together; the email alone lists nothing', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const code = made.structured.booking.confirmationCode;
-        const elsewhere = { session: 'session-elsewhere' };
-        const byEmail = await handleTool(deps, t.listBookings, { email: 'robin@example.com' }, elsewhere);
-        expect(byEmail.structured.count).toBe(0);
-        const both = await handleTool(deps, t.listBookings, { email: 'robin@example.com', booking: code }, elsewhere);
-        expect(both.structured.count).toBe(1);
-        // Found, it is this conversation's now: its code alone opens it here, so
-        // the card's Cancel - which sends nothing more - works on it.
-        const cancel = await handleTool(deps, t.previewCancellation, { booking: code }, elsewhere);
-        expect(cancel.structured.view).toBe('cancellation-preview');
-        // And nothing in any answer carries the conversation it was made in.
-        expect(JSON.stringify(both.structured)).not.toContain('session-');
-        expect(JSON.stringify(both.structured)).not.toContain('owners');
-        const third = { session: 'session-third' };
-        const wrong = await handleTool(deps, t.listBookings, { email: 'someone@example.com', booking: code }, third);
-        expect(wrong.structured.count).toBe(0);
-        expect(wrong.structured.notFound).toBe(code);
-        expect(wrong.text).toMatch(/Both are needed/);
-        // The id is not a code: with an email, only the code opens a booking.
-        const id = both.structured.bookings[0]?.id ?? '';
-        const byId = await handleTool(deps, t.listBookings, { email: 'robin@example.com', booking: id }, third);
-        expect(byId.structured.count).toBe(0);
-    });
-    it('says a miss even when the conversation has bookings to list', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const res = await call(t.listBookings, { booking: 'SL-NOPE00', email: 'robin@example.com' });
-        expect(res.structured.count).toBe(1);
-        expect(res.structured.notFound).toBe('SL-NOPE00');
-        expect(res.text).toMatch(/^No booking matches that confirmation code and email/);
-    });
-    it('stops taking guesses at a code and an email after a few misses', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const code = made.structured.booking.confirmationCode;
-        const guessing = { deps: { ...deps, misses: new Misses(() => clock) } };
-        const guess = (booking, session) => handleTool(guessing.deps, t.listBookings, { email: 'robin@example.com', booking }, { session });
-        for (let i = 0; i < MAX_MISSES; i += 1)
-            await guess(`SL-WRONG${i}`, 'session-guesser');
-        // The right code now waits too - from this conversation, and for this
-        // email from another one.
-        const blocked = await guess(code, 'session-guesser');
-        expect(blocked.structured.count).toBe(0);
-        expect(blocked.structured.tooMany).toBe(true);
-        expect(blocked.text).toMatch(/paused for a quarter of an hour/);
-        expect((await guess(code, 'session-other')).structured.tooMany).toBe(true);
-        // A conversation's own booking, with no email, is never a guess.
-        expect((await call(t.listBookings, {})).structured.count).toBe(1);
-    });
-});
-// ⚠️ A CONFIRMATION CONFIRMS WHAT WAS SHOWN (2026-09-28 audit).
-describe('confirming a cancellation', () => {
-    it('shows the fee first when nothing was previewed, then cancels on the next confirmation', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const code = made.structured.booking.confirmationCode;
-        const first = await call(t.cancelBooking, { booking: code, confirmed: true });
-        expect(first.structured.view).toBe('cancellation-preview');
-        expect(first.text).toMatch(/Nothing is cancelled yet/);
-        const second = await call(t.cancelBooking, { booking: code, confirmed: true });
-        expect(second.structured.view).toBe('cancelled');
-    });
-});
-// ⚠️ A PLACE, THEN THE DATES, THEN HOTELS PRICED FOR THEM (robin, 2026-09-28,
-// with Trip.com and shangri-la.com as the reference).
-describe('a list for the guest’s nights', () => {
-    it('prices every hotel for the whole stay, taxes in, and keeps the nights on the search', async () => {
-        const res = await call(t.listHotels, { city: 'Hong Kong', ...STAY });
-        const tiles = res.structured.hotels;
-        const island = tiles.find((h) => h.id === 'hong-kong-island');
-        // The same number the hotel's own page gives for its cheapest room.
-        expect(island?.forStay).toMatchObject({ total: 'HK$8,588', nights: 2 });
-        expect(res.structured.stay).toEqual(STAY);
-        expect(res.structured.ask).toMatchObject({ city: 'Hong Kong', ...STAY });
-        expect(res.text).toMatch(/Priced for 2026-10-19 to 2026-10-21: each price is that hotel's cheapest room for the whole stay, taxes included/);
-    });
-    it('orders by the price of those nights, and says which have no room', async () => {
-        const res = await call(t.listHotels, {
-            city: 'Hong Kong',
-            ...STAY,
-            guests: 4,
-            sort: 'price-low',
-        });
-        const tiles = res.structured.hotels;
-        // Four in one room: nothing at the Island sleeps four, so it has no room.
-        expect(tiles.find((h) => h.id === 'hong-kong-island')?.noRoomsForStay).toMatch(/No room/);
-        // Priced first, cheapest first; the ones with no room last.
-        const priced = tiles.filter((h) => h.forStay);
-        expect(tiles.slice(0, priced.length)).toEqual(priced);
-    });
-    it('keeps the nights on the destinations, for the place picked next', async () => {
-        const res = await call(t.listHotels, { ...STAY });
-        expect(res.structured.view).toBe('destinations');
-        expect(res.structured.ask).toMatchObject(STAY);
-    });
-});
-// ⚠️ FILTERS, AS A BOOKING SITE HAS THEM (robin, 2026-09-28: 「筛选可以，加上」).
-describe('filtering a list', () => {
-    const ids = (res) => (res.structured.hotels ?? []).map((h) => h.id);
-    it('offers only the chips that narrow, each with what it would leave', async () => {
-        const res = await call(t.listHotels, { city: 'Hong Kong' });
-        const r = res.structured.refine;
-        expect(r.brands.map((b) => [b.name, b.count])).toEqual([
-            ['Shangri-La', 2],
-            ['JEN', 1],
-            ['Kerry', 1],
-        ]);
-        // Every Hong Kong hotel has a pool: a "pool" chip here would change nothing.
-        expect(r.facilities.map((x) => x.key)).toEqual(['spa']);
-        expect(r.room).toEqual([]);
-    });
-    it('narrows by brand and by what a hotel has, and keeps them on the search', async () => {
-        const kerry = await call(t.listHotels, { city: 'Hong Kong', brand: 'Kerry' });
-        expect(ids(kerry)).toEqual(['hong-kong-kerry']);
-        expect(kerry.structured.ask).toMatchObject({ city: 'Hong Kong', brand: 'Kerry' });
-        expect(kerry.text).toMatch(/Filtered to Kerry/);
-        const spa = await call(t.listHotels, { city: 'Hong Kong', facilities: ['spa'] });
-        expect(ids(spa).sort()).toEqual(['hong-kong-island', 'hong-kong-kowloon']);
-    });
-    it('prices, on a dated list, the room the filter asks for', async () => {
-        const plain = await call(t.listHotels, { city: 'Hong Kong', ...STAY });
-        const withBreakfast = await call(t.listHotels, { city: 'Hong Kong', ...STAY, breakfast: true });
-        const island = (res) => res.structured.hotels.find((h) => h.id === 'hong-kong-island')?.forStay?.room;
-        // The Island's cheapest room has no breakfast; with the filter, the priced
-        // room is the cheapest that does.
-        expect(island(plain)).toBe('Deluxe Peak View Room');
-        expect(island(withBreakfast)).not.toBe('Deluxe Peak View Room');
-    });
-    it('says the filters emptied a list, keeps the way back, and does not widen the place', async () => {
-        const res = await call(t.listHotels, { city: 'Hong Kong', brand: 'JEN', facilities: ['spa'] });
-        expect(res.structured.view).toBe('no-hotels');
-        expect(res.structured.beforeFilters).toBe(4);
-        expect(res.structured.widened).toBeUndefined();
-        expect(res.text).toMatch(/None of the 4 hotels here has JEN, spa together/);
-        const r = res.structured.refine;
-        expect(r.brands.find((b) => b.on)?.name).toBe('JEN');
-    });
-    it('lists hotels, not places, when a filter is the only thing asked', async () => {
-        const res = await call(t.listHotels, { brand: 'Kerry' });
-        expect(res.structured.view).toBe('hotels');
-    });
-});
-describe('room terms on a dated list', () => {
-    it('always offers free cancellation and breakfast there: they change the room priced', async () => {
-        const res = await call(t.listHotels, { city: 'Hong Kong', ...STAY });
-        const room = res.structured.refine.room.map((x) => x.key);
-        expect(room).toEqual(['freeCancellation', 'breakfast']);
-    });
-});
-describe('a list one filter emptied', () => {
-    it('says it plainly - "together" is for several', async () => {
-        const res = await call(t.listHotels, { city: 'Shanghai', brand: 'JEN' });
-        expect(res.text).toMatch(/None of the \d+ hotels here is JEN\./);
-        expect(res.text).not.toMatch(/together/);
-    });
-});
-// ⚠️ THE 2026-09-28 FULL AUDIT, server side: each of these was reproduced
-// against the running connector before it was fixed.
-describe('the audit of 2026-09-28', () => {
-    const pressed = (c, group) => group === 'brands'
-        ? { brand: c.name }
-        : group === 'facilities'
-            ? { facilities: [c.key] }
-            : { [String(c.key)]: true };
-    it.each([
-        ['a ceiling', { city: 'Hong Kong', maxNightly: 3000 }],
-        ['a ceiling on named nights', { city: 'Hong Kong', maxNightly: 3000, ...STAY }],
-    ])('counts every filter chip as what pressing it lists, under %s', async (_, args) => {
-        const res = await call(t.listHotels, args);
-        const refine = res.structured.refine;
-        for (const group of ['brands', 'facilities', 'room']) {
-            for (const chip of refine[group]) {
-                if (chip.on)
-                    continue;
-                const after = await call(t.listHotels, { ...args, ...pressed(chip, group) });
-                expect([group, chip.name ?? chip.key, after.structured.total ?? 0]).toEqual([
-                    group,
-                    chip.name ?? chip.key,
-                    chip.count,
-                ]);
-            }
-        }
-    });
-    it('says a ceiling emptied a filtered list, not the filter', async () => {
-        const res = await call(t.listHotels, { city: 'Hong Kong', brand: 'Kerry', maxNightly: 1000 });
-        expect(res.text).toMatch(/^Nothing under HK\$1,000 a night/);
-        expect(res.text).not.toMatch(/None of the/);
-    });
-    it('keeps the order and the ceiling on the way out of a filter that emptied the list', async () => {
-        const res = await call(t.listHotels, {
-            city: 'Hong Kong',
-            brand: 'Kerry',
-            facilities: ['spa'],
-            sort: 'rating',
-            ...STAY,
-        });
-        if (res.structured.ask) {
-            expect(res.structured.ask).toMatchObject({ sort: 'rating', city: 'Hong Kong' });
-            expect(res.structured.stay).toMatchObject(STAY);
-        }
-    });
-    it('keeps `all` on the search it echoes, so a re-query stays a list', async () => {
-        const res = await call(t.listHotels, { all: true });
-        expect(res.structured.view).toBe('hotels');
-        expect(res.structured.ask).toMatchObject({ all: true });
-        const again = await call(t.listHotels, res.structured.ask);
-        expect(again.structured.view).toBe('hotels');
-    });
-    it('puts hotels with no room for the nights last, and never counts them over a ceiling', async () => {
-        const three = { ...STAY, guests: 3 };
-        const high = await call(t.listHotels, { city: 'Hong Kong', ...three, sort: 'price-high' });
-        const tiles = high.structured.hotels;
-        const firstFull = tiles.findIndex((h) => h.noRoomsForStay);
-        expect(firstFull).toBeGreaterThan(0);
-        expect(tiles.slice(firstFull).every((h) => h.noRoomsForStay)).toBe(true);
-        const capped = await call(t.listHotels, { city: 'Hong Kong', ...three, maxNightly: 100000 });
-        expect(capped.structured.overBudget).toBeUndefined();
-        expect(capped.text).not.toMatch(/over the ceiling/);
-    });
-    it('quotes the misses on named nights at what those nights cost', async () => {
-        const weekend = { checkIn: '2026-10-23', checkOut: '2026-10-25', guests: 2 };
-        const res = await call(t.listHotels, { city: 'Hong Kong', ...weekend, maxNightly: 500 });
-        const [first] = res.structured.nearest;
-        expect(first?.forStay?.nightly).toBeDefined();
-        expect(res.text).toContain(`at ${first?.forStay?.nightly}`);
-    });
-    it('says a widened search came back over the ceiling rather than empty', async () => {
-        const res = await call(t.listHotels, { city: 'Hong Kong', query: 'helipad', maxNightly: 500 });
-        expect(res.text).toMatch(/Nothing matched Hong Kong and "helipad", so this looked in Hong Kong/);
-        expect(res.text).toMatch(/Nothing under HK\$500 a night/);
-        expect(res.text).not.toMatch(/found nothing either/);
-    });
-    it('offers no free cancellation once the window has closed', async () => {
-        // Arriving tomorrow: a 48-hour rule closed yesterday; a 24-hour one has not.
-        const soon = { checkIn: '2026-10-02', checkOut: '2026-10-03', guests: 2 };
-        const island = await call(t.getHotel, { hotel: 'hong-kong-island', ...soon });
-        const rooms = island.structured.rooms;
-        expect(rooms.some((r) => r.refundable)).toBe(true);
-        expect(rooms.every((r) => !r.freeCancellationUntil)).toBe(true);
-        expect(island.text).not.toMatch(/free to cancel/);
-        const free = await call(t.listHotels, { city: 'Hong Kong', ...soon, freeCancellation: true });
-        const ids = free.structured.hotels.map((h) => h.id).sort();
-        expect(ids).toEqual(['hong-kong-jen', 'hong-kong-kowloon']);
-    });
-    it('adds an add-on without re-pricing the room, whoever is signed in now', async () => {
-        await call(t.signIn, { number: 'SLC-4471-8820', surname: 'Ruan' });
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'horizon-club', ...STAY });
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const booking = made.structured.booking;
-        await call(t.signOut);
-        const extras = await call(t.listExtras, { booking: booking.confirmationCode });
-        const transfer = extras.structured.extras.find((e) => e.id === 'airport-transfer');
-        const pre = await call(t.previewChange, {
-            booking: booking.confirmationCode,
-            extra: 'airport-transfer',
-            quantity: 1,
-        });
-        // The difference is the transfer and its tax - nothing from the room.
-        const price = Number(String(transfer?.price).replace(/[^\d.]/g, ''));
-        const diff = Number(String(pre.structured.difference).replace(/[^\d.]/g, ''));
-        expect(diff).toBe(price + Math.round((price * 13) / 100));
-        expect(pre.structured.refundDue).toBe(false);
-    });
-    it('names what a change changes', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-kowloon', room: 'deluxe', rooms: 2, ...STAY });
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const code = made.structured.booking.confirmationCode;
-        const fewer = await call(t.previewChange, { booking: code, rooms: 1 });
-        expect(fewer.text).toMatch(/would go from 2 rooms to 1 room\./);
-        const none = await call(t.previewChange, { booking: code, rooms: 0 });
-        expect(none.structured.changeable).toBe(false);
-        expect(none.text).toMatch(/at least one room/);
-        const same = await call(t.previewChange, {
-            booking: code,
-            checkOut: '2026-10-22',
-            extra: 'airport-transfer',
-            quantity: 0,
-        });
-        expect(same.text).toMatch(/would move to 2026-10-19 - 2026-10-22\./);
-    });
-    it('charges a non-refundable cancellation exactly what was booked', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'horizon-club', ...STAY });
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const booking = made.structured.booking;
-        const pre = await call(t.previewCancellation, { booking: booking.confirmationCode });
-        expect(pre.structured.fee).toBe(booking.quote.total);
-        expect(pre.structured.refund).toBe('HK$0');
-    });
-    it('makes a trip total exactly the sum of the bookings it becomes', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        await call(t.addToTrip, { hotel: 'hong-kong-island', extra: 'airport-transfer', quantity: 1 });
-        const later = { checkIn: '2026-10-21', checkOut: '2026-10-23', guests: 2 };
-        await call(t.addToTrip, { hotel: 'hong-kong-kowloon', room: 'deluxe', ...later });
-        await call(t.addToTrip, { hotel: 'hong-kong-kowloon', extra: 'airport-transfer', quantity: 1 });
-        const trip = await call(t.viewTrip);
-        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const amount = (x) => Number(x.replace(/[^\d.]/g, ''));
-        const sum = made.structured.bookings.reduce((n, b) => n + amount(b.total), 0);
-        expect(sum).toBe(amount(String(trip.structured.total)));
-    });
-    it('forgets preferences on every conversation signed in as that member', async () => {
-        const other = { session: 'session-other' };
-        const member = { number: 'SLC-4471-8820', surname: 'Ruan' };
-        await call(t.signIn, member);
-        await handleTool(deps, t.signIn, member, other);
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        await call(t.requestBooking, {
-            name: 'Robin Ruan',
-            email: 'robin@example.com',
-            requests: ['king-bed', 'high-floor'],
-            rememberRequests: true,
-        });
-        await handleTool(deps, t.forgetPreferences, {}, other);
-        const here = await call(t.viewTrip);
-        expect(here.structured.member.preferences).toBeUndefined();
-    });
-    it('adds to saved preferences rather than replacing them, and never keeps an accessible room', async () => {
-        await call(t.signIn, { number: 'SLC-4471-8820', surname: 'Ruan' });
-        const book = async (requests) => {
-            await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-            return call(t.requestBooking, {
-                name: 'Robin Ruan',
-                email: 'robin@example.com',
-                requests,
-                rememberRequests: true,
-            });
-        };
-        await book(['king-bed', 'high-floor']);
-        const second = await book(['quiet-room', 'accessible-room', 'twin-beds']);
-        expect(second.structured.remembered).toEqual(['high-floor', 'quiet-room', 'twin-beds']);
-    });
-    it('compares at the member rate the list and the hotel show', async () => {
-        await call(t.signIn, { number: 'SLC-4471-8820', surname: 'Ruan' });
-        const hotel = await call(t.getHotel, { hotel: 'hong-kong-kerry', ...STAY });
-        const cheapest = hotel.structured.rooms
-            .map((r) => r.stayTotal)
-            .sort((a, b) => Number(a.replace(/\D/g, '')) - Number(b.replace(/\D/g, '')))[0];
-        const compared = await call(t.compare, {
-            entries: [{ hotel: 'hong-kong-kerry' }, { hotel: 'hong-kong-jen' }],
-            ...STAY,
-        });
-        const columns = compared.structured.columns;
-        expect(columns.find((c) => c.hotel.id === 'hong-kong-kerry')?.price?.stayTotal).toBe(cheapest);
-    });
-    // ⚠️ REFUSED NOW, NOT CLAMPED (2026-10-05 audit, P2): nine rooms became five
-    // and the answer spoke as if five had been asked for.
-    it('refuses a room count it cannot take, and spells a brand as the data does', async () => {
-        const many = await call(t.listHotels, { city: 'Hong Kong', ...STAY, rooms: 9 });
-        expect(many.structured).toMatchObject({ view: 'error', error: 'bad-count' });
-        expect(many.isError).toBe(true);
-        expect(many.text).toMatch(/whole number from 1 to 5/);
-        for (const rooms of [-1, 1.5, 1e9]) {
-            expect((await call(t.addToTrip, { hotel: 'hong-kong-kowloon', room: 'deluxe', rooms, ...STAY }))
-                .isError).toBe(true);
-        }
-        // A count sent as a string is the same count.
-        expect((await call(t.listHotels, { city: 'Hong Kong', ...STAY, rooms: '2' })).isError).toBeUndefined();
-        const kerry = await call(t.listHotels, { city: 'Hong Kong', brand: 'kerry' });
-        const chip = kerry.structured.refine.brands.find((b) => b.name === 'Kerry');
-        expect(chip?.on).toBe(true);
-    });
-    it('says a page past the end is past the end', async () => {
-        const res = await call(t.listHotels, { city: 'Hong Kong', offset: 10 });
-        expect(res.text).toMatch(/past the end: 4 match/);
-    });
-    it('leaves a currency of add-ons alone out of the trip total', async () => {
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
-        await call(t.addToTrip, { hotel: 'shanghai-pudong', extra: 'airport-transfer', quantity: 1 });
-        const trip = await call(t.viewTrip);
-        const groups = trip.structured.groups;
-        expect(groups.map((g) => [g.currency, !!g.goesWithAStay])).toEqual([
-            ['HKD', false],
-            ['CNY', true],
-        ]);
-        expect(trip.structured.total).toBe(groups[0]?.total);
-    });
-    it('says a hotel has no room for the party, not no room for the nights', async () => {
-        const res = await call(t.listHotels, { city: 'Hong Kong', ...STAY, guests: 5 });
-        const tiles = res.structured.hotels;
-        expect(tiles.every((h) => /No room here sleeps 5/.test(h.noRoomsForStay ?? ''))).toBe(true);
-    });
-    it('lets a lapsed hold go before pricing a list', async () => {
-        const three = { ...STAY, guests: 3 };
-        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'suite', ...three });
-        await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
-        const held = await call(t.listHotels, { city: 'Hong Kong', ...three });
-        const island = () => held.structured.hotels;
-        expect(island().find((h) => h.id === 'hong-kong-island')?.noRoomsForStay).toBeDefined();
-        clock += 3 * 3_600_000;
-        const lapsed = await call(t.listHotels, { city: 'Hong Kong', ...three });
-        const tile = lapsed.structured.hotels.find((h) => h.id === 'hong-kong-island');
-        expect(tile?.noRoomsForStay).toBeUndefined();
-    });
-});
-//# sourceMappingURL=tools.test.js.map