@curless/hotel-storefront 0.52.1 → 0.53.0

package/dist/tools.js

@@ -1,4 +1,4 @@
-import { DEFAULT_PAGE, FULL_CAPABILITIES, LASTING_REQUESTS, MAX_PAGE, REQUEST_KINDS, REQUEST_NOTE_MAX, guestTooLong, unitWords, } from './backend.js';
+import { DEFAULT_PAGE, FULL_CAPABILITIES, LASTING_REQUESTS, MAX_PAGE, REQUEST_KINDS, REQUEST_NOTE_MAX, guestTooLong, notPricedForNoAnswer, unansweredBy, unitWords, } from './backend.js';
 import { MAX_GUESTS, addDays, isDay, nights as nightsBetween } from './dates.js';
 import { FACILITIES } from './facilities.js';
 import { DESCRIPTION_MAX, POLICY_MAX, hotelName, hotelText } from './fence.js';
@@ -1288,6 +1288,8 @@ const BOOKING_SCHEMA = {
         again: OBJ,
         /** Of `bookings`, the ids asked for minutes before, when the others are new (`BookingResult.reused`). */
         repeated: STRS,
+        /** The coupon asked for was not used: the booking returned was made before, without it (`couponNotUsedOf`). */
+        couponNotUsed: OBJ,
         /** `trip`, drawn again: see `stampOf`. */
         stamp: STR,
         /** The trip changed after the card that sent the form was drawn, so nothing was booked (`stampOf`). */
@@ -1730,6 +1732,11 @@ const holderOf = (deps, supplier) => {
  */
 const bookingForCard = (b) => ({
     ...b,
+    // A booking cancelled before the reason was kept: a coupon not returned could
+    // then only have run out (C10) - said so, as the text says it.
+    ...(b.couponReturned === false && !b.couponNotReturnedBecause
+        ? { couponNotReturnedBecause: 'expired' }
+        : {}),
     quote: quoteForCard(b.quote),
     // What a cancelled booking was charged to cancel, as text like every amount the
     // card is given: "Cancelled" in My bookings says it beside the struck-out total
@@ -1908,10 +1915,33 @@ const heldLine = (deps, b) => {
         : `${b.holdUntil?.slice(0, 16).replace('T', ' ')} UTC`;
     // ⚠️ NOT "PRESENTS A CARD AT CHECK-IN" (2026-10-05 audit, P2): a demo
     // booking has no check-in, and saying so sent a guest towards a real desk.
+    //
+    // ⚠️ AND NOT A CLOCK TIME (2026-11-03 review, T2). "lapses on its own at Tue 3
+    // Nov, 11:39" was told as 「今天 11:41 自动失效」 - the booking void today, when
+    // the stay is weeks away. A demonstration hold lapses by itself and means
+    // nothing for a real stay; said as how long it lasts, and that it is only the
+    // demonstration.
     if (h.demo)
-        return `${total} all in. **${demoBookingWords(h)}** Nothing has been charged and no card is needed. The demonstration hold lapses on its own at ${lapses}.`;
+        return `${total} all in. **${demoBookingWords(h)}** Nothing has been charged and no card is needed. ${demoHoldWords(b, deps.trips.now())}`;
     return `${total} all in. **Nothing has been charged** - the rooms are held until ${lapses}, and the guest presents a card at check-in.`;
 };
+/**
+ * How long a demonstration hold lasts, as "in N minutes" from now - the hold
+ * lapses by itself, and says nothing about the stay (T2, `heldLine`).
+ */
+const demoHoldWords = (b, now) => {
+    const minutes = b.holdUntil ? Math.ceil((Date.parse(b.holdUntil) - now) / 60_000) : Number.NaN;
+    if (Number.isNaN(minutes))
+        return '';
+    const lasting = minutes <= 1
+        ? 'in a minute'
+        : minutes < 90
+            ? `in ${minutes} minutes`
+            : minutes < 48 * 60
+                ? `in about ${Math.round(minutes / 60)} hours`
+                : `in about ${Math.round(minutes / (24 * 60))} days`;
+    return `This is a demonstration: it lapses by itself ${lasting} (demo only - no real room is held; the stay's own dates are not affected).`;
+};
 /** What a demonstration booking is, in one sentence - see `demoBookingNote`. */
 const demoBookingWords = (h) => `This is a demonstration booking: ${h.name} has not received it and is not holding any room.`;
 /**
@@ -2133,10 +2163,29 @@ const couponTerms = (c, brand) => [
                 ? `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.`;
+/**
+ * What cancelling does to the coupon a booking used - and why.
+ *
+ * ⚠️ BACK ONLY FOR A FREE CANCELLATION IN THE COUPON'S DATES (robin,
+ * 2026-11-03, C10). A cancellation that charges a fee counts the coupon as
+ * used: it already took money off a stay that is being paid for. The reason is
+ * said in the words (`fee` / `expired`) and as the same code in the structure
+ * (`notReturnedBecause`), so a host that draws no card has it too. `fee` is the
+ * charge as text, for the sentence.
+ */
+const couponBackWords = (c, fee, 
+/** Said after the cancellation, not before it. */
+done = false) => c.returned
+    ? done
+        ? `The coupon ${couponName(c)} is back with the member, usable until ${c.validUntil}: the cancellation was free.`
+        : `The coupon ${couponName(c)} it used comes back to the member on cancelling, because the cancellation is free and the coupon is usable until ${c.validUntil}.`
+    : c.notReturnedBecause === 'fee'
+        ? done
+            ? `The coupon ${couponName(c)} is NOT given back: this cancellation was charged a fee${fee ? ` (${fee})` : ''}, and a cancellation that is charged counts the coupon as used.`
+            : `The coupon ${couponName(c)} it used does NOT come back: cancelling costs a fee${fee ? ` (${fee})` : ''}, and a cancellation that is charged counts the coupon as used.`
+        : done
+            ? `The coupon ${couponName(c)} ran out on ${c.validUntil}, so it is not given back.`
+            : `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).
@@ -2174,9 +2223,6 @@ const memberTripLines = (q) => {
         `${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}`,
@@ -2189,7 +2235,26 @@ const memberTripLines = (q) => {
             : []),
     ].filter(Boolean);
 };
+/**
+ * The coupon asked for that was not taken off, and why.
+ *
+ * ⚠️ SAID WHENEVER THERE IS ONE, SIGNED IN OR NOT (2026-11-03 review, C2). The
+ * sentence lived in `memberTripLines`, which says nothing without a member - so
+ * a coupon refused because nobody is signed in (`signed-out`) was in
+ * `structuredContent.couponRefused` and not in the words, and a host that
+ * hands its model the text read "Total ¥1,200" and could say it was the price
+ * with the coupon.
+ */
+const couponRefusedLine = (q) => 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.`
+    : '';
 const tripText = (quote, demo, noCards) => {
+    // ⚠️ NOT "EMPTY" WHEN SOMETHING WAS LEFT OUT: a trip whose only group did not
+    // answer is not an empty trip (2026-11-03 review, C5).
+    if (quote.lines.length === 0 && quote.dropped?.length)
+        return [...quote.dropped.map((d) => `Left out: ${d.title} — ${d.why}`), demo ? DEMO_NOTE : '']
+            .filter(Boolean)
+            .join('\n');
     if (quote.lines.length === 0)
         return 'The trip is empty.';
     const lines = quote.lines.map((l) => l.kind === 'room'
@@ -2198,6 +2263,7 @@ const tripText = (quote, demo, noCards) => {
     return [
         ...lines,
         `Taxes and fees ${quote.taxesIncluded ? 'included in the prices' : formatMoney(quote.taxesAndFees)}${quote.coupon ? ` · coupon −${formatMoney(quote.coupon.off)}` : ''} · **Total ${formatMoney(quote.total)}**`,
+        couponRefusedLine(quote),
         ...memberTripLines(quote),
         ...(quote.dropped ?? []).map((d) => `Left out: ${d.title} — ${d.why}`),
         demo ? DEMO_NOTE : '',
@@ -2645,7 +2711,9 @@ const bookingLine = (b, noCards) => {
             ? ` · coupon ${couponName(b.quote.coupon)} −${formatMoney(b.quote.coupon.off)}${b.couponReturned === true
                 ? ' (given back)'
                 : b.couponReturned === false
-                    ? ' (ran out - not given back)'
+                    ? b.couponNotReturnedBecause === 'fee'
+                        ? ' (not given back - the cancellation was charged a fee)'
+                        : ' (ran out - not given back)'
                     : ''}`
             : '',
         b.payment
@@ -2851,12 +2919,14 @@ const listAnd = (xs) => xs.length > 1 ? `${xs.slice(0, -1).join(', ')} and ${xs.
  * hotel. The sentence says the first and denies the second, in the text and in
  * `structuredContent` alike - a host with no card has only the words.
  */
-const degradedOf = (deps, answer) => {
+const degradedOf = (deps, answer, 
+/** What is missing from the list: the hotels of a search, the bookings of "my bookings". */
+noun = deps.vocab.nounPlural) => {
     const down = answer.degraded ?? [];
     if (down.length === 0)
         return { structured: {}, said: '' };
     const one = down.length === 1;
-    const said = `${listAnd(down.map((d) => d.name))} did not answer in time, so none of ${one ? 'its' : 'their'} ${deps.vocab.nounPlural} is in this list - this does not mean ${one ? 'it has' : 'they have'} none here; asking again in a moment may bring them.`;
+    const said = `${listAnd(down.map((d) => d.name))} did not answer in time, so none of ${one ? 'its' : 'their'} ${noun} is in this list - this does not mean ${one ? 'it has' : 'they have'} none here; asking again in a moment may bring them.`;
     return {
         structured: {
             degraded: down.map((d) => ({ supplier: d.supplier, name: d.name })),
@@ -2865,6 +2935,37 @@ const degradedOf = (deps, answer) => {
         said,
     };
 };
+/**
+ * What is said when a read could not be had because hotel groups did not answer
+ * in time - one group, or several, or every one.
+ *
+ * ⚠️ NEVER JUST THE FIRST GROUP, NEVER "NONE HERE" (2026-11-03 review, C5/C8).
+ * Where every group of a market is silent it says so ("no group answered this
+ * time"), not the name of whichever was asked first; and in every case it
+ * denies the reading a guest would make of silence, that there is nothing.
+ */
+const notAnswered = (deps, key, down) => {
+    const groups = deps.backend.suppliers?.().length ?? 0;
+    const names = listAnd(down.map((d) => d.name));
+    const one = down.length === 1;
+    const said = groups > 1 && down.length >= groups
+        ? `No hotel group answered this time: ${names} did not answer in time - this does not mean there is nothing here; asking again in a moment may bring them.`
+        : `${names} did not answer in time, so nothing from ${one ? 'it' : 'them'} could be read just now - this does not mean ${one ? 'it has' : 'they have'} none here; asking again in a moment may bring ${one ? 'it' : 'them'}.`;
+    return {
+        structured: {
+            view: 'error',
+            ...common(deps, key),
+            error: 'supplier-timeout',
+            detail: said,
+            degraded: down.map((d) => ({ supplier: d.supplier, name: d.name })),
+            degradedSaid: said,
+        },
+        text: said,
+        // Like `bad-count`: the card still draws it, and a host that checks a
+        // result against the tool's output schema does not hold an error to it.
+        isError: true,
+    };
+};
 /** The counts a call can carry, and what each may be. */
 const COUNTS = ['guests', 'rooms', 'quantity'];
 /** "2" is 2: a host that sends a count as a string has not asked for something else. */
@@ -2916,6 +3017,13 @@ const countProblem = (t, name, args) => {
  */
 const guestWords = (err, fault = 'That could not be done just now - nothing was changed. Try again in a moment.') => {
     const e = err;
+    // ⚠️ A READ THAT TIMED OUT IS NOT A REFUSAL (2026-11-03 review, C5). After a
+    // booking was made, "Atour did not answer within 8000 ms" would be read
+    // back as the booking's own answer - and sound like it was not made.
+    if (unansweredBy(err)) {
+        console.error('[tools] a read timed out:', e.message);
+        return fault;
+    }
     if (e instanceof Error && (typeof e.code === 'string' || e.constructor === Error))
         return e.message;
     console.error('[tools] failed:', err);
@@ -2969,14 +3077,42 @@ const guarded = async (deps, ctx, who, code, run) => {
  */
 const quoteParts = async (deps, lines, who, coupon) => {
     const byCurrency = new Map();
+    // ⚠️ A HOTEL WHOSE GROUP DID NOT ANSWER IS LEFT OUT OF THE PRICE, SAID (2026-11-03
+    // review, C5): its currency cannot be read, so it cannot be priced with the
+    // rest - and it is not an empty trip, nor a trip without it.
+    const unread = new Map();
     for (const l of lines) {
-        const c = (await deps.backend.getHotel(l.hotelId))?.hotel.currency ?? '';
-        byCurrency.set(c, [...(byCurrency.get(c) ?? []), l]);
+        try {
+            const c = (await deps.backend.getHotel(l.hotelId))?.hotel.currency ?? '';
+            byCurrency.set(c, [...(byCurrency.get(c) ?? []), l]);
+        }
+        catch (err) {
+            const down = unansweredBy(err);
+            if (!down)
+                throw err;
+            for (const g of down)
+                unread.set(g.supplier, g);
+        }
     }
     const asked = coupon ? { coupon } : {};
+    if (byCurrency.size === 0 && unread.size) {
+        throw Object.assign(new Error(`${listAnd([...unread.values()].map((g) => g.name))} did not answer`), { code: 'supplier-timeout', unanswered: [...unread.values()] });
+    }
     if (byCurrency.size === 0)
         return [await deps.backend.quote({ lines: [], ...asked }, who)];
-    const parts = await Promise.all([...byCurrency.values()].map((g) => deps.backend.quote({ lines: g, ...asked }, who)));
+    const priced = await Promise.all([...byCurrency.values()].map((g) => deps.backend.quote({ lines: g, ...asked }, who)));
+    const parts = unread.size && priced[0]
+        ? [
+            {
+                ...priced[0],
+                dropped: [
+                    ...(priced[0].dropped ?? []),
+                    ...[...unread.values()].map(notPricedForNoAnswer),
+                ],
+            },
+            ...priced.slice(1),
+        ]
+        : priced;
     // 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;
@@ -3434,7 +3570,17 @@ export const tripGone = (deps) => {
 };
 export const handleTool = async (deps, name, rawArgs, ctx) => {
     const { result, written } = await keepingAmounts(async () => {
-        const answer = await answerTool(deps, name, rawArgs, ctx);
+        // ⚠️ A GROUP THAT DID NOT ANSWER A READ IS AN ANSWER, NOT A FAULT (2026-11-03
+        // review, C5/C8): the hotel page, the add-ons, the dates, a booking looked
+        // up. Thrown by the market past its time limit, it reached the host as "the
+        // connector could not answer that" - or, for a search where every group was
+        // silent, as the first group's name alone. Said here, naming every group.
+        const answer = await answerTool(deps, name, rawArgs, ctx).catch((err) => {
+            const down = unansweredBy(err);
+            if (!down)
+                throw err;
+            return notAnswered(deps, ctx.tripKey ?? tripKey(ctx.session, deps.vocab.brand), down);
+        });
         const suggestions = await suggestionsFor(deps, answer.structured).catch(() => []);
         return { answer, suggestions };
     });
@@ -3530,7 +3676,13 @@ const listedInWords = (h) => {
     const price = f
         ? `${formatMoney(f.total)} for the stay incl. taxes and fees, ${withZh(f.room, f.roomNames, true)}${f.rooms > 1 ? ` × ${f.rooms}` : ''}${terms.length ? ` [${terms.join(', ')}]` : ''}`
         : h.noRoomsForStay
-            ? 'no room for those nights'
+            ? // ⚠️ NOT SOLD HERE IS NOT SOLD OUT (2026-11-03 review, U11): a hotel with no
+                // rooms on sale through this connector was told as "no room for those
+                // nights", and the model said "no vacancy tonight" - as if another night
+                // would do. It says what the hotel's own page says.
+                h.noRoomsForStayCode === 'none-on-sale'
+                    ? h.noRoomsForStay
+                    : 'no room for those nights'
             : h.fromNightly
                 ? `from ${formatMoney(h.fromNightly)} ${nightWords(true)}`
                 : '';
@@ -3763,6 +3915,57 @@ const LIVE_STATUSES = new Set([
     'unconfirmed',
     'awaiting-payment',
 ]);
+/**
+ * A coupon asked for on a booking that was already made, without it - or
+ * nothing.
+ *
+ * ⚠️ NEVER SILENT THAT THE COUPON WAS NOT USED (2026-11-03 review, C3). The
+ * same stay asked for again within minutes is answered with the first
+ * booking (`repeat`); a member who first booked without a coupon and then said
+ * "use the 满500减50" was handed the first booking at its first price, with
+ * nothing said of the coupon they had just agreed to. The coupon is NOT put in
+ * the repeat key - that would book the stay twice - so the answer says it:
+ * the booking stands as it was, the coupon was not spent, and what it takes to
+ * use it is cancelling this one (free until when, or what it costs) and
+ * booking again. In the structure as `couponNotUsed` and in the same words.
+ */
+const couponNotUsedOf = (deps, key, asked, 
+/** The bookings that were asked for before and returned as they were. */
+reusedBookings, 
+/** Every booking in the answer: the coupon may have gone on one made now. */
+answered) => {
+    const want = asked?.trim().toUpperCase();
+    if (!want || reusedBookings.length === 0)
+        return undefined;
+    if (answered.some((b) => b.quote.coupon?.id.toUpperCase() === want))
+        return undefined;
+    const t = deps.tools;
+    const held = deps.members.read(key)?.coupons?.find((c) => c.id.toUpperCase() === want);
+    const label = held ? couponName(held) : (asked ?? '');
+    const codes = reusedBookings.map((b) => b.confirmationCode).filter(Boolean);
+    const names = codes.length ? codes.join(', ') : 'it';
+    const now = deps.trips.now();
+    // Free to cancel still: every room line has a window that has not closed.
+    const rooms = reusedBookings.flatMap((b) => b.quote.lines.filter((l) => l.kind === 'room'));
+    const open = rooms.filter((l) => l.freeCancellationUntil && Date.parse(l.freeCancellationUntil) > now);
+    const first = open
+        .slice()
+        .sort((a, b) => (a.freeCancellationUntil ?? '').localeCompare(b.freeCancellationUntil ?? ''))[0];
+    const freeUntil = rooms.length > 0 && open.length === rooms.length && first ? freeUntilText(first) : undefined;
+    const total = reusedBookings.map((b) => formatMoney(b.quote.total)).join(' + ');
+    const said = `THE COUPON WAS NOT USED: ${reusedBookings.length > 1 ? 'these bookings were' : 'this booking was'} made a few minutes ago without the coupon ${label}, and a booking already made is not changed to take one - ${reusedBookings.length > 1 ? 'they stand' : 'it stands'} at ${total} all in, and the coupon is still the member's. To use it, cancel ${names} (${freeUntil ? `free to cancel until ${freeUntil}` : `${t.previewCancellation} says what cancelling costs`}) and book again with the coupon - only if the guest wants that.`;
+    return {
+        structured: {
+            id: asked,
+            ...(held ? { name: held.name, ...(held.names ? { names: held.names } : {}) } : {}),
+            bookings: codes,
+            cancelFree: !!freeUntil,
+            ...(freeUntil ? { freeUntil } : {}),
+            said,
+        },
+        said,
+    };
+};
 /**
  * The booking this very form made a few minutes ago, when the slot is empty
  * because of it - or undefined.
@@ -3803,6 +4006,7 @@ const bookedFromThisForm = async (deps, ctx, key, args) => {
         x.quote.lines.some((l) => l.kind === 'room' && l.roomRef === room && (l.quantity ?? 1) === rooms));
     if (!b)
         return undefined;
+    const notUsed = couponNotUsedOf(deps, key, couponOf(deps, args), [b], [b]);
     return {
         structured: {
             view: 'booking',
@@ -3812,9 +4016,11 @@ const bookedFromThisForm = async (deps, ctx, key, args) => {
             holdUntil: b.holdUntil,
             total: formatMoney(b.quote.total),
             repeat: true,
+            ...(notUsed ? { couponNotUsed: notUsed.structured } : {}),
         },
         text: [
             'NOTHING NEW WAS BOOKED: this booking form already booked this room a few minutes ago, and that answer did not reach the card - this is the booking made then.',
+            notUsed?.said ?? '',
             `**${confirming(deps, b) ? 'Being confirmed' : b.confirmationCode}** · ${b.hotelName} · ${stayWords(b.stay, b.hourly)}`,
             bookedLine(deps, b) ?? '',
             deps.vocab.demo ? noteFor(deps.vocab) : '',
@@ -3869,6 +4075,47 @@ const putRoomLine = async (deps, t, ctx, key, store, args, detail) => {
             return currentTrip(deps, key, who, store, couponOf(deps, args), ctx);
         }
     }
+    // ⚠️ LISTED, NOT BOOKED HERE (robin, 2026-10-30): a rate paid in advance
+    // where this deployment takes no payment goes in no trip and no pick. The
+    // press on its Reserve - or the assistant asking for it - is answered with
+    // what is true and what is left: nothing booked, nothing charged; the rates
+    // here paid at the hotel, a press each; other dates; or the group itself.
+    // Never a review that fails at Book, after the guest typed their name.
+    // ONE ANSWER FOR A ROOM BY THE NIGHT AND A ROOM BY THE HOUR (2026-11-03
+    // review, C6): the hourly branch put such a room in the trip before this was
+    // asked, and the guest met the refusal at "Book".
+    const prepaidNotHere = (room, open, stay, when) => {
+        const group = groupNameOf(deps, hotelId);
+        const said = [
+            `Nothing was booked or charged: ${room.name} is paid in advance, and a stay paid in advance cannot be booked here yet - this connector books rates paid at the hotel.`,
+            open.length
+                ? `Paid at the hotel at ${detail.hotel.name} ${when}: ${open.map((r) => `${r.name} (\`${r.id}\`)`).join(', ')}.`
+                : `No rate at ${detail.hotel.name} ${when} is paid at the hotel.`,
+            `Other dates, or booking this rate with ${group} directly, are the other ways on.`,
+        ].join(' ');
+        return {
+            structured: {
+                view: 'error',
+                ...common(deps, key),
+                error: 'prepaid-not-here',
+                room: { id: room.id, name: room.name, ...(room.names ? { names: room.names } : {}) },
+                rooms: open.map((r) => ({
+                    id: r.id,
+                    name: r.name,
+                    ...(r.names ? { names: r.names } : {}),
+                })),
+                hotel: {
+                    id: detail.hotel.id,
+                    name: detail.hotel.name,
+                    ...(detail.hotel.names ? { names: detail.hotel.names } : {}),
+                },
+                stay,
+                group,
+                said,
+            },
+            text: said,
+        };
+    };
     const today = (startTime || !asStay(args)
         ? deps.backend.hourlyRooms?.(hotelId, guestsOf(args), who)
         : undefined);
@@ -3897,6 +4144,15 @@ const putRoomLine = async (deps, t, ctx, key, store, args, detail) => {
                     : ((await today)?.noRooms ?? `${detail.hotel.name} has no rooms by the hour today.`),
             };
         }
+        if (hourlyRoom.notSoldHere) {
+            const wantedHere = Math.max(1, clampCount(args.rooms ?? 1, MAX_ROOMS_PER_LINE));
+            const open = ((await today)?.rooms ?? []).filter((r) => r.hourly && !r.notSoldHere && r.roomsLeft >= wantedHere);
+            return prepaidNotHere(hourlyRoom, open, {
+                checkIn: hourlyRoom.hourly.date,
+                checkOut: hourlyRoom.hourly.date,
+                guests: guestsOf(args),
+            }, 'by the hour today');
+        }
         const bad = startProblem(hourlyRoom.hourly, startTime);
         if (bad) {
             return {
@@ -4026,44 +4282,10 @@ const putRoomLine = async (deps, t, ctx, key, store, args, detail) => {
             text: `${type ? `${detail.hotel.name} has no ${type.name} that sleeps ${stay.guests} and has ${wanted === 1 ? 'a room' : `${wanted} rooms`} left for those nights.` : `${detail.hotel.name} has no room type by that name for those nights.`} It has: ${dated.rooms.map((r) => `${r.name} (${han && r.names?.zh ? `${r.names.zh}, ` : ''}\`${r.id}\`)`).join(', ')}. Call again with the id.`,
         };
     }
-    // ⚠️ LISTED, NOT BOOKED HERE (robin, 2026-10-30): a rate paid in advance
-    // where this deployment takes no payment goes in no trip and no pick. The
-    // press on its Reserve - or the assistant asking for it - is answered with
-    // what is true and what is left: nothing booked, nothing charged; the rates
-    // here paid at the hotel, a press each; other dates; or the group itself.
-    // Never a review that fails at Book, after the guest typed their name.
+    // Listed, not booked here - see `prepaidNotHere`.
     if (room.notSoldHere) {
         const open = dated.rooms.filter((r) => !r.notSoldHere && r.sleeps >= stay.guests && r.roomsLeft >= wanted);
-        const group = groupNameOf(deps, hotelId);
-        const said = [
-            `Nothing was booked or charged: ${room.name} is paid in advance, and a stay paid in advance cannot be booked here yet - this connector books rates paid at the hotel.`,
-            open.length
-                ? `Paid at the hotel at ${detail.hotel.name} for those nights: ${open.map((r) => `${r.name} (\`${r.id}\`)`).join(', ')}.`
-                : `No rate at ${detail.hotel.name} for those nights is paid at the hotel.`,
-            `Other dates, or booking this rate with ${group} directly, are the other ways on.`,
-        ].join(' ');
-        return {
-            structured: {
-                view: 'error',
-                ...common(deps, key),
-                error: 'prepaid-not-here',
-                room: { id: room.id, name: room.name, ...(room.names ? { names: room.names } : {}) },
-                rooms: open.map((r) => ({
-                    id: r.id,
-                    name: r.name,
-                    ...(r.names ? { names: r.names } : {}),
-                })),
-                hotel: {
-                    id: detail.hotel.id,
-                    name: detail.hotel.name,
-                    ...(detail.hotel.names ? { names: detail.hotel.names } : {}),
-                },
-                stay,
-                group,
-                said,
-            },
-            text: said,
-        };
+        return prepaidNotHere(room, open, stay, 'for those nights');
     }
     deps.trips.set(store, {
         kind: 'room',
@@ -4103,7 +4325,7 @@ const bookTripLines = async (deps, t, ctx, key, store, args, nothingThere) => {
     // the trip as it is now (no stamp); a card's form books the one it showed.
     const drawn = str(args.stamp);
     if (drawn && drawn !== stampOf(inTrip, deps.trips.shown(store))) {
-        const again = await currentTrip(deps, key, identity(deps, ctx, key), store);
+        const again = await currentTrip(deps, key, identity(deps, ctx, key), store, undefined, ctx);
         return {
             ...again,
             structured: { ...again.structured, tripChanged: true },
@@ -4196,7 +4418,7 @@ const bookTripLines = async (deps, t, ctx, key, store, args, nothingThere) => {
         // booking is held to (ShownQuote).
         const rest = lines.length === inTrip.length && !failed.length
             ? undefined
-            : await currentTrip(deps, key, identity(deps, ctx, key), store);
+            : await currentTrip(deps, key, identity(deps, ctx, key), store, undefined, ctx);
         const others = rest && lines.length !== inTrip.length;
         // What could be booked instead of each, found now (robin, 2026-10-14).
         const instead = await Promise.all(failed.map((f, i) => i < MAX_FAILED_WITH_ALTERNATIVES
@@ -4243,7 +4465,9 @@ const bookTripLines = async (deps, t, ctx, key, store, args, nothingThere) => {
         // at 15:00, and a generic "check-in is in the afternoon" is not an answer.
         // Per booking: each is its own hotel, with its own hour and its own desk.
         const booked = await Promise.all(made.map(async (booking, i) => {
-            const hotel = await deps.backend.getHotel(booking.hotelId);
+            // ⚠️ THE BOOKING IS MADE: a read after it that fails (a group slow to
+            // answer) loses the check-in hour, never the answer.
+            const hotel = await deps.backend.getHotel(booking.hotelId).catch(() => null);
             return {
                 booking,
                 // The requests that could not both be asked for are said once.
@@ -4254,6 +4478,10 @@ const bookTripLines = async (deps, t, ctx, key, store, args, nothingThere) => {
         const several = booked.length > 1;
         // The stays asked for minutes before, beside new ones - see `reused`.
         const earlier = booked.filter(({ booking }) => reused?.includes(booking.id));
+        // The coupon asked for, when the stays asked for before did not carry it
+        // and nothing new did either - see `couponNotUsedOf`.
+        const askedCoupon = couponOf(deps, args);
+        const notUsed = couponNotUsedOf(deps, key, askedCoupon, repeat ? made : earlier.map(({ booking }) => booking), made);
         const waiting = booked.filter(({ booking }) => confirming(deps, booking)).length;
         const notBooked = failed.map((f, i) => ({
             hotelId: f.hotelId,
@@ -4348,6 +4576,7 @@ const bookTripLines = async (deps, t, ctx, key, store, args, nothingThere) => {
                 ...(notBooked.length ? { failed: notBooked } : {}),
                 ...(repeat ? { repeat: true } : {}),
                 ...(earlier.length ? { repeated: earlier.map(({ booking }) => booking.id) } : {}),
+                ...(notUsed ? { couponNotUsed: notUsed.structured } : {}),
             },
             text: [
                 // ⚠️ THE SAME BOOKING ASKED FOR AGAIN IS SAID TO BE THAT, never a new
@@ -4357,6 +4586,7 @@ const bookTripLines = async (deps, t, ctx, key, store, args, nothingThere) => {
                     : earlier.length
                         ? `NOT ALL NEW: ${listAnd(earlier.map(({ booking }) => booking.confirmationCode || booking.hotelName))} ${earlier.length > 1 ? 'were' : 'was'} asked for a few minutes ago for the same guest and ${earlier.length > 1 ? 'are the bookings' : 'is the booking'} made then; the rest were booked now.`
                         : '',
+                notUsed?.said ?? '',
                 // ⚠️ BOOKED IS CONFIRMED: a stay still being confirmed is said as
                 // that, and not counted (总线程, 2026-10-14).
                 notBooked.length || (booked.length > 1 && waiting)
@@ -4386,13 +4616,16 @@ const bookTripLines = async (deps, t, ctx, key, store, args, nothingThere) => {
         // and the trip is shown again at today's - which is then what the guest
         // has seen, and what a second ask books.
         if (err.code === 'price-changed') {
-            const again = await currentTrip(deps, key, identity(deps, ctx, key), store);
+            const again = await currentTrip(deps, key, identity(deps, ctx, key), store, undefined, ctx);
             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));
+            // ⚠️ WITH THE CONTEXT, like every other answer of the trip (2026-11-03
+            // review, T1): without it the restated trip lost the Chinese room and
+            // hotel names a host with no card is given beside the plain ones.
+            const again = await currentTrip(deps, key, identity(deps, ctx, key), store, couponOf(deps, args), ctx);
             return {
                 ...again,
                 structured: { ...again.structured, notBooked: 'coupon' },
@@ -4400,7 +4633,7 @@ const bookTripLines = async (deps, t, ctx, key, store, args, nothingThere) => {
             };
         }
         if (err.code === 'mixed-supplier') {
-            const again = await currentTrip(deps, key, identity(deps, ctx, key), store);
+            const again = await currentTrip(deps, key, identity(deps, ctx, key), store, undefined, ctx);
             return {
                 ...again,
                 text: [
@@ -4500,7 +4733,14 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         // 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) {
+        // ⚠️ AND NOT WHEN A GROUP DID NOT ANSWER (2026-11-03 review, C4). The place
+        // "matched nothing" among the groups that answered; the one that did not
+        // may have it. A wider search then found something else, took over as the
+        // answer, and the first search's "X did not answer" went with it - "nothing
+        // matched Hong Kong, so this is Shenzhen", with Hong Kong's group silent.
+        // It also cost another time limit. The empty answer is given as it is, with
+        // the sentence that the group did not answer (`degradedOf`).
+        if (placedCount(answer) === 0 && !answer.degraded?.length) {
             const wider = widen(ask);
             if (wider) {
                 const second = await deps.backend.searchHotels(wider.ask, who);
@@ -4666,8 +4906,11 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 guests: guestsOf(args),
             };
             const priced = await answerTool(deps, t.listHotels, { ...args, ...tonight }, ctx);
+            // ⚠️ THE ROOMS ASKED FOR, not "one room" (2026-11-03 review, C12): `rooms: 2`
+            // rides along into the priced list, and every price in it is two rooms'.
+            const roomCount = ask.rooms ?? 1;
             // In both, in the same words: the model reads the structure.
-            const stayDefault = `No dates were asked for, so this opens on tonight by default: ${tonight.checkIn} to ${tonight.checkOut} (one night, on the hotels' own date), ${tonight.guests} ${tonight.guests === 1 ? 'guest' : 'guests'}, one room - every price here is for that night. Say so: the prices shown are tonight's, and the guest can ${ctx.noCards ? 'name other dates' : 'change the dates on the card or name others'}. Do not ask for dates before showing them.`;
+            const stayDefault = `No dates were asked for, so this opens on tonight by default: ${tonight.checkIn} to ${tonight.checkOut} (one night, on the hotels' own date), ${tonight.guests} ${tonight.guests === 1 ? 'guest' : 'guests'}, ${roomCount === 1 ? 'one room' : `${roomCount} rooms`} - every price here is for that night. Say so: the prices shown are tonight's, and the guest can ${ctx.noCards ? 'name other dates' : 'change the dates on the card or name others'}. Do not ask for dates before showing them.`;
             // Right after what is here - "every one, and no others" stays the first thing said.
             const inAll = String(priced.structured.inAll ?? '');
             return {
@@ -4910,8 +5153,12 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             ask.filters?.hourly && hotels.some((h) => h.forStay?.hours)
                 ? `By the hour, today: each price is that ${deps.vocab.noun}'s cheapest room by the hour, for its hours, taxes included.`
                 : ask.stay
-                    ? `Priced for ${ask.stay.checkIn} to ${ask.stay.checkOut}${ask.rooms && ask.rooms > 1 ? `, ${ask.rooms} rooms` : ''}: each price is that ${deps.vocab.noun}'s cheapest room for the whole stay, taxes included${hotels.some((h) => h.noRoomsForStay)
-                        ? `; ${hotels.filter((h) => h.noRoomsForStay).length} in this answer have no room for those nights`
+                    ? `Priced for ${ask.stay.checkIn} to ${ask.stay.checkOut}${ask.rooms && ask.rooms > 1 ? `, ${ask.rooms} rooms` : ''}: each price is that ${deps.vocab.noun}'s cheapest room for the whole stay, taxes included${hotels.some((h) => h.noRoomsForStay && h.noRoomsForStayCode !== 'none-on-sale')
+                        ? `; ${hotels.filter((h) => h.noRoomsForStay && h.noRoomsForStayCode !== 'none-on-sale').length} in this answer have no room for those nights`
+                        : ''}${
+                    // The other kind, said as its own (U11): other nights will not help.
+                    hotels.some((h) => h.noRoomsForStayCode === 'none-on-sale')
+                        ? `; ${hotels.filter((h) => h.noRoomsForStayCode === 'none-on-sale').length} in this answer ${hotels.filter((h) => h.noRoomsForStayCode === 'none-on-sale').length === 1 ? 'has' : 'have'} no rooms on sale through this connector - not sold out, and other nights make no difference`
                         : ''}.`
                     : '',
         ].filter(Boolean);
@@ -5445,7 +5692,9 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 ...(isDay(str(args.day)) ? { day: str(args.day) } : {}),
             };
             deps.trips.set(key, line);
-            return currentTrip(deps, key, identity(deps, ctx, key), key, undefined, ctx);
+            // ⚠️ THE COUPON STAYS ON, like on a room (2026-11-03 review, C11): its
+            // schema says it keeps the new price, and `undefined` here dropped it.
+            return currentTrip(deps, key, identity(deps, ctx, key), key, couponOf(deps, args), ctx);
         }
         return putRoomLine(deps, t, ctx, key, key, args, detail);
     }
@@ -5492,6 +5741,9 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
     if (name === t.listBookings) {
         const who = identity(deps, ctx, key, args);
         const here = await deps.backend.listBookings(who, typeof args.limit === 'number' ? args.limit : undefined);
+        // Read here, before a filter or a spread drops it: the groups whose
+        // bookings are not in `here` (2026-11-03 review, C5).
+        const missing = degradedOf(deps, { degraded: here.degraded }, 'bookings');
         // Elsewhere, only with the code AND the email - see `listBookings`.
         const code = str(args.booking);
         const { found: there, tooMany } = code && str(args.email)
@@ -5517,6 +5769,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 // than "nothing in this conversation".
                 ...(missed ? { notFound: code, notFoundLine: missLine } : {}),
                 ...(tooMany ? { tooMany: true } : {}),
+                ...missing.structured,
             },
             text: [
                 missed ? missLine : '',
@@ -5524,7 +5777,11 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                     ? bookings.map((b) => bookingLine(b, ctx.noCards)).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.',
+                        : // ⚠️ NOT "NO BOOKINGS" when a group did not answer: it may hold them.
+                            missing.said
+                                ? ''
+                                : 'No bookings in this conversation. A booking made elsewhere is found with its confirmation code and the email it was made with.',
+                missing.said,
             ]
                 .filter(Boolean)
                 .join('\n'),
@@ -5881,13 +6138,18 @@ 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) } }
+                    ? {
+                        coupon: {
+                            ...preview.coupon,
+                            said: couponBackWords(preview.coupon, formatMoney(preview.fee)),
+                        },
+                    }
                     : {}),
             },
             text: [
                 `Cancelling ${preview.confirmationCode} would cost ${formatMoney(preview.fee)}${preview.fee.minor === 0 ? ' - nothing' : ''}.`,
                 preview.rule,
-                preview.coupon ? couponBackWords(preview.coupon) : '',
+                preview.coupon ? couponBackWords(preview.coupon, formatMoney(preview.fee)) : '',
                 preview.cancellable
                     ? `Say the word and it is cancelled (${t.cancelBooking} with \`confirmed\`).`
                     : '',
@@ -5930,6 +6192,28 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         // will be charged.
         const charged = cancelled.cancellationFee ?? preview.fee;
         const h = holderOf(deps, cancelled.supplier);
+        // What became of the coupon the booking used, said once and handed over in
+        // both: the structure's `coupon` and the text's sentence are this one string.
+        const couponNow = cancelled.quote.coupon && cancelled.couponReturned !== undefined
+            ? (() => {
+                const returned = cancelled.couponReturned === true;
+                const c = {
+                    id: cancelled.quote.coupon.id,
+                    name: cancelled.quote.coupon.name,
+                    ...(cancelled.quote.coupon.names ? { names: cancelled.quote.coupon.names } : {}),
+                    validUntil: cancelled.quote.coupon.validUntil,
+                    returned,
+                    // A booking cancelled before the reason was kept: a coupon not
+                    // returned could then only have run out.
+                    ...(returned
+                        ? {}
+                        : {
+                            notReturnedBecause: cancelled.couponNotReturnedBecause ?? 'expired',
+                        }),
+                };
+                return { ...c, said: couponBackWords(c, formatMoney(charged), true) };
+            })()
+            : undefined;
         return {
             structured: {
                 view: 'cancelled',
@@ -5940,6 +6224,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 fee: formatMoney(charged),
                 rule: preview.rule,
                 cancellable: false,
+                ...(couponNow ? { coupon: couponNow } : {}),
             },
             text: [
                 cancelled.payment
@@ -5954,11 +6239,7 @@ 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.`
-                    : '',
+                couponNow?.said ?? '',
                 demoBookingNote(deps, cancelled.supplier),
                 deps.vocab.demo ? noteFor(deps.vocab) : '',
             ]
@@ -5982,7 +6263,10 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             who: identity(deps, ctx, key),
         });
         if (comparison.columns.length === 0) {
-            const unknown = comparison.dropped.filter((d) => !d.candidates?.length);
+            // A group that did not answer is not "not ours" (2026-11-03 review, C5):
+            // its hotels are said as left out for that.
+            const silent = comparison.dropped.filter((d) => d.code === 'supplier-timeout');
+            const unknown = comparison.dropped.filter((d) => !d.candidates?.length && d.code !== 'supplier-timeout');
             const fitsMany = fitsManyOf(deps, comparison.dropped);
             return {
                 structured: {
@@ -5992,12 +6276,13 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 },
                 // A name that fits several IS one of ours - only the rest are "none".
                 text: [
-                    ...(unknown.length || !fitsMany.length
+                    ...(unknown.length || (!fitsMany.length && !silent.length)
                         ? [
                             `None of those are ${catalogue(deps.vocab)}: ${unknown.map((d) => d.name).join(', ')}.`,
                         ]
                         : []),
                     ...fitsMany,
+                    ...silent.map((d) => `Left out: ${d.name} — ${d.why}`),
                 ].join('\n'),
             };
         }
@@ -6048,6 +6333,25 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
     }
     if (name === t.itinerary) {
         const days = Array.isArray(args.days) ? args.days : [];
+        // ⚠️ WHICH STAYS ARE BOOKED ALREADY marks the plan; a group that did not
+        // answer cannot be checked, and the plan says so rather than showing its
+        // stays as not booked (2026-11-03 review, C5).
+        let planBookings = [];
+        let unchecked = [];
+        try {
+            const mine = await deps.backend.listBookings(identity(deps, ctx, key, args), 50);
+            planBookings = mine;
+            unchecked = mine.degraded ?? [];
+        }
+        catch (err) {
+            const down = unansweredBy(err);
+            if (!down)
+                throw err;
+            unchecked = down;
+        }
+        const uncheckedSaid = unchecked.length
+            ? `${listAnd(unchecked.map((d) => d.name))} did not answer in time, so ${unchecked.length === 1 ? 'its' : 'their'} bookings were not checked against this plan - a stay there may already be booked without the plan saying so; asking again in a moment may check them.`
+            : '';
         const plan = await buildItinerary(deps.backend, days.map((d) => ({
             label: str(d.label),
             note: typeof d.note === 'string' ? d.note : undefined,
@@ -6058,7 +6362,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             title: str(args.title),
             stay: asStay(args),
             trip: deps.trips.read(key),
-            bookings: await deps.backend.listBookings(identity(deps, ctx, key, args), 50),
+            bookings: planBookings,
             who: identity(deps, ctx, key),
         });
         if (plan.days.length === 0) {
@@ -6120,6 +6424,12 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 gap,
                 ...(nudges.length ? { nudges } : {}),
                 ...(overlaps.length ? { overlaps } : {}),
+                ...(uncheckedSaid
+                    ? {
+                        degraded: unchecked.map((d) => ({ supplier: d.supplier, name: d.name })),
+                        degradedSaid: uncheckedSaid,
+                    }
+                    : {}),
                 // In both, like the nudges: a host with no card may hand its model
                 // this rather than the text.
                 ...(ctx.noCards ? { notDrawn: PLAN_NOT_DRAWN } : {}),
@@ -6139,6 +6449,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                     : []),
                 ...plan.dropped.map((d) => `Left out: ${d.name} — ${d.why}`),
                 ...fitsManyOf(deps, plan.dropped),
+                uncheckedSaid,
                 ctx.noCards ? PLAN_NOT_DRAWN : PLAN_DRAWN_ONCE,
                 deps.vocab.demo ? noteFor(deps.vocab) : '',
             ]