@curless/hotel-storefront 0.18.3 → 0.19.1

package/dist/tools.js

@@ -71,7 +71,7 @@ export const buildTools = (n, v) => {
     return [
         {
             name: n.listHotels,
-            description: `${v.brand} ${v.nounPlural}, shown as a card with a picture, the city and area, a rating where the ${v.noun} publishes one, and a from-price for each. \`city\` or \`query\` narrows the list; a city usually holds several ${v.nounPlural}, and all of them are returned. Unnarrowed it answers with one page of a longer list, ordered by how many ${v.nounPlural} the group has in each city - a country is ordered the same way - and says how many it left out and where the next page starts. \`sort\` and \`maxNightly\` order and cap by the from-price where the matches share one currency. Words or a place that match nothing are widened once, and the answer names what it widened to. Dates are not needed here and no stay is priced.${v.hints.search ? ` ${v.hints.search}` : ''}`,
+            description: `${v.brand} ${v.nounPlural}, shown as a card. Asked with no place - or a country of many cities - it answers with the places to choose from: regions, countries and cities, each with how many ${v.nounPlural} it has; \`all\` lists the ${v.nounPlural} themselves. \`city\` (a city or a country) or \`query\` answers with the ${v.nounPlural}: a picture, the city and area, a rating where the ${v.noun} publishes one, and a from-price, and a city usually holds several. With \`checkIn\` and \`checkOut\` every ${v.noun} is priced for those nights - its cheapest room that takes the party, \`rooms\` of it, for the whole stay with taxes - or marked as having no room for them. \`sort\` and \`maxNightly\` order and cap by that price, or by the from-price without dates, where the matches share one currency. \`brand\`, \`facilities\`, \`freeCancellation\` and \`breakfast\` narrow the list, and the answer counts what each would leave. A long list comes a page at a time: the answer says how many more there are and the \`offset\` of the next page. Words or a place that match nothing are widened once, and the answer names what it widened to.${v.hints.search ? ` ${v.hints.search}` : ''}`,
             annotations: reads(`Browse ${v.brand} ${v.nounPlural}`, open),
             inputSchema: {
                 type: 'object',
@@ -80,15 +80,23 @@ export const buildTools = (n, v) => {
                         type: 'string',
                         description: "Free text over the name, city, area, description and amenities - the guest's own words",
                     },
-                    city: { type: 'string', description: 'One city, e.g. "Hong Kong"' },
+                    city: {
+                        type: 'string',
+                        description: 'One city or one country, e.g. "Hong Kong" or "Japan"',
+                    },
+                    ...stayProps,
+                    rooms: {
+                        type: 'number',
+                        description: `With dates: how many rooms of one type the party needs, 1 to ${MAX_ROOMS_PER_LINE}. Default 1`,
+                    },
                     sort: {
                         type: 'string',
                         enum: ['group', 'price-low', 'price-high', 'rating'],
-                        description: `Default \`group\`: the cities the group has most ${v.nounPlural} in lead the list. A price order holds only where the matches share one currency - across currencies it is dropped and the answer says which currencies they are`,
+                        description: `Default \`group\`: the cities the group has most ${v.nounPlural} in lead the list. A price order - by the stay's price with dates, the from-price without - holds only where the matches share one currency; across currencies it is dropped and the answer says which currencies they are`,
                     },
                     maxNightly: {
                         type: 'number',
-                        description: 'A ceiling on the from-price, in the currency the matches are quoted in. Across currencies it is dropped and the answer says so',
+                        description: 'A ceiling on the price of a night - of the stay with dates, the from-price without - in the currency the matches are quoted in. Across currencies it is dropped and the answer says so',
                     },
                     limit: {
                         type: 'number',
@@ -153,7 +161,11 @@ export const buildTools = (n, v) => {
                     ...stayProps,
                     booking: {
                         type: 'string',
-                        description: `A booking's confirmation code. The answer is then that booking's ${v.noun}, its add-ons for those nights and how many of each the booking holds; ${n.previewChange} changes them`,
+                        description: `A booking's confirmation code. The answer is then that booking's ${v.noun}, its add-ons for those nights and how many of each the booking holds`,
+                    },
+                    email: {
+                        type: 'string',
+                        description: 'The email the booking was made with, when it was made elsewhere',
                     },
                 },
             },
@@ -227,7 +239,7 @@ export const buildTools = (n, v) => {
                     },
                     rememberRequests: {
                         type: 'boolean',
-                        description: 'True when the guest asked for these room preferences to be remembered for their next stays. Needs a signed-in member; what is kept is the lasting kind - a bed type, a floor, a quiet, connecting or accessible room',
+                        description: 'True when the guest asked for these room preferences to be remembered for their next stays. Needs a signed-in member; what is kept is the lasting kind - a bed type, a floor, a quiet or connecting room; an accessible room is asked for on each stay and is not kept',
                     },
                 },
                 required: ['name', 'email'],
@@ -471,7 +483,7 @@ export const buildTools = (n, v) => {
         },
         {
             name: n.forgetPreferences,
-            description: `Forgets the room preferences saved on the signed-in ${v.brand} membership - a bed type, a floor, a quiet or accessible room. Bookings already made keep what they asked for.`,
+            description: `Forgets the room preferences saved on the signed-in ${v.brand} membership - a bed type, a floor, a quiet or connecting room. Bookings already made keep what they asked for.`,
             annotations: {
                 title: 'Forget my saved preferences',
                 readOnlyHint: false,
@@ -816,6 +828,10 @@ const quoteForCard = (quote) => ({
         stay: l.stay,
         nights: l.nights,
         quantity: l.quantity,
+        // How many were ORDERED, beside how many units that comes to: one extra
+        // bed over three nights is quantity 3 and ordered 1, and the card's
+        // stepper read 3 and sent 3 ± 1 as the new count (2026-09-28 audit).
+        ...(l.ordered !== undefined ? { ordered: l.ordered } : {}),
         unit: formatMoney(l.unit),
         total: formatMoney(l.total),
         refundable: l.refundable,
@@ -839,7 +855,7 @@ const tripText = (quote, demo) => {
         return 'The trip is empty.';
     const lines = quote.lines.map((l) => l.kind === 'room'
         ? `- ${l.quantity ?? 1}× ${l.title} at ${l.hotelName}, ${l.stay?.checkIn} to ${l.stay?.checkOut} (${l.nights} nights) — ${formatMoney(l.total)}`
-        : `- ${l.quantity}× ${l.title} — ${formatMoney(l.total)}`);
+        : `- ${l.ordered ?? l.quantity}× ${l.title}${l.ordered !== undefined && l.quantity !== undefined && l.quantity !== l.ordered ? ` (${l.quantity} in all, over the stay)` : ''} — ${formatMoney(l.total)}`);
     return [
         ...lines,
         `Taxes and fees ${formatMoney(quote.taxesAndFees)} · **Total ${formatMoney(quote.total)}**`,
@@ -1000,23 +1016,30 @@ const widen = (ask) => {
 };
 /** What a change would do, in one sentence - the nights, and the add-on when it sets one. */
 const changeSentence = (p) => {
-    const moves = !!p.to &&
-        (p.to.stay.checkIn !== p.from.stay.checkIn ||
-            p.to.stay.checkOut !== p.from.stay.checkOut ||
-            p.to.rooms !== p.from.rooms ||
-            p.to.roomName !== p.from.roomName);
+    // ⚠️ EACH THING THAT CHANGES, NAMED AS WHAT IT IS. Two rooms down to one
+    // was said as "would move to" the nights it already held, and an add-on set
+    // to the count it already had as "take it off" (2026-09-28 audit).
+    const to = p.to;
+    const rooms = (n) => `${n} room${n === 1 ? '' : 's'}`;
     const a = p.addOn;
-    const addOn = !a
-        ? ''
-        : a.to === 0
-            ? `take ${a.name} off`
-            : a.from === 0
-                ? `add ${a.to}× ${a.name}`
-                : `change ${a.name} from ${a.from} to ${a.to}`;
-    const nights = moves
-        ? `move to ${p.to?.stay.checkIn} - ${p.to?.stay.checkOut}${p.to && p.to.rooms > 1 ? `, ${p.to.rooms} rooms` : ''}`
-        : '';
-    return `${p.confirmationCode} would ${[nights, addOn].filter(Boolean).join(' and ')}.`;
+    const parts = [
+        to && (to.stay.checkIn !== p.from.stay.checkIn || to.stay.checkOut !== p.from.stay.checkOut)
+            ? `move to ${to.stay.checkIn} - ${to.stay.checkOut}`
+            : '',
+        to && to.roomName !== p.from.roomName ? `change the room to ${to.roomName}` : '',
+        to && to.rooms !== p.from.rooms ? `go from ${rooms(p.from.rooms)} to ${rooms(to.rooms)}` : '',
+        !a || a.from === a.to
+            ? ''
+            : a.to === 0
+                ? `take ${a.name} off`
+                : a.from === 0
+                    ? `add ${a.to}× ${a.name}`
+                    : `change ${a.name} from ${a.from} to ${a.to}`,
+    ].filter(Boolean);
+    const said = parts.length > 1
+        ? `${parts.slice(0, -1).join(', ')} and ${parts.at(-1)}`
+        : (parts[0] ?? 'change');
+    return `${p.confirmationCode} would ${said}.`;
 };
 /**
  * How much of a plan is real, in the one sentence the model is told to repeat:
@@ -1135,6 +1158,57 @@ const identity = (deps, ctx, key, args = {}) => {
         ...(member ? { member } : {}),
     };
 };
+/**
+ * What the last preview of each booking's cancellation or change showed, per
+ * conversation.
+ *
+ * ⚠️ A CONFIRMATION CONFIRMS WHAT WAS SHOWN. A cancellation previewed at no
+ * charge and confirmed after the free window closed was cancelled for a
+ * night's rate nobody had been shown; a `confirmed` with no preview at all was
+ * cancelled on the spot (2026-09-28 audit). Now a confirmation goes through
+ * only when the fee - or the change's new total - is the one last shown in
+ * this conversation; otherwise it answers with the preview again.
+ */
+const shownPreviews = new WeakMap();
+const MAX_SHOWN = 5_000;
+const previewsOf = (deps) => {
+    let m = shownPreviews.get(deps);
+    if (!m) {
+        m = new Map();
+        shownPreviews.set(deps, m);
+    }
+    return m;
+};
+const remember = (deps, k, amount) => {
+    const m = previewsOf(deps);
+    m.delete(k);
+    m.set(k, amount);
+    while (m.size > MAX_SHOWN) {
+        const oldest = m.keys().next().value;
+        if (oldest === undefined)
+            break;
+        m.delete(oldest);
+    }
+};
+/** Said when a lookup has missed too often - see limits.ts. */
+const TOO_MANY_TRIES = 'Too many codes and emails that did not match, so looking a booking up by email is paused for a quarter of an hour. Check the code and the email on the confirmation, then try again.';
+/**
+ * A booking lookup, with any email in it counted as a guess.
+ *
+ * ⚠️ A CODE AND AN EMAIL ARE ONLY A PAIR WHEN SOMETHING COUNTS THE MISSES. A
+ * miss that carried an email is counted against the conversation AND the
+ * email; after a few, lookups by email wait (limits.ts). A lookup of this
+ * conversation's own booking, with no email, is never counted and never waits.
+ */
+const guarded = async (deps, key, who, run) => {
+    const keys = who.email ? [`lookup|${key}`, `email|${who.email.trim().toLowerCase()}`] : [];
+    if (keys.length && deps.misses?.blocked(keys))
+        return { found: null, tooMany: true };
+    const found = await run();
+    if (!found && keys.length)
+        deps.misses?.miss(keys);
+    return { found, tooMany: false };
+};
 /**
  * The trip priced one currency at a time, in the order the currencies first
  * appear in it.
@@ -1205,6 +1279,7 @@ const currentTrip = async (deps, key, who) => {
         };
     }
     const shaped = parts.map(quoteForCard);
+    const bookable = parts.map((p) => p.lines.some((l) => l.kind === 'room'));
     return {
         structured: {
             view: 'trip',
@@ -1213,9 +1288,24 @@ const currentTrip = async (deps, key, who) => {
             // One block per currency, each with its own taxes and total. `total` is
             // the totals side by side for anything that reads one string - a list,
             // never a sum.
-            groups: shaped.map((p, i) => ({ ...p, currency: parts[i]?.total.currency })),
+            //
+            // ⚠️ A CURRENCY OF ADD-ONS ALONE IS NOT PART OF WHAT IS BOOKED. A
+            // transfer at a Paris hotel with no Paris room made its own € block, and
+            // the trip's total read "HK$8,588 · €347" for a request that refuses
+            // the €347 (2026-09-28 audit). It is drawn, marked, and left out.
+            groups: shaped.map((p, i) => ({
+                ...p,
+                currency: parts[i]?.total.currency,
+                ...(bookable[i] ? {} : { goesWithAStay: true }),
+            })),
             currencies: parts.map((p) => p.total.currency),
-            total: shaped.map((p) => p.total).join(' + '),
+            // Side by side with a dot, not a plus: "HK$8,588 + ¥152,550" reads as
+            // a sum nobody can do.
+            total: (shaped.filter((_, i) => bookable[i]).length
+                ? shaped.filter((_, i) => bookable[i])
+                : shaped)
+                .map((p) => p.total)
+                .join(' · '),
             ...needs,
             ...(shaped.some((p) => p.dropped) ? { dropped: shaped.flatMap((p) => p.dropped ?? []) } : {}),
             count: lines.length,
@@ -1317,7 +1407,9 @@ const suggestionsFor = async (deps, d) => {
         const nearby = await deps.backend.searchHotels({ city: hotel.city, limit: 2 });
         if (nearby.total > 1)
             out.push({
-                label: `Compare with the other ${hotel.city} hotels`,
+                // The label IS what is sent: a chip that sends more than it says is
+                // a chip that says something else in the guest's name.
+                label: `Compare ${hotel.name} with the other ${hotel.city} hotels`,
                 say: `Compare ${hotel.name} with the other ${hotel.city} hotels`,
             });
     }
@@ -1338,7 +1430,7 @@ const suggestionsFor = async (deps, d) => {
     }
     if (view === 'itinerary' && Number(d.planned) > Number(d.inTrip) + Number(d.booked ?? 0))
         out.push({
-            label: 'Put these stays in the trip',
+            label: 'Put the stays on this plan in the trip',
             say: 'Put the stays on this plan in the trip',
         });
     if (view === 'booking') {
@@ -1395,11 +1487,21 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             sort,
             maxNightly: ceiling,
             stay: asStay(args),
-            rooms: typeof args.rooms === 'number' ? args.rooms : undefined,
+            // Clamped here, so what is said and echoed is what was priced: "9 rooms"
+            // was said over prices for five.
+            rooms: typeof args.rooms === 'number' && Number.isFinite(args.rooms)
+                ? Math.max(1, Math.min(MAX_ROOMS_PER_LINE, Math.floor(args.rooms)))
+                : undefined,
             filters: filtersOf(args),
         };
         const who = identity(deps, ctx, key, args);
         let answer = await deps.backend.searchHotels(ask, who);
+        // A brand as the data spells it, so its chip shows as ON and can be turned
+        // off: `brand: 'kerry'` filtered, and then no chip matched it.
+        const brandAsked = ask.filters?.brand?.toLowerCase();
+        const brandNamed = answer.refine?.brands.find((b) => b.name.toLowerCase() === brandAsked)?.name;
+        if (ask.filters && brandNamed)
+            ask.filters = { ...ask.filters, brand: brandNamed };
         // The search the answer actually came from - the widened one, when it was
         // widened - so its next page is the next page of THAT.
         let asked = ask;
@@ -1419,20 +1521,29 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         // comment was written to forbid, committed by the code under it.
         // `overBudget` is how the seam says the place and the words did match.
         let widened;
-        // ⚠️ A FILTER THAT EMPTIED THE LIST IS NOT A SEARCH THAT FAILED either,
-        // for the same reason as the ceiling below: the place matched.
-        const filteredEmpty = !!ask.filters && (answer.beforeFilters ?? 0) > 0;
-        if (answer.total === 0 && !answer.overBudget && !filteredEmpty) {
+        // ⚠️ A FILTER OR A CEILING THAT EMPTIED THE LIST IS NOT A SEARCH THAT
+        // FAILED either, for the same reason as the ceiling above: the place
+        // matched. What matched the place and the words, before either:
+        const placedCount = (a) => a.beforeFilters ?? a.beforeCeiling ?? a.total;
+        if (placedCount(answer) === 0) {
             const wider = widen(ask);
             if (wider) {
                 const second = await deps.backend.searchHotels(wider.ask, who);
-                widened = { from: wider.from, to: wider.to, found: second.total > 0 };
-                if (second.total > 0) {
+                // Found when the wider PLACE matched - a wider search emptied by the
+                // same ceiling or filter is still the place, and "Hong Kong found
+                // nothing either" was said of four hotels over the ceiling.
+                widened = { from: wider.from, to: wider.to, found: placedCount(second) > 0 };
+                if (widened.found) {
                     answer = second;
                     asked = { ...ask, ...wider.ask };
                 }
             }
         }
+        const filteredEmpty = !!asked.filters &&
+            answer.total === 0 &&
+            placedCount(answer) > 0 &&
+            (answer.beforeCeiling ?? 0) === 0;
+        const ceilingEmpty = answer.total === 0 && (answer.beforeCeiling ?? 0) > 0;
         // The ceiling again on this side of the seam. MAX_PAGE is part of the
         // backend contract, but "the next backend honours it" is not something the
         // card can be built on - and the cost of it being wrong is the whole group
@@ -1486,6 +1597,21 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 ...(ask.rooms && ask.rooms > 1 ? { rooms: ask.rooms } : {}),
             }
             : {};
+        // ⚠️ THE SEARCH AS ASKED, `all` INCLUDED. The echo dropped `all`, so every
+        // re-query the card made from a "Browse all" list - new dates, the default
+        // order, clearing a filter - met no place, no words and no filter, and
+        // came back as the destinations page (2026-09-28 audit). Built once, for
+        // the list and for the list a filter or a ceiling emptied.
+        const listAll = args.all === true;
+        const echo = (applied) => ({
+            ...(asked.query ? { query: asked.query } : {}),
+            ...(asked.city ? { city: asked.city } : {}),
+            ...(applied !== 'group' ? { sort: applied } : {}),
+            ...(asked.maxNightly ? { maxNightly: asked.maxNightly } : {}),
+            ...(asked.filters ?? {}),
+            ...(listAll ? { all: true } : {}),
+            ...stayArgs,
+        });
         const namedCountry = !!asked.city &&
             facets?.countries.length === 1 &&
             facets.countries[0]?.name.toLowerCase() === asked.city.toLowerCase();
@@ -1495,8 +1621,19 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             sort === 'group' &&
             !asked.maxNightly &&
             !offset &&
-            args.all !== true &&
+            !listAll &&
+            // A widened search is a list with the miss said over it: as a page of
+            // places, "helipad" matching nothing in China was never said at all.
+            !widened &&
             (!asked.city || (namedCountry && facets.cities.length >= CITY_PICKER_MIN));
+        // "Today" where the hotels are - earliest and latest - for a page that has
+        // no one hotel's clock to fill its date bar from (see the card's
+        // `todayRange`): the UTC date was yesterday in Asia before 8am.
+        const days = answer.hotels
+            .map((h) => h.todayThere)
+            .filter((x) => !!x)
+            .sort();
+        const today = days.length ? { min: days[0], max: days.at(-1) } : undefined;
         if (choosing && facets) {
             const countries = facets.countries.map((c) => ({
                 name: c.name,
@@ -1505,10 +1642,10 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                     .filter((x) => x.country === c.name)
                     .map((x) => ({ name: x.name, count: x.count })),
             }));
-            const top = (xs) => xs
-                .slice(0, 3)
-                .map((x) => `${x.name} (${x.count})`)
-                .join(', ');
+            // Every place, counted: a host with no card has only this sentence, and
+            // "the most are in" three of forty cities left the other thirty-seven
+            // for a guest to guess at.
+            const every = (xs) => xs.map((x) => `${x.name} (${x.count})`).join(', ');
             const n = deps.vocab.nounPlural;
             if (namedCountry) {
                 const [only] = countries;
@@ -1520,8 +1657,9 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                         scope: only,
                         ask: { city: asked.city, ...stayArgs },
                         ...(ask.stay ? { stay: ask.stay } : {}),
+                        ...(today ? { today } : {}),
                     },
-                    text: `${total} ${deps.vocab.brand} ${n} in ${only?.name}, in ${only?.cities.length} cities - the card lists the cities to choose from; the most are in ${top(only?.cities ?? [])}. \`all\` lists the ${n} themselves.`,
+                    text: `${total} ${deps.vocab.brand} ${n} in ${only?.name}, in ${only?.cities.length} cities to choose from: ${every(only?.cities ?? [])}. A city lists its ${n}; \`all\` lists every one in ${only?.name}.`,
                 };
             }
             const regions = [
@@ -1543,8 +1681,9 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                     regions,
                     ask: { ...stayArgs },
                     ...(ask.stay ? { stay: ask.stay } : {}),
+                    ...(today ? { today } : {}),
                 },
-                text: `${total} ${deps.vocab.brand} ${n} in ${facets.cities.length} cities across ${countries.length} countries - the card sets them out by region, country and city for the guest to choose from; the most are in ${top(countries)}.`,
+                text: `${total} ${deps.vocab.brand} ${n} in ${facets.cities.length} cities across ${countries.length} countries, to choose from by region, country and city - ${regions.map((r) => `${r.name}: ${every(r.countries)}`).join('; ')}. A city or a country lists its ${n}.`,
             };
         }
         if (hotels.length === 0) {
@@ -1552,9 +1691,39 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 ...h,
                 summary: hotelText('description', h.name, h.summary, DESCRIPTION_MAX).text,
                 fromNightly: h.fromNightly ? formatMoney(h.fromNightly) : undefined,
+                ...(h.forStay
+                    ? {
+                        forStay: {
+                            ...h.forStay,
+                            total: formatMoney(h.forStay.total),
+                            nightly: formatMoney(h.forStay.nightly),
+                        },
+                    }
+                    : {}),
             }));
-            const cheapest = answer.nearest?.[0]?.fromNightly;
+            const [first] = answer.nearest ?? [];
+            // On named nights, a night of the stay that was priced - the list rate
+            // was quoted beside a ceiling it was never held against.
+            const cheapest = first?.forStay?.nightly ?? first?.fromNightly;
             const capCurrency = answer.currencies[0] ?? cheapest?.currency ?? 'HKD';
+            const cap = formatMoney(money(toMinor(Number(ceiling), capCurrency), capCurrency));
+            const pastTheEnd = answer.total > 0 && offset > 0;
+            const why = pastTheEnd
+                ? `That page is past the end: ${answer.total} match, so \`offset\` 0 to ${answer.total - 1} is where they are.`
+                : filteredEmpty
+                    ? emptiedBy(asked.filters ?? {}, answer.beforeFilters ?? 0, deps.vocab.nounPlural)
+                    : ceilingEmpty && nearest.length
+                        ? `Nothing under ${cap} a night. The cheapest that matched is ${first?.name} at ${cheapest ? formatMoney(cheapest) : '-'}${answer.overBudget && answer.overBudget > 1 ? `, of ${answer.overBudget} over the ceiling` : ''}.`
+                        : ceilingEmpty
+                            ? `None of the ${answer.beforeCeiling} that match has a room for those nights.`
+                            : [
+                                `No ${deps.vocab.brand} ${deps.vocab.nounPlural} match that.`,
+                                // What was tried and also failed is worth a sentence: it tells a
+                                // guest the word itself is the problem, not the narrowing.
+                                widened ? `${sentence(widened.to)} found nothing either.` : '',
+                            ]
+                                .filter(Boolean)
+                                .join(' ');
             return {
                 structured: {
                     view: 'no-hotels',
@@ -1563,33 +1732,28 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                     total: 0,
                     query,
                     ...(nearest.length ? { nearest, overBudget: answer.overBudget } : {}),
-                    // The way back out of a filter that emptied it: the same search,
-                    // with the chips to take one off.
+                    ...(ask.stay ? { stay: ask.stay } : {}),
+                    ...(widened?.found ? { widened } : {}),
+                    // Why it is empty, in the words the model is told, so the card says
+                    // the same thing rather than guessing at it.
+                    why,
+                    // The way back out of a filter that emptied it: the same search -
+                    // its order, its ceiling and its nights too - with the chips to take
+                    // one off. Taking one off dropped the sort and the ceiling.
                     ...(filteredEmpty
                         ? {
-                            ask: {
-                                ...(asked.query ? { query: asked.query } : {}),
-                                ...(asked.city ? { city: asked.city } : {}),
-                                ...(asked.filters ?? {}),
-                                ...stayArgs,
-                            },
+                            ask: echo(sort),
                             ...(answer.refine ? { refine: refineFor(answer.refine, asked.filters, 0) } : {}),
                             beforeFilters: answer.beforeFilters,
                         }
                         : {}),
                 },
-                text: filteredEmpty
-                    ? emptiedBy(asked.filters ?? {}, answer.beforeFilters ?? 0, deps.vocab.nounPlural)
-                    : nearest.length
-                        ? `Nothing under ${formatMoney(money(toMinor(Number(ceiling), capCurrency), capCurrency))} a night. The cheapest that matched is ${answer.nearest?.[0]?.name} at ${cheapest ? formatMoney(cheapest) : '-'}${answer.overBudget && answer.overBudget > 1 ? `, of ${answer.overBudget} over the ceiling` : ''}.`
-                        : [
-                            `No ${deps.vocab.brand} ${deps.vocab.nounPlural} match that.`,
-                            // What was tried and also failed is worth a sentence: it tells a
-                            // guest the word itself is the problem, not the narrowing.
-                            widened ? `${sentence(widened.to)} found nothing either.` : '',
-                        ]
-                            .filter(Boolean)
-                            .join(' '),
+                text: [
+                    widened?.found ? `Nothing matched ${widened.from}, so this looked in ${widened.to}.` : '',
+                    why,
+                ]
+                    .filter(Boolean)
+                    .join(' '),
             };
         }
         const forCard = hotels.map((h) => ({
@@ -1648,14 +1812,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 sort: applied,
                 // The search as asked, so "show more" is this search's next page and
                 // not a new one - and a place chip keeps the order the guest chose.
-                ask: {
-                    ...(asked.query ? { query: asked.query } : {}),
-                    ...(asked.city ? { city: asked.city } : {}),
-                    ...(applied !== 'group' ? { sort: applied } : {}),
-                    ...(asked.maxNightly ? { maxNightly: asked.maxNightly } : {}),
-                    ...(asked.filters ?? {}),
-                    ...stayArgs,
-                },
+                ask: echo(applied),
                 ...(ask.stay ? { stay: ask.stay } : {}),
                 ...(answer.refine
                     ? { refine: refineFor(answer.refine, asked.filters, total, !!ask.stay) }
@@ -1693,7 +1850,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             };
         }
         const h = detail.hotel;
-        const description = hotelText('description', h.name, h.summary, DESCRIPTION_MAX);
+        const description = hotelText('description', h.name, h.summary, DESCRIPTION_MAX, deps.vocab.demo);
         const policies = await deps.backend.policies(h.id);
         const extras = await deps.backend.extrasFor(h.id, stay);
         const base = {
@@ -1794,7 +1951,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             },
             text: [
                 `**${h.name}** · ${enough.length} room ${enough.length === 1 ? 'type' : 'types'} for ${stay.checkIn} to ${stay.checkOut}, ${stay.guests} guests${roomsWanted > 1 ? `, ${roomsWanted} rooms` : ''}.`,
-                ...enough.map((r) => `- ${r.name} — ${formatMoney(r.nightly)} a night, ${formatMoney(r.stayTotal)} for the stay incl. taxes and fees${roomsWanted > 1 ? ` (${formatMoney(multiplyMoney(r.stayTotal, roomsWanted))} for ${roomsWanted} rooms)` : ''}${r.refundable ? `, free to cancel${r.freeCancellationUntil ? ` until ${r.freeCancellationUntil.slice(0, 10)}` : ''}` : ', non-refundable'}`),
+                ...enough.map((r) => `- ${r.name} — ${formatMoney(r.nightly)} a night, ${formatMoney(r.stayTotal)} for the stay incl. taxes and fees${roomsWanted > 1 ? ` (${formatMoney(multiplyMoney(r.stayTotal, roomsWanted))} for ${roomsWanted} rooms)` : ''}${r.freeCancellationUntil ? `, free to cancel until ${r.freeCancellationUntil.slice(0, 10)}` : r.refundable ? ', the free cancellation window has closed - cancelling costs a night' : ', non-refundable'}`),
                 flex.text,
                 deps.vocab.demo ? DEMO_NOTE : '',
             ]
@@ -1808,14 +1965,35 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         // transfer had nowhere to go. Asked with a booking, this lists that
         // hotel's add-ons for that booking's nights, with what it already holds.
         const code = str(args.booking);
-        const found = code
-            ? await deps.backend.findBooking(code, identity(deps, ctx, key, args))
-            : null;
+        const who = identity(deps, ctx, key, args);
+        const { found, tooMany } = code
+            ? await guarded(deps, key, who, () => deps.backend.findBooking(code, who))
+            : { found: null, tooMany: false };
         const booked = found && (found.status === 'requested' || found.status === 'confirmed') ? found : undefined;
+        if (code && found && !booked) {
+            // Found, and over: saying "no booking matches" about a booking the guest
+            // is looking at sends them hunting for a code they have right.
+            return {
+                structured: {
+                    view: 'error',
+                    ...common(deps, key),
+                    error: 'booking-ended',
+                    detail: `${found.confirmationCode} is ${found.status}, so nothing can be added to it.`,
+                },
+                text: `${found.confirmationCode} is ${found.status}, so nothing can be added to it. An add-on goes on a booking that still holds its rooms.`,
+            };
+        }
         if (code && !booked) {
             return {
-                structured: { view: 'booking-not-found', ...common(deps, key), query: code },
-                text: 'No booking here matches that code. A booking made in another conversation needs the email it was made with.',
+                structured: {
+                    view: 'booking-not-found',
+                    ...common(deps, key),
+                    query: code,
+                    ...(tooMany ? { tooMany: true } : {}),
+                },
+                text: tooMany
+                    ? TOO_MANY_TRIES
+                    : 'No booking here matches that code. A booking made in another conversation needs the email it was made with.',
             };
         }
         const wanted = booked ? booked.hotelId : str(args.hotel);
@@ -2017,8 +2195,17 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                     };
                 }
                 else {
-                    const kept = await deps.backend.rememberPreferences(signedIn, lasting);
+                    // ADDED TO what is kept, not in place of it: a quiet room remembered
+                    // this time silently dropped the king bed remembered last time. A new
+                    // request does replace its opposite - twin beds over a king bed.
+                    const clash = (k) => lasting.some((n) => OPPOSITES.some((pair) => pair.includes(n) && pair.includes(k)));
+                    const merged = [
+                        ...(signedIn.preferences ?? []).filter((k) => !lasting.includes(k) && !clash(k)),
+                        ...lasting,
+                    ];
+                    const kept = await deps.backend.rememberPreferences(signedIn, merged);
                     deps.members.set(key, { ...signedIn, preferences: kept });
+                    deps.members.setPreferences(signedIn.number, kept);
                     remembered = {
                         kept,
                         line: `Remembered on this ${signedIn.programme} membership for next time: ${kept.map((k) => REQUEST_WORDS[k]).join(', ')}. ${t.forgetPreferences} forgets them.`,
@@ -2055,6 +2242,10 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                                 quote: quoteForCard(booking.quote),
                                 total: formatMoney(booking.quote.total),
                                 ...(asked.length ? { requested: asked } : {}),
+                                // Each its own warning colour - it rode on the first alone.
+                                ...(booking.requests?.kinds.includes('accessible-room')
+                                    ? { accessibility: true }
+                                    : {}),
                             })),
                         }
                         : {}),
@@ -2100,8 +2291,19 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         const here = await deps.backend.listBookings(who, typeof args.limit === 'number' ? args.limit : undefined);
         // Elsewhere, only with the code AND the email - see `listBookings`.
         const code = str(args.booking);
-        const there = code && str(args.email) ? await deps.backend.findBooking(code, who) : null;
+        const { found: there, tooMany } = code && str(args.email)
+            ? await guarded(deps, key, who, () => deps.backend.findBooking(code, who))
+            : { found: null, tooMany: false };
         const bookings = there && !here.some((b) => b.id === there.id) ? [there, ...here] : here;
+        // ⚠️ A MISS IS SAID EVEN WHEN THERE IS SOMETHING TO LIST. With two
+        // bookings in the conversation, a wrong code answered "2 bookings" and
+        // nothing else - read as "found it" (2026-09-28 audit).
+        const missed = code && !there;
+        const missLine = tooMany
+            ? TOO_MANY_TRIES
+            : code && !str(args.email)
+                ? 'A booking made elsewhere needs the email it was made with as well as its code.'
+                : 'No booking matches that confirmation code and email. Both are needed, as they are on the confirmation.';
         return {
             structured: {
                 view: 'bookings',
@@ -2110,13 +2312,19 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 count: bookings.length,
                 // What was looked for, so a card can say THAT did not match rather
                 // than "nothing in this conversation".
-                ...(code && !there ? { notFound: code } : {}),
+                ...(missed ? { notFound: code, notFoundLine: missLine } : {}),
+                ...(tooMany ? { tooMany: true } : {}),
             },
-            text: bookings.length
-                ? bookings.map(bookingLine).join('\n')
-                : code
-                    ? 'No booking matches that confirmation code and email. Both are needed, as they are on the confirmation.'
-                    : 'No bookings in this conversation. A booking made elsewhere is found with its confirmation code and the email it was made with.',
+            text: [
+                missed ? missLine : '',
+                bookings.length
+                    ? bookings.map(bookingLine).join('\n')
+                    : code
+                        ? ''
+                        : 'No bookings in this conversation. A booking made elsewhere is found with its confirmation code and the email it was made with.',
+            ]
+                .filter(Boolean)
+                .join('\n'),
         };
     }
     if (name === t.previewChange || name === t.changeBooking) {
@@ -2130,11 +2338,18 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             ...(str(args.extra) ? { extra: str(args.extra) } : {}),
             ...(typeof args.quantity === 'number' ? { quantity: args.quantity } : {}),
         };
-        const preview = await deps.backend.previewChange(ref, change, who);
+        const { found: preview, tooMany } = await guarded(deps, key, who, () => deps.backend.previewChange(ref, change, who));
         if (!preview) {
             return {
-                structured: { view: 'booking-not-found', ...common(deps, key), query: ref },
-                text: 'No booking here matches that code. A booking made in another conversation needs the email it was made with.',
+                structured: {
+                    view: 'booking-not-found',
+                    ...common(deps, key),
+                    query: ref,
+                    ...(tooMany ? { tooMany: true } : {}),
+                },
+                text: tooMany
+                    ? TOO_MANY_TRIES
+                    : 'No booking here matches that code. A booking made in another conversation needs the email it was made with.',
             };
         }
         const stayOf = (x) => ({
@@ -2176,16 +2391,48 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                         : 'The total is unchanged.',
                     preview.rule,
                     `Say the word and it moves (${t.changeBooking} with \`confirmed\`).`,
-                ].join(' ')
+                    deps.vocab.demo ? DEMO_NOTE : '',
+                ]
+                    .filter(Boolean)
+                    .join(' ')
                 : preview.rule,
         };
         // ⚠️ THE PREVIEW IS NOT ADVISORY, for the same reason the cancellation's is
         // not: a change re-prices the stay, and a guest who never saw the new total
-        // finds it at the desk.
+        // finds it at the desk. And it confirms what was SHOWN - see
+        // `shownPreviews`.
+        // Keyed by what the change COMES TO, not how it was asked: the card sends
+        // its confirmation from the preview's own nights and rooms, which need not
+        // be the words the preview was asked in.
+        const shownKey = [
+            key,
+            'change',
+            preview.bookingId,
+            preview.to?.stay.checkIn,
+            preview.to?.stay.checkOut,
+            preview.to?.rooms,
+            preview.to?.roomName,
+            preview.addOn ? `${preview.addOn.id}:${preview.addOn.to}` : '',
+        ].join('|');
+        const wasShown = previewsOf(deps).get(shownKey);
+        const newTotal = preview.to?.total.minor;
+        if (newTotal !== undefined)
+            remember(deps, shownKey, newTotal);
         if (name === t.previewChange || args.confirmed !== true)
             return asPreview;
         if (!preview.changeable)
             return asPreview;
+        if (wasShown === undefined || wasShown !== newTotal) {
+            return {
+                ...asPreview,
+                text: [
+                    wasShown === undefined
+                        ? 'Nothing has changed yet: this is what the change would do, for the guest to see first.'
+                        : `The price of this change has moved since it was shown - it is now ${preview.to ? formatMoney(preview.to.total) : '-'} in all. Nothing has changed yet.`,
+                    asPreview.text,
+                ].join(' '),
+            };
+        }
         try {
             const changed = await deps.backend.changeBooking(ref, change, who);
             if (!changed)
@@ -2219,11 +2466,18 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
     if (name === t.previewCancellation || name === t.cancelBooking) {
         const ref = str(args.booking);
         const who = identity(deps, ctx, key, args);
-        const preview = await deps.backend.previewCancellation(ref, who);
+        const { found: preview, tooMany } = await guarded(deps, key, who, () => deps.backend.previewCancellation(ref, who));
         if (!preview) {
             return {
-                structured: { view: 'booking-not-found', ...common(deps, key), query: ref },
-                text: 'No booking here matches that code. A booking made in another conversation needs the email it was made with.',
+                structured: {
+                    view: 'booking-not-found',
+                    ...common(deps, key),
+                    query: ref,
+                    ...(tooMany ? { tooMany: true } : {}),
+                },
+                text: tooMany
+                    ? TOO_MANY_TRIES
+                    : 'No booking here matches that code. A booking made in another conversation needs the email it was made with.',
             };
         }
         const asPreview = {
@@ -2244,17 +2498,33 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 preview.cancellable
                     ? `Say the word and it is cancelled (${t.cancelBooking} with \`confirmed\`).`
                     : '',
+                deps.vocab.demo ? DEMO_NOTE : '',
             ]
                 .filter(Boolean)
                 .join(' '),
         };
         // ⚠️ THE PREVIEW IS NOT ADVISORY. Cancelling without one is how a guest
         // loses a night's rate they were never told about, so the cancel tool
-        // returns this same preview and does nothing until it is told again.
+        // returns this same preview and does nothing until it is told again - and
+        // told again about the fee that was SHOWN (`shownPreviews`).
+        const shownKey = `${key}|cancel|${preview.bookingId}`;
+        const wasShown = previewsOf(deps).get(shownKey);
+        remember(deps, shownKey, preview.fee.minor);
         if (name === t.previewCancellation || args.confirmed !== true)
             return asPreview;
         if (!preview.cancellable)
             return asPreview;
+        if (wasShown === undefined || wasShown !== preview.fee.minor) {
+            return {
+                ...asPreview,
+                text: [
+                    wasShown === undefined
+                        ? 'Nothing is cancelled yet: this is what cancelling would cost, for the guest to see first.'
+                        : `The fee has changed since it was shown - it is now ${formatMoney(preview.fee)}. Nothing is cancelled yet.`,
+                    asPreview.text,
+                ].join(' '),
+            };
+        }
         const cancelled = await deps.backend.cancelBooking(ref, who, str(args.reason) || undefined);
         if (!cancelled)
             return asPreview;
@@ -2268,7 +2538,12 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 rule: preview.rule,
                 cancellable: false,
             },
-            text: `${cancelled.confirmationCode} is cancelled. ${preview.fee.minor === 0 ? 'No fee.' : `The hotel charges ${formatMoney(preview.fee)}.`}`,
+            text: [
+                `${cancelled.confirmationCode} is cancelled. ${preview.fee.minor === 0 ? 'No fee.' : `The hotel charges ${formatMoney(preview.fee)}.`}`,
+                deps.vocab.demo ? DEMO_NOTE : '',
+            ]
+                .filter(Boolean)
+                .join(' '),
         };
     }
     if (name === t.compare) {
@@ -2282,6 +2557,9 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             stay: asStay(args),
             recommended: str(args.recommended) || undefined,
             title: str(args.title) || undefined,
+            // The member's rate, like the list and the hotel beside it: without
+            // it the comparison quoted HK$5,424 where both said HK$4,610.
+            who: identity(deps, ctx, key),
         });
         if (comparison.columns.length === 0) {
             return {
@@ -2357,7 +2635,23 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
     if (name === t.signIn) {
         const number = str(args.number);
         const surname = str(args.surname);
+        // Counted like a booking lookup - see limits.ts. A number and a surname
+        // read a tier, a point balance and saved preferences.
+        const tries = [`signin|${key}`, `member|${number.replace(/\s+/g, '').toUpperCase()}`];
+        if (deps.misses?.blocked(tries)) {
+            return {
+                structured: {
+                    view: 'member-not-found',
+                    ...common(deps, key),
+                    query: number,
+                    tooMany: true,
+                },
+                text: 'Too many membership numbers and surnames that did not match, so signing in is paused for a quarter of an hour. Check both as they are printed on the card, then try again.',
+            };
+        }
         const member = await deps.backend.signInMember(number, surname);
+        if (!member)
+            deps.misses?.miss(tries);
         if (!member) {
             // ⚠️ NO TIER FOR A NUMBER THAT DID NOT MATCH. Being generous here - "close
             // enough, have the discount" - is inventing a membership, and the guest
@@ -2403,6 +2697,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         await deps.backend.rememberPreferences(m, []);
         const { preferences: _gone, ...member } = m;
         deps.members.set(key, member);
+        deps.members.setPreferences(m.number, []);
         return {
             structured: { view: 'member', ...common(deps, key), member },
             text: `Forgot the room preferences saved on ${m.programme} ${m.tier.name}. Bookings already made keep what they asked for.`,