@curless/hotel-storefront 0.50.5 → 0.51.1

package/dist/tools.js

@@ -100,20 +100,40 @@ export const buildTools = (n, v, caps = FULL_CAPABILITIES) => forCapabilities(al
  * another city (three smoke runs did). Where it is a few (`HOME_LIST_MAX`,
  * Huazhu's production, 2026-10-30), asked with no place it lists all of them.
  * Never in a market.
+ *
+ * ⚠️ `all` SAYS SO TOO (0.51.1): its "true lists the hotels themselves" is
+ * what had the model open Huazhu's production with `all: true` - the one way
+ * past the home, with no tonight and no prices. It is the home there now, and
+ * its description says it changes nothing.
  */
 export const homeListing = (t, brand, count) => {
     const v = brand.vocab;
     if (t.name !== brand.tools.listHotels || v.market || count < 1 || count > HOME_LIST_MAX)
         return t;
-    const one = count === 1
-        ? `This deployment has ONE ${v.noun} in all: asked with no place, it answers with that ${v.noun}'s own page - priced for tonight when no dates are given - and there is no other ${v.noun} or city to list or search. `
-        : `This deployment has ${count} ${v.nounPlural} in all: asked with no place, it lists every one of them - priced for tonight when no dates are given - and there is no other ${v.noun} or city to list or search. `;
+    const home = count === 1 ? `it answers with that ${v.noun}'s own page` : 'it lists every one of them';
+    const one = `This deployment has ${count === 1 ? 'ONE' : count} ${count === 1 ? v.noun : v.nounPlural} in all: asked with no place, or with \`all\`, ${home}; any list here without dates is priced for tonight; and there is no other ${v.noun} or city to list or search. `;
     const places = /Asked with no place[\s\S]*?themselves\. /;
+    const schema = t.inputSchema;
+    const all = schema?.properties?.all;
     return {
         ...t,
         description: places.test(t.description)
             ? t.description.replace(places, one)
             : `${one}${t.description}`,
+        ...(schema && all
+            ? {
+                inputSchema: {
+                    ...schema,
+                    properties: {
+                        ...schema.properties,
+                        all: {
+                            ...all,
+                            description: `Changes nothing here: with ${count === 1 ? `one ${v.noun}` : `${count} ${v.nounPlural}`} in all, asked with no place ${home} either way`,
+                        },
+                    },
+                },
+            }
+            : {}),
     };
 };
 export const withheldTools = (n, caps) => new Set([
@@ -200,6 +220,44 @@ const forCapabilities = (tools, n, v, caps) => {
                     }),
                 };
         }
+        // ⚠️ ONLY WHERE COUPONS ARE TAKEN (`capabilities.coupons`): a group that
+        // takes none is offered no parameter for one.
+        if (caps.coupons) {
+            const withCoupon = (schema, description) => {
+                const s = schema;
+                return {
+                    ...s,
+                    properties: { ...(s.properties ?? {}), coupon: { type: 'string', description } },
+                };
+            };
+            if (t.name === n.viewTrip)
+                out = {
+                    ...out,
+                    description: `${out.description} With \`coupon\`, priced with that coupon taken off, after the member rate - nothing is spent by looking.`,
+                    inputSchema: withCoupon(out.inputSchema, 'A coupon the signed-in member holds, by the id the sign-in answer gave it. Only one the guest named or agreed to - never one picked for them'),
+                };
+            if (t.name === n.requestBooking)
+                out = {
+                    ...out,
+                    inputSchema: withCoupon(out.inputSchema, 'A coupon the signed-in member holds, by its id: used on this booking, which spends it. Only when the guest named it or agreed to it - the one the price they agreed to was shown with. If it cannot be used, nothing is booked'),
+                };
+            // The card's stepper and Remove on a trip priced with a coupon keep it.
+            if (t.name === n.addToTrip)
+                out = {
+                    ...out,
+                    inputSchema: withCoupon(out.inputSchema, 'The coupon this trip is already priced with, by its id, to keep it on the new price - nothing is spent. Only one the guest named or agreed to'),
+                };
+            if (t.name === n.pickRoom || t.name === n.bookPicked)
+                out = {
+                    ...out,
+                    inputSchema: withCoupon(out.inputSchema, 'The coupon the guest chose on the card, by its id'),
+                };
+            if (t.name === n.signIn)
+                out = {
+                    ...out,
+                    description: out.description.replace('and answers with their tier, their point balance', 'and answers with their tier, their point balance, the coupons they hold'),
+                };
+        }
         // ⚠️ THE PICKED ROOM'S BOOKING TAKES THE SAME GUEST FIELDS as the trip's:
         // a phone where the hotel needs one, and no `rememberRequests` without
         // members. Its description is its own (below, only request_booking's).
@@ -995,6 +1053,10 @@ const TRIP_SCHEMA = {
         member: OBJ,
         /** What the tier took off THIS trip, and what it earns. */
         memberSaving: OBJ,
+        /** The coupon taken off, the one asked for and refused, and every one the member holds. */
+        coupon: OBJ,
+        couponRefused: OBJ,
+        coupons: ARR,
         days: ARR,
         dropped: ARR,
         /** A name that fits more than one hotel: the ones it fits (`namesLike`). */
@@ -1008,6 +1070,8 @@ const CANCEL_SCHEMA = {
     type: 'object',
     properties: {
         view: { enum: ['cancellation-preview', 'cancelled', 'booking-not-found'] },
+        /** The coupon the booking used and whether cancelling gives it back. */
+        coupon: OBJ,
         brand: STR,
         toolNames: OBJ,
         bookingMode: STR,
@@ -1140,6 +1204,8 @@ const HOTEL_PAGE = {
     needsDates: BOOL,
     /** How many rooms of one type the list was filtered to. */
     rooms_wanted: { type: 'number' },
+    /** Signed in: whose rate the prices are, said as the text says it (`said`). */
+    memberRates: OBJ,
     noRooms: STR,
     /** `noRooms` as a code (`NoRoomsCode`) and what it holds, for a card to say in the guest's language. */
     noRoomsCode: STR,
@@ -1183,6 +1249,11 @@ const BOOKING_SCHEMA = {
         // `trip`: nothing was booked and the trip is shown again - its price
         // moved, or (in a market) it holds two groups' stays.
         view: { enum: ['booking', 'needs-guest', 'empty-trip', 'error', 'trip'] },
+        /** `coupon`: nothing was booked because the coupon asked for cannot be used (`couponRefused`). */
+        notBooked: STR,
+        coupon: OBJ,
+        couponRefused: OBJ,
+        coupons: ARR,
         brand: STR,
         toolNames: OBJ,
         bookingMode: STR,
@@ -1519,10 +1590,25 @@ const memberBadge = (deps, key) => {
                 programme: m.programme,
                 tier: { name: m.tier.name, discount: m.tier.discount },
                 ...(m.preferences?.length ? { preferences: m.preferences } : {}),
+                // As they stand now - spent or handed back since signing in - so
+                // the member page the badge opens is never a booking behind.
+                points: m.points,
+                ...(m.pointsExpiring ? { pointsExpiring: m.pointsExpiring } : {}),
+                ...(m.coupons ? { coupons: m.coupons.map(couponForCard) } : {}),
             },
         }
         : { signedIn: false };
 };
+/** A member for the card: every amount as text, like every amount the card is given. */
+const memberForCard = (m, brand) => ({
+    ...m,
+    // Each with its terms in the sign-in text's own words (\`said\`): the model
+    // reads this, and a coupon for every hotel had no scope here at all - so
+    // "全部门店" went unsaid (0.51.0 eval).
+    ...(m.coupons
+        ? { coupons: m.coupons.map((c) => ({ ...couponForCard(c), said: couponTerms(c, brand) })) }
+        : {}),
+});
 /** A market's group by its id or its name, as a guest or a model would say it. */
 /** How many stays that failed are each given alternatives - each is a search. */
 const MAX_FAILED_WITH_ALTERNATIVES = 3;
@@ -1779,7 +1865,22 @@ const madeForCard = (deps, b) => {
     const { confirmationCode: _unconfirmed, ...rest } = card;
     return { ...rest, pending: true };
 };
-const bookedLine = (deps, b) => {
+const bookedLine = (deps, b) => [heldLine(deps, b), couponPointsLine(b)].filter(Boolean).join(' ');
+/**
+ * The coupon a booking used and the points it should earn - on the booking
+ * itself, so the confirmation says what the review said (§4, §5).
+ */
+const couponPointsLine = (b) => [
+    b.quote.coupon
+        ? `Coupon ${couponName(b.quote.coupon)} used: −${formatMoney(b.quote.coupon.off)}, and ${formatMoney(b.quote.total)} is the booking's total after it.`
+        : '',
+    b.quote.member
+        ? `About ${b.quote.member.points.toLocaleString('en-GB')} ${b.quote.member.programme} points after the stay - not added to the balance here.`
+        : '',
+]
+    .filter(Boolean)
+    .join(' ');
+const heldLine = (deps, b) => {
     const paid = paidLine(deps, b);
     if (paid)
         return paid;
@@ -1875,6 +1976,35 @@ const langOf = (deps, _key) => deps.lang;
  */
 const freeUntilText = (r) => r.freeCancellationLocal ??
     `${(r.freeCancellationUntil ?? '').slice(0, 16).replace('T', ' ')} UTC`;
+/**
+ * What a signed-in member's prices are, said once at the top of a hotel's
+ * rooms - with the cheapest one's public and member figures, so "member rate"
+ * is a number the guest can check (10-30: the rooms were at the member rate
+ * and nothing told the model so).
+ */
+const memberRatesOf = (rooms, roomsWanted) => {
+    const priced = rooms.filter((r) => r.memberRate && r.publicStayTotal);
+    const cheapest = priced.reduce((a, r) => (!a || r.stayTotal.minor < a.stayTotal.minor ? r : a), undefined);
+    const m = cheapest?.memberRate;
+    if (!cheapest?.publicStayTotal || !m)
+        return undefined;
+    const n = Math.max(1, roomsWanted);
+    return {
+        programme: m.programme,
+        tier: m.tier,
+        discount: m.discount,
+        said: `Prices here are the ${m.programme} ${m.tier} member rate, ${Math.round(m.discount * 100)}% below the public rate - the cheapest, ${cheapest.name}, is ${formatMoney(multiplyMoney(cheapest.publicStayTotal, n))} at the public rate and ${formatMoney(multiplyMoney(cheapest.stayTotal, n))} at the member rate for the stay${n > 1 ? ` (${n} rooms)` : ''}.`,
+    };
+};
+/** A held coupon for the card: its amounts as text, like every amount the card is given. */
+const couponForCard = (c) => ({
+    ...c,
+    ...(c.amountOff ? { amountOff: formatMoney(c.amountOff) } : {}),
+    ...(c.maxOff ? { maxOff: formatMoney(c.maxOff) } : {}),
+    ...(c.minSpend ? { minSpend: formatMoney(c.minSpend) } : {}),
+    ...(c.off ? { off: formatMoney(c.off) } : {}),
+    ...(c.spend ? { spend: formatMoney(c.spend) } : {}),
+});
 /** One line of a trip, flattened for the card. Prices are strings: the card never does arithmetic. */
 const quoteForCard = (quote, groupOf) => ({
     lines: quote.lines.map((l) => ({
@@ -1925,11 +2055,114 @@ const quoteForCard = (quote, groupOf) => ({
     // the quote's block is a different shape (a tier NAME, a saving, points).
     // Two shapes on one key is how a card reads `member.tier.name` off a string.
     ...(quote.member
-        ? { memberSaving: { ...quote.member, saved: formatMoney(quote.member.saved) } }
+        ? {
+            memberSaving: {
+                ...quote.member,
+                saved: formatMoney(quote.member.saved),
+                // The review's own order - public, member, coupon, total - each
+                // figure the server's, so the card adds nothing up (10-30, ①).
+                publicTotal: formatMoney(quote.member.publicTotal),
+                memberTotal: formatMoney(money(quote.member.publicTotal.minor - quote.member.saved.minor, quote.total.currency)),
+            },
+        }
+        : {}),
+    ...(quote.coupon ? { coupon: { ...quote.coupon, off: formatMoney(quote.coupon.off) } } : {}),
+    ...(quote.couponRefused
+        ? {
+            couponRefused: {
+                ...quote.couponRefused,
+                ...(quote.couponRefused.minSpend
+                    ? { minSpend: formatMoney(quote.couponRefused.minSpend) }
+                    : {}),
+                ...(quote.couponRefused.spend ? { spend: formatMoney(quote.couponRefused.spend) } : {}),
+            },
+        }
         : {}),
+    ...(quote.coupons ? { coupons: quote.coupons.map(couponForCard) } : {}),
     ...(quote.stay ? { stay: quote.stay } : {}),
     ...(quote.dropped ? { dropped: quote.dropped } : {}),
 });
+/**
+ * A coupon's name as a guest of either language reads it: the programme's
+ * Chinese beside its English - "满500减50 (¥50 off a stay of ¥500)".
+ */
+const couponName = (c) => c.names?.zh && c.names.zh !== c.name ? `${c.names.zh} (${c.name})` : c.name;
+/** "A, B or C". */
+const listOrWords = (xs) => xs.length > 1 ? `${xs.slice(0, -1).join(', ')} or ${xs.at(-1)}` : (xs[0] ?? '');
+/** What a held coupon is - what it takes off, where, until when - and where it stands. */
+const couponTerms = (c, brand) => [
+    c.kind === 'amount-off'
+        ? `${c.amountOff ? formatMoney(c.amountOff) : ''} off${c.minSpend ? ` a stay of ${formatMoney(c.minSpend)} or more` : ', no minimum'}`
+        : `${Math.round((c.percentOff ?? 0) * 100)}% off${c.maxOff ? `, at most ${formatMoney(c.maxOff)}` : ''}${c.minSpend ? `, on a stay of ${formatMoney(c.minSpend)} or more` : ''}`,
+    c.hotels?.length
+        ? `only at ${listOrWords(c.hotels.map((h) => h.name))}`
+        : c.brands?.length
+            ? `only at ${listOrWords(c.brands.map((b) => b.name))} hotels`
+            : `at every ${brand} hotel`,
+    c.state === 'expired'
+        ? `ran out on ${c.validUntil} - cannot be used`
+        : c.state === 'used'
+            ? 'already used on a booking'
+            : c.state === 'not-yet'
+                ? `usable from ${c.validFrom} to ${c.validUntil}`
+                : `until ${c.validUntil}`,
+].join(' · ');
+/** What cancelling does to the coupon a booking used. */
+const couponBackWords = (c) => c.returned
+    ? `The coupon ${couponName(c)} it used comes back to the member on cancelling (usable until ${c.validUntil}).`
+    : `The coupon ${couponName(c)} it used ran out on ${c.validUntil}, so cancelling does not give it back.`;
+/**
+ * Said wherever points are: they are shown and earned, never spent here -
+ * nobody has published what a point is worth (hotel-connectors.md §5).
+ */
+const POINTS_DO_NOT_PAY = 'Points cannot pay for a room here, not even in part: what a point is worth has not been published, so give no rate for them.';
+/** The rule a coupon is used by, said once where coupons are listed. */
+const COUPON_RULE = 'One coupon per booking, taken off after the member rate. Use one only when the guest names it or agrees to it - using it spends it - by passing its id as `coupon` to the trip view (to price it) and to the booking.';
+/** A signed-in member's coupons and points, for the sign-in answer - see `memberCouponsSaid`. */
+const memberSaid = (m, brand) => [
+    `Points: ${m.points.toLocaleString('en-GB')}.${m.pointsExpiring ? ` ${m.pointsExpiring.points.toLocaleString('en-GB')} of them lapse on ${m.pointsExpiring.on}.` : ''} ${POINTS_DO_NOT_PAY}`,
+    ...(m.coupons
+        ? m.coupons.length
+            ? [
+                `Coupons held (${m.coupons.length}): ${COUPON_RULE}`,
+                // The terms say it in English; the name is the programme's own.
+                ...m.coupons.map((c) => `- ${c.names?.zh ?? c.name} · ${couponTerms(c, brand)} · id \`${c.id}\``),
+            ]
+            : ['No coupons are held on this membership.']
+        : []),
+];
+/**
+ * What membership did to this trip, in the review's own order: the public
+ * rate, the member rate, the coupon, what is paid - the same three figures the
+ * card shows (`memberSaving`), so text and structure agree.
+ */
+const memberTripLines = (q) => {
+    const m = q.member;
+    if (!m)
+        return [];
+    const cur = q.total.currency;
+    const memberTotal = money(m.publicTotal.minor - m.saved.minor, cur);
+    const atHotel = !q.lines.some((l) => l.payment === 'prepaid');
+    const stays = new Set(q.lines.flatMap((l) => (l.kind === 'room' ? [`${l.hotelId}|${l.stay?.checkIn}`] : []))).size;
+    return [
+        `${m.programme} ${m.tier} member rate: public rate ${formatMoney(m.publicTotal)} → member rate ${formatMoney(memberTotal)} (${formatMoney(m.saved)} less)${q.coupon
+            ? ` → coupon ${couponName(q.coupon)} −${formatMoney(q.coupon.off)}${stays > 1 ? ` (on the stay at ${q.coupon.hotelName})` : ''}`
+            : ''} → **${atHotel ? 'to pay at the hotel' : 'to pay'} ${formatMoney(q.total)}**. Earns about ${m.points.toLocaleString('en-GB')} points${q.coupon ? ', on the price after the coupon' : ''}.`,
+        q.couponRefused
+            ? `The coupon ${q.couponRefused.name ? couponName({ name: q.couponRefused.name, names: q.couponRefused.names }) : q.couponRefused.id} was NOT taken off: ${q.couponRefused.why} The total is without it.`
+            : '',
+        ...(q.coupons?.length
+            ? [
+                `The member's coupons for this trip - ${COUPON_RULE}`,
+                ...q.coupons.map((c) => `- ${couponName(c)} (\`${c.id}\`): ${q.coupon?.id === c.id
+                    ? 'taken off above'
+                    : c.off
+                        ? `would take ${formatMoney(c.off)} off${stays > 1 && c.hotelName ? ` (the stay at ${c.hotelName})` : ''}`
+                        : `cannot be used here: ${c.why ?? 'it does not apply.'}`}`),
+            ]
+            : []),
+    ].filter(Boolean);
+};
 const tripText = (quote, demo) => {
     if (quote.lines.length === 0)
         return 'The trip is empty.';
@@ -1938,7 +2171,8 @@ const tripText = (quote, demo) => {
         : `- ${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 ${quote.taxesIncluded ? 'included in the prices' : formatMoney(quote.taxesAndFees)} · **Total ${formatMoney(quote.total)}**`,
+        `Taxes and fees ${quote.taxesIncluded ? 'included in the prices' : formatMoney(quote.taxesAndFees)}${quote.coupon ? ` · coupon −${formatMoney(quote.coupon.off)}` : ''} · **Total ${formatMoney(quote.total)}**`,
+        ...memberTripLines(quote),
         ...(quote.dropped ?? []).map((d) => `Left out: ${d.title} — ${d.why}`),
         demo ? DEMO_NOTE : '',
     ]
@@ -2057,26 +2291,15 @@ const bare = (kind) => REQUEST_WORDS[kind].replace(/^an? /, '');
  * desk cannot act on.
  */
 const SORTS = ['group', 'price-low', 'price-high', 'rating'];
-/**
- * The ONE wider search to try when the narrow one found nothing, and how to
- * describe it.
- *
- * ⚠️ IT WIDENS ONCE AND STOPS. A search that keeps loosening until something
- * comes back always finds something, and what it finds is unrelated to what was
- * asked - which is worse than "no", because "no" is at least true. One step,
- * and the answer names it.
- *
- * ⚠️ AND IT DROPS THE WORDS BEFORE THE PLACE. "Nothing in Tokyo matches
- * «rooftop pool»" still leaves a guest looking at Tokyo, which is where they
- * said they were going; keeping the words and losing Tokyo answers a question
- * nobody asked.
- */
 const widen = (ask) => {
     if (ask.city && ask.query) {
         return {
             ask: { ...ask, query: undefined },
             from: `${ask.city} and "${ask.query}"`,
             to: ask.city,
+            how: 'words',
+            city: ask.city,
+            query: ask.query,
         };
     }
     // A place nobody has filed under that name may still be in a hotel's own
@@ -2086,6 +2309,8 @@ const widen = (ask) => {
             ask: { ...ask, city: undefined, query: ask.city },
             from: `the city "${ask.city}"`,
             to: `"${ask.city}" anywhere in the record`,
+            how: 'place',
+            city: ask.city,
         };
     }
     // Several words that match nothing together may match on the longest one.
@@ -2096,6 +2321,9 @@ const widen = (ask) => {
             ask: { ...ask, query: longest },
             from: `all of "${ask.query}"`,
             to: `"${longest}"`,
+            how: 'word',
+            query: ask.query ?? '',
+            word: longest,
         };
     }
     return undefined;
@@ -2344,6 +2572,13 @@ const bookingLine = (b) => {
             ? 'unconfirmed: whether it was made is not known yet, and a person is confirming it'
             : b.status}`,
         kinds.length ? ` · asked for ${kinds.map(bare).join(', ')}` : '',
+        b.quote.coupon
+            ? ` · coupon ${couponName(b.quote.coupon)} −${formatMoney(b.quote.coupon.off)}${b.couponReturned === true
+                ? ' (given back)'
+                : b.couponReturned === false
+                    ? ' (ran out - not given back)'
+                    : ''}`
+            : '',
         b.payment
             ? ` · ${paymentWords(b)}${b.payment.status === 'awaiting' && b.payment.url ? ` by ${b.payment.payByLocal ?? b.payment.payBy}: ${b.payment.url}` : ''}`
             : '',
@@ -2639,15 +2874,38 @@ const guarded = async (deps, ctx, who, code, run) => {
  * read as the hotel's. Now it is two quotes, drawn side by side and never
  * added up; each hotel is booked, and paid, in its own.
  */
-const quoteParts = async (deps, lines, who) => {
+const quoteParts = async (deps, lines, who, coupon) => {
     const byCurrency = new Map();
     for (const l of lines) {
         const c = (await deps.backend.getHotel(l.hotelId))?.hotel.currency ?? '';
         byCurrency.set(c, [...(byCurrency.get(c) ?? []), l]);
     }
+    const asked = coupon ? { coupon } : {};
     if (byCurrency.size === 0)
-        return [await deps.backend.quote({ lines: [] }, who)];
-    return Promise.all([...byCurrency.values()].map((g) => deps.backend.quote({ lines: g }, who)));
+        return [await deps.backend.quote({ lines: [], ...asked }, who)];
+    const parts = await Promise.all([...byCurrency.values()].map((g) => deps.backend.quote({ lines: g, ...asked }, who)));
+    // A coupon goes on one part of a trip in two currencies: the others need
+    // not say it is in the wrong one.
+    return parts.some((p) => p.coupon) ? parts.map(({ couponRefused: _no, ...p }) => p) : parts;
+};
+/** The coupon a call names - only where the backend takes coupons (`capabilities.coupons`). */
+const couponOf = (deps, args) => (deps.backend.capabilities ?? FULL_CAPABILITIES).coupons
+    ? str(args.coupon) || undefined
+    : undefined;
+/**
+ * The signed-in member as the backend has them now - their coupons spent or
+ * handed back since they signed in. Every answer's badge reads the store, so
+ * the card's member page is never a booking behind.
+ */
+const refreshMember = async (deps, key) => {
+    if (!(deps.backend.capabilities ?? FULL_CAPABILITIES).coupons)
+        return;
+    const m = deps.members.read(key);
+    if (!m)
+        return;
+    const now = await deps.backend.signInMember(m.number, m.surname);
+    if (now)
+        deps.members.set(key, { ...now, ...(m.preferences ? { preferences: m.preferences } : {}) });
 };
 /** The trip, priced, as both views need it. */
 /**
@@ -2688,9 +2946,11 @@ const needsRoomIn = (t, lines, parts) => {
  * `store`) the picked room's slot. `key` stays the conversation's trip key: it
  * is the one `common` reads, so a header's trip count never counts a pick.
  */
-const currentTrip = async (deps, key, who, store = key) => {
+const currentTrip = async (deps, key, who, store = key, coupon) => {
+    await refreshMember(deps, key);
+    const member = deps.members.read(key);
     const lines = deps.trips.read(store);
-    const parts = await quoteParts(deps, lines, who);
+    const parts = await quoteParts(deps, lines, who && member ? { ...who, member } : who, coupon);
     // ⚠️ WHAT THE GUEST IS SHOWN IS WHAT IS BOOKED - see `ShownQuote`. Every
     // priced trip answer goes through here: add_to_trip, view_trip, and the
     // card's own trip view.
@@ -3449,7 +3709,7 @@ const putRoomLine = async (deps, t, ctx, key, store, args, detail) => {
                 : !!asked && l.stay.checkIn === asked.checkIn && l.stay.checkOut === asked.checkOut));
         if (held) {
             deps.trips.set(store, unset(held));
-            return currentTrip(deps, key, who, store);
+            return currentTrip(deps, key, who, store, couponOf(deps, args));
         }
     }
     const today = (startTime || !asStay(args)
@@ -3509,7 +3769,7 @@ const putRoomLine = async (deps, t, ctx, key, store, args, detail) => {
                 hours: hourlyRoom.hourly.hours,
             },
         });
-        return currentTrip(deps, key, who, store);
+        return currentTrip(deps, key, who, store, couponOf(deps, args));
     }
     const stay = asStay(args);
     // ⚠️ NO DATES, NO LINE. Guessing "tonight" or "this weekend" here is how a
@@ -3655,7 +3915,7 @@ const putRoomLine = async (deps, t, ctx, key, store, args, detail) => {
         stay,
         rooms: clampCount(args.rooms ?? 1, MAX_ROOMS_PER_LINE),
     });
-    const now = await currentTrip(deps, key, identity(deps, ctx, key), store);
+    const now = await currentTrip(deps, key, identity(deps, ctx, key), store, couponOf(deps, args));
     // Which rate was taken, in the structure too and in the same words - see
     // the itinerary's `nudges` (2026-10-27 audit, F11).
     return took
@@ -3742,7 +4002,14 @@ const bookTripLines = async (deps, t, ctx, key, store, args, nothingThere) => {
     const { requests, dropped } = readRequests(args);
     try {
         const shown = deps.trips.shown(store);
-        const { booked: made, failed, repeat, reused, } = await deps.backend.requestBooking({ lines, ...(shown ? { shown } : {}) }, {
+        const { booked: made, failed, repeat, reused, } = await deps.backend.requestBooking(
+        // The coupon the guest named, spent on the one stay it goes on - or
+        // nothing is booked (see `TripDraft.coupon`).
+        {
+            lines,
+            ...(shown ? { shown } : {}),
+            ...(couponOf(deps, args) ? { coupon: couponOf(deps, args) } : {}),
+        }, {
             ...guest,
             ...(str(args.phone) ? { phone: str(args.phone) } : {}),
             ...(requests?.note ? { notes: requests.note } : {}),
@@ -3756,6 +4023,8 @@ const bookTripLines = async (deps, t, ctx, key, store, args, nothingThere) => {
         // only place an Identity is built; the guest's email still overrides,
         // because a booking is found by the address it was made with.
         { ...identity(deps, ctx, key), email: guest.email }, requests);
+        // A coupon spent is spent on the member's badge too.
+        await refreshMember(deps, key);
         // ⚠️ WHAT WAS BOOKED LEAVES THE TRIP; WHAT WAS NOT STAYS IN IT, add-ons
         // and all - to ask again, or to put another hotel in its place (robin,
         // 2026-10-14).
@@ -3962,6 +4231,16 @@ const bookTripLines = async (deps, t, ctx, key, store, args, nothingThere) => {
             const again = await currentTrip(deps, key, identity(deps, ctx, key), store);
             return { ...again, text: [words, again.text].join('\n\n') };
         }
+        // The coupon asked for cannot be used: nothing was booked, and the trip
+        // is shown again with it refused and why - the guest decides what next.
+        if (err.code === 'coupon') {
+            const again = await currentTrip(deps, key, identity(deps, ctx, key), store, couponOf(deps, args));
+            return {
+                ...again,
+                structured: { ...again.structured, notBooked: 'coupon' },
+                text: [words, again.text].join('\n\n'),
+            };
+        }
         if (err.code === 'mixed-supplier') {
             const again = await currentTrip(deps, key, identity(deps, ctx, key), store);
             return {
@@ -4070,7 +4349,8 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 // 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 };
+                const { ask: _wider, ...said } = wider;
+                widened = { ...said, found: placedCount(second) > 0 };
                 if (widened.found) {
                     answer = second;
                     asked = { ...ask, ...wider.ask };
@@ -4149,12 +4429,24 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 ...(ask.rooms && ask.rooms > 1 ? { rooms: ask.rooms } : {}),
             }
             : {};
+        // How many the whole deployment has: the server says, and an unnarrowed
+        // answer is it. A deployment of up to HOME_LIST_MAX fits on one page -
+        // never a market, whose home is its groups.
+        const unnarrowed = !ask.query && !ask.city && !ask.filters && !ask.maxNightly;
+        const deployed = deps.hotelCount?.() ?? (unnarrowed ? answer.total : 0);
+        const fitsOnePage = !deps.backend.suppliers && !deps.vocab.market && deployed >= 1 && deployed <= HOME_LIST_MAX;
         // ⚠️ 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;
+        //
+        // ⚠️ WHERE IT ALL FITS ON ONE PAGE, `all` IS THE HOME (robin, 2026-10-30:
+        // 「华住默认还是没有日期呀」). Huazhu's production has two; asked to open
+        // Huazhu, the model sent `all: true` - "lists the hotels themselves" - and
+        // that skipped the home: no tonight, no prices, "All hotels · add dates".
+        // Here every hotel is on the home already, so `all` asks for nothing more.
+        const listAll = args.all === true && !fitsOnePage;
         const echo = (applied) => ({
             ...(asked.query ? { query: asked.query } : {}),
             ...(asked.city ? { city: asked.city } : {}),
@@ -4199,17 +4491,17 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         // theirs read as that night's prices; here the dates and the prices are
         // the same night, so that cannot happen. Tonight is the hotels' own date
         // (the earliest of them, `todayThere`), for the default party; asked again
-        // with those nights, the answer is the home as before - priced. Only the
-        // home of a deployment that fits on one page (the list of all, or the one
-        // hotel's page): a group of many still chooses a city first, a market its
-        // group, and dates or a place the model gave are used as given.
-        const homeOfFew = !!choosing &&
-            !asked.city &&
-            !deps.backend.suppliers &&
-            total >= 1 &&
-            total <= HOME_LIST_MAX &&
-            hotels.length === total;
-        if (homeOfFew && !ask.stay && today?.min) {
+        // with those nights, the answer is the home as before - priced.
+        //
+        // ⚠️ AND EVERY LIST THERE WITHOUT DATES, NOT THE HOME ALONE (0.51.1). In a
+        // deployment that fits on one page a list - a city, words, a filter, `all`
+        // - is the home or a part of it: without dates it was the same hotels with
+        // tonight's prices taken away, "add dates to see what a stay costs" one
+        // turn after the home showed them. It costs what the home costs, a quote
+        // per hotel (six at most). A group of many still chooses a city first and
+        // lists twenty at a time without prices, a market its group; rooms by the
+        // hour are today's by their own rule; dates the model gave are used as given.
+        if (fitsOnePage && !ask.stay && !ask.filters?.hourly && hotels.length && today?.min) {
             const tonight = {
                 checkIn: today.min,
                 checkOut: addDays(today.min, 1),
@@ -4657,6 +4949,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 : {}),
             ...(r.freeCancellationUntil ? { freeCancellationLocal: freeUntilText(r) } : {}),
         }));
+        const memberRates = memberRatesOf(enough, roomsWanted);
         return {
             structured: {
                 view: 'hotel',
@@ -4669,9 +4962,11 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 // Types with no room to book for these nights, said and not left out.
                 ...(byTheHour || !soldOut.length ? {} : { soldOut }),
                 ...(notSold ? { notSoldHere: notSold } : {}),
+                ...(memberRates ? { memberRates } : {}),
                 ...flex.structured,
             },
             text: [
+                memberRates?.said ?? '',
                 ...roomsText(h.name, byTheHour
                     ? (rs) => `${rs.length} ${rs.length === 1 ? 'room' : 'rooms'} by the hour for today, ${stay.checkIn}, ${stay.guests} guests`
                     : (rs) => `${offerCount(rs)} for ${stay.checkIn} to ${stay.checkOut}, ${stay.guests} guests${roomsWanted > 1 ? `, ${roomsWanted} rooms` : ''}`, byTheHour ? `today, ${stay.checkIn}` : `${stay.checkIn} to ${stay.checkOut}`, enough, roomsWanted, terms),
@@ -4955,7 +5250,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         return direct(await putRoomLine(deps, t, ctx, key, slot, args, found.detail));
     }
     if (name === t.viewTrip)
-        return currentTrip(deps, key, identity(deps, ctx, key));
+        return currentTrip(deps, key, identity(deps, ctx, key), key, couponOf(deps, args));
     if (name === t.clearTrip) {
         deps.trips.clear(key);
         return {
@@ -5367,10 +5662,15 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                     }
                     : {}),
                 toolToConfirm: t.cancelBooking,
+                // Whether cancelling hands the coupon back - the same sentence as the text.
+                ...(preview.coupon
+                    ? { coupon: { ...preview.coupon, said: couponBackWords(preview.coupon) } }
+                    : {}),
             },
             text: [
                 `Cancelling ${preview.confirmationCode} would cost ${formatMoney(preview.fee)}${preview.fee.minor === 0 ? ' - nothing' : ''}.`,
                 preview.rule,
+                preview.coupon ? couponBackWords(preview.coupon) : '',
                 preview.cancellable
                     ? `Say the word and it is cancelled (${t.cancelBooking} with \`confirmed\`).`
                     : '',
@@ -5405,6 +5705,8 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         const cancelled = await deps.backend.cancelBooking(ref, who, str(args.reason) || undefined);
         if (!cancelled)
             return asPreview;
+        // A coupon handed back is back on the member's badge.
+        await refreshMember(deps, key);
         // ⚠️ WHAT THE HOTEL SAYS IT CHARGED, once it has said. A group's own system
         // answers a cancellation with its penalty; the preview was our reading of
         // the rate's terms, and where the two differ the hotel's is the one that
@@ -5435,6 +5737,11 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                                 ? // Nobody charges a demonstration anything (2026-10-05 audit, P2).
                                     `${cancelled.confirmationCode} is cancelled. ${charged.minor === 0 ? 'No fee.' : `A real booking on this rate would be charged ${formatMoney(charged)}; this is a demonstration, and nothing is charged.`}`
                                 : `${cancelled.confirmationCode} is cancelled. ${charged.minor === 0 ? 'No fee.' : `The hotel charges ${formatMoney(charged)}.`}`,
+                cancelled.quote.coupon && cancelled.couponReturned !== undefined
+                    ? cancelled.couponReturned
+                        ? `The coupon ${couponName(cancelled.quote.coupon)} is back with the member, usable until ${cancelled.quote.coupon.validUntil}.`
+                        : `The coupon ${couponName(cancelled.quote.coupon)} ran out on ${cancelled.quote.coupon.validUntil}, so it is not given back.`
+                    : '',
                 demoBookingNote(deps, cancelled.supplier),
                 deps.vocab.demo ? noteFor(deps.vocab) : '',
             ]
@@ -5652,17 +5959,24 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         }
         deps.members.set(key, member);
         return {
-            structured: { view: 'member', ...common(deps, key), member },
+            structured: {
+                view: 'member',
+                ...common(deps, key),
+                member: memberForCard(member, deps.vocab.brand),
+            },
             text: [
-                `Signed in as ${member.name} · ${member.programme} ${member.tier.name} · ${member.points.toLocaleString('en-GB')} points.`,
+                `Signed in as ${member.name}${member.names?.zh ? ` (${member.names.zh})` : ''} · ${member.programme} ${member.tier.name} · ${member.points.toLocaleString('en-GB')} points.`,
                 `Rates now show the ${member.tier.name} member rate, ${Math.round(member.tier.discount * 100)}% off the public one.`,
+                ...((deps.backend.capabilities ?? FULL_CAPABILITIES).coupons
+                    ? memberSaid(member, deps.vocab.brand)
+                    : [POINTS_DO_NOT_PAY]),
                 member.preferences?.length
                     ? `Saved preferences on this membership: ${member.preferences.map((k) => REQUEST_WORDS[k]).join(', ')}. They are ticked on the booking form; mention them, and ask before booking with them.`
                     : '',
                 deps.vocab.demo ? noteFor(deps.vocab) : '',
             ]
                 .filter(Boolean)
-                .join(' '),
+                .join('\n'),
         };
     }
     if (name === t.signOut) {
@@ -5688,7 +6002,11 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         deps.members.set(key, member);
         deps.members.setPreferences(m.number, []);
         return {
-            structured: { view: 'member', ...common(deps, key), member },
+            structured: {
+                view: 'member',
+                ...common(deps, key),
+                member: memberForCard(member, deps.vocab.brand),
+            },
             text: `Forgot the room preferences saved on ${m.programme} ${m.tier.name}. Bookings already made keep what they asked for.`,
         };
     }