@curless/hotel-storefront 0.52.1 → 0.54.0

package/dist/tools.js

@@ -1,4 +1,6 @@
-import { DEFAULT_PAGE, FULL_CAPABILITIES, LASTING_REQUESTS, MAX_PAGE, REQUEST_KINDS, REQUEST_NOTE_MAX, guestTooLong, unitWords, } from './backend.js';
+import { aboutLines } from './about.js';
+import { DEFAULT_PAGE, FULL_CAPABILITIES, LASTING_REQUESTS, MAX_PAGE, REQUEST_KINDS, REQUEST_NOTE_MAX, guestTooLong, notPricedForNoAnswer, unansweredBy, unitWords, } from './backend.js';
+import { usedOnWords } from './coupon-words.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';
@@ -302,8 +304,8 @@ const forCapabilities = (tools, n, v, caps) => {
                             ? 'A rate marked paid in advance is booked on its own, and not at once: the answer gives a card page in test mode and the time it is paid by, and the stay is booked once it is paid - no card is collected here. Every other rate is paid by nobody.'
                             : 'No payment is taken and no card is collected.'} All of the trip is booked or none of it. Preferences - a bed type, a floor, a late arrival - ride along on the booking as requests.`
                         : v.sandbox
-                            ? `Makes a booking in a simulated copy of ${v.brand}'s booking system, for testing: each stay gets its own confirmation code there, and none of it is a ${v.brand} reservation or holds a real room. ${caps.prepaid
-                                ? 'A rate marked paid in advance is booked on its own, and not at once: the answer gives a card page in test mode and the time it is paid by, and the stay is booked once it is paid - no card is collected here. Every other rate is paid by nobody.'
+                            ? `Makes a simulated booking in a simulated copy of ${v.brand}'s booking system: each stay gets its own confirmation code there, and none of it is a ${v.brand} reservation or holds a real room. ${caps.prepaid
+                                ? 'A rate marked paid in advance is booked on its own, and not at once: the answer gives a card page where no real money moves and the time it is paid by, and the stay is booked once it is paid - no card is collected here. Every other rate is paid by nobody.'
                                 : 'No payment is taken and no card is collected.'} All of the trip is booked or none of it. Preferences - a bed type, a floor, a late arrival - ride along on the booking as requests.`
                             : `Books the trip's rooms with ${v.brand} for a named guest: each stay becomes the hotel's own reservation, with its own confirmation code, paid at the hotel. No payment is taken here and no card is collected. All of the trip is booked or none of it. Preferences - a bed type, a floor, a late arrival - ride along on the booking as requests the desk tries to meet.`,
                 };
@@ -592,9 +594,10 @@ const allTools = (n, v) => {
             // could take the code to the real hotel.
             description: v.market
                 ? // ⚠️ THE GROUP HOLDS THE BOOKING, NOT THE MARKET - and what a booking
-                    // makes is the group's: a hold, a test booking, or a reservation paid
-                    // at the hotel. The answer says which, stay by stay.
-                    `Books the trip's rooms for a named guest with the hotel group each stay belongs to, one group at a time: a trip holding two groups' hotels is booked group by group. What a booking makes is that group's - a demonstration hold that lapses on its own, a test booking in a simulated system, or the hotel's own reservation paid at the hotel - and the answer says which for every stay. No payment is taken here and no card is collected. Preferences - a bed type, a floor, a late arrival - ride along on the booking as requests.`
+                    // makes is the group's: a hold, a booking that holds no room, or a
+                    // reservation paid at the hotel. The answer says which, stay by stay.
+                    // ⚠️ NO "DEMONSTRATION" / "TEST" / "SIMULATED" IN A MARKET (robin, 2026-11-03).
+                    `Books the trip's rooms for a named guest with the hotel group each stay belongs to, one group at a time: a trip holding two groups' hotels is booked group by group. What a booking makes is that group's - a hold that lapses on its own and is not sent to the group, a booking that holds no room for anyone, or the hotel's own reservation paid at the hotel - and the answer says which for every stay. No payment is taken here and no card is collected. Preferences - a bed type, a floor, a late arrival - ride along on the booking as requests.`
                 : v.demo
                     ? `Makes a demonstration booking request for the trip's rooms, for a named guest: it returns a confirmation code and the moment the demonstration hold lapses on its own. ${v.brand} does not receive it and no real room is held. No payment is taken and no card is collected. Preferences - a bed type, a floor, a late arrival - ride along on the request.`
                     : `Asks ${v.brand} to hold the trip's rooms for a named guest and returns a confirmation code and the moment the hold lapses. No payment is taken and no card is collected; the rooms are held, not paid for. Preferences - a bed type, a floor, a late arrival - ride along on the booking as requests the desk tries to meet.`,
@@ -1288,6 +1291,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`). */
@@ -1704,6 +1709,7 @@ const holderOf = (deps, supplier) => {
             demo: s.mode !== 'live',
             sandbox: s.mode === 'sandbox',
             test: s.mode === 'test',
+            notReal: !!deps.vocab.market && s.mode !== 'live',
         };
     return {
         name: deps.vocab.brand,
@@ -1711,6 +1717,7 @@ const holderOf = (deps, supplier) => {
         demo: deps.vocab.demo,
         sandbox: !!deps.vocab.sandbox,
         test: !!deps.vocab.test,
+        notReal: false,
     };
 };
 /**
@@ -1730,6 +1737,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
@@ -1784,11 +1796,17 @@ const paidLine = (deps, b, fee) => {
     const back = formatMoney(p.refundAmount ?? p.amount);
     const whole = !p.refundAmount || p.refundAmount.minor === p.amount.minor;
     const unionpay = p.method === 'unionpay';
-    const test = h.sandbox
-        ? ` This is a test: ${unionpay ? "UnionPay's test system" : 'the card page in test mode'}, no real money moves, and the booking is in the simulated system.`
-        : h.test
-            ? ` This is a test: ${unionpay ? "UnionPay's test system" : 'the card page in test mode'}, no real money moves, and the booking is a test booking in ${h.name}'s test system.`
-            : '';
+    // ⚠️ ONE WORD PER ENVIRONMENT (0.54.0, M9): simulated on the simulated copy, test on a
+    // group's test system - and in a market neither, only the fact (`notReal`). A
+    // simulation names no "test card" or "UnionPay's test system": that is the payment
+    // channel's own environment, not the simulation's word.
+    const test = h.notReal
+        ? ` No real money moves, and this is not a real booking with ${h.name}.`
+        : h.sandbox
+            ? ' This is simulated: no real money moves, and the booking is a simulated booking.'
+            : h.test
+                ? ` This is a test: ${unionpay ? "UnionPay's test system" : 'the card page in test mode'}, no real money moves, and the booking is a test booking in ${h.name}'s test system.`
+                : '';
     const ended = b.status === 'cancelled' || b.status === 'expired' || b.status === 'failed';
     const said = (() => {
         // Its money as it stands once the stay has ended - never "if it does not take it".
@@ -1819,7 +1837,7 @@ const paidLine = (deps, b, fee) => {
                 case 'refunded':
                     return `${whole ? `All ${back}` : `${back} of the ${amount} paid`} has gone back to the card it was paid with${p.refundReason ? ` - ${p.refundReason}` : ''}.`;
                 case 'hotel-refunds':
-                    return `The money is with ${h.name}, who charged the one-time card UnionPay issued: what its terms give back${fee && fee.minor > 0 ? ` after its fee of ${formatMoney(fee)}` : ''}, it returns to that card - not this connector${p.refundReason ? ` (${p.refundReason})` : ''}.`;
+                    return `The money is with ${h.name}, who charged the one-time card UnionPay issued: what its terms give back${fee && fee.minor > 0 ? ` after its fee of ${formatMoney(fee)}` : ''}, it returns to that card - nothing is refunded from here${p.refundReason ? ` (${p.refundReason})` : ''}.`;
             }
         }
         switch (p.status) {
@@ -1853,7 +1871,7 @@ const paidLine = (deps, b, fee) => {
             case 'refunded':
                 return `${whole ? `All ${back}` : `${back} of the ${amount} paid`} has gone back to the card it was paid with${p.refundReason ? ` - ${p.refundReason}` : ''}.`;
             case 'hotel-refunds':
-                return `The money is with ${h.name}, who returns what its terms give back to the card it charged - not this connector.`;
+                return `The money is with ${h.name}, who returns what its terms give back to the card it charged - nothing is refunded from here.`;
         }
     })();
     return `${said}${test}`;
@@ -1895,8 +1913,11 @@ const heldLine = (deps, b) => {
     const total = formatMoney(b.quote.total);
     const h = holderOf(deps, b.supplier);
     if (h.caps.booking === 'pay-at-hotel') {
+        // ⚠️ A MARKET'S GROUP: the fact, in no environment's word (robin, 2026-11-03).
+        if (h.notReal)
+            return `${total} all in. **This booking was not sent to ${h.name}** - no room is held for anyone and nothing is paid, now or at any hotel.`;
         if (h.sandbox)
-            return `${total} in the simulated system. **This is a test booking** - not a ${h.name} reservation: no room is held and nothing is paid, now or at any hotel.`;
+            return `${total} in the simulated system. **This is a simulated booking** - not a ${h.name} reservation: no room is held and nothing is paid, now or at any hotel.`;
         if (h.test)
             return `${total} in ${h.name}'s test system. **This is a test booking** - it holds no room for anyone, nothing is paid, now or at any hotel, and nobody needs to go there.`;
         return b.status === 'requested'
@@ -1908,12 +1929,40 @@ 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(), h)}`;
     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, h) => {
+    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`;
+    // In a market, no "demonstration" (robin, 2026-11-03): only that it lapses and holds no room.
+    if (h.notReal)
+        return `It lapses by itself ${lasting} (no real room is held; the stay's own dates are not affected).`;
+    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.`;
+const demoBookingWords = (h) => h.notReal
+    ? `This booking was not sent to ${h.name}, and ${h.name} is not holding any room.`
+    : `This is a demonstration booking: ${h.name} has not received it and is not holding any room.`;
 /**
  * Said on every answer about a demonstration booking - made, changed or
  * cancelled - and on nothing else: a hold of the demo's that a guest took for
@@ -1962,7 +2011,10 @@ const common = (deps, key) => {
             ? { market: { name: deps.vocab.brand, suppliers: deps.backend.suppliers() } }
             : {}),
         vocab: { noun: deps.vocab.noun, nounPlural: deps.vocab.nounPlural },
-        ...(deps.vocab.demo ? { demo: true, demoNote: noteFor(deps.vocab) } : { demo: false }),
+        // A market's note is empty (`noteFor`): it labels no environment (robin, 2026-11-03).
+        ...(deps.vocab.demo
+            ? { demo: true, ...(noteFor(deps.vocab) ? { demoNote: noteFor(deps.vocab) } : {}) }
+            : { demo: false }),
         ...(key ? memberBadge(deps, key) : {}),
         ...(langOf(deps, key) ? { lang: langOf(deps, key) } : {}),
     };
@@ -2088,6 +2140,11 @@ const quoteForCard = (quote, groupOf) => ({
                 // 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),
+                // The room charges at the public rate, the taxes a row of their own -
+                // the receipt every guest gets: room, taxes, less the tier, less the
+                // coupon, is the total (0.54.0, M1: a member's started from the
+                // public rate taxes in, a guest's from the room before them).
+                publicSubtotal: formatMoney(money(quote.member.publicTotal.minor - (quote.taxesIncluded ? 0 : quote.taxesAndFees.minor), quote.total.currency)),
                 memberTotal: formatMoney(money(quote.member.publicTotal.minor - quote.member.saved.minor, quote.total.currency)),
             },
         }
@@ -2128,15 +2185,34 @@ const couponTerms = (c, brand) => [
     c.state === 'expired'
         ? `ran out on ${c.validUntil} - cannot be used`
         : c.state === 'used'
-            ? 'already used on a booking'
+            ? `already used ${usedOnWords(c.usedOn)}`
             : 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.`;
+/**
+ * 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 +2250,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 +2262,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 +2290,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 : '',
@@ -2449,6 +2542,8 @@ const labelWords = (r) => {
     ];
     return words.length ? ` [${words.join(', ')}]` : '';
 };
+/** What a list and a page both say of a hotel with nothing on sale here: other nights would not help. */
+const NOT_SOLD_OUT = 'not sold out, and other nights make no difference';
 /**
  * What is said of rates listed but not booked here (`Room.notSoldHere`) - in
  * the text and, word for word, in the structure (`notSoldHere`): the model reads
@@ -2456,7 +2551,18 @@ const labelWords = (r) => {
  * card says no more than 预付 on them (robin, 2026-10-30), so the assistant is
  * the one who knows - and says it when the guest wants one.
  */
-export const notSoldHereWords = (group) => `Rates marked paid in advance are listed as ${group} sells them, but a stay paid in advance cannot be booked here yet: this connector books rates paid at the hotel. If the guest wants one, say so plainly - nothing is booked or charged - and offer a rate paid at the hotel, other dates, or booking it with ${group} directly.`;
+export const notSoldHereWords = (group) => `Rates marked paid in advance are listed as ${group} sells them, but a stay paid in advance cannot be booked here yet; only rates paid at the hotel can be. If the guest wants one, say so plainly - nothing is booked or charged - and offer a rate paid at the hotel, other dates, or booking it with ${group} directly.`;
+/**
+ * A hotel none of whose rooms are on sale here (`none-on-sale`), said on its page
+ * with the way out (2026-11-03 review, T5). The page's text had one sentence -
+ * "This hotel has no rooms on sale here." - and the card said where to book it
+ * instead, so a client that draws no card left the guest with a dead end. The
+ * clause is the list's (see `NOT_SOLD_OUT`), so the list and the page say one
+ * thing; the group is the deployment's own, or the hotel's in a market, never a
+ * name written into the sentence. In the text and, word for word, in the
+ * structure (`noRooms`): the model reads the structure.
+ */
+export const notOnSaleWords = (group, why) => `${why.replace(/[.\s]+$/, '')} - ${NOT_SOLD_OUT}. To book it, the guest can use ${group}'s own channels: its app, its website or by phone.`;
 /** The group a hotel is with, by name - the deployment's own brand outside a market. */
 const groupNameOf = (deps, hotelId) => holderOf(deps, deps.backend.supplierOf?.(hotelId)).name;
 /** What a rate says about cancelling, as the text puts it. */
@@ -2645,7 +2751,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 +2959,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 +2975,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 +3057,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 +3117,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 +3610,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 +3716,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 +3955,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 +4046,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 +4056,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 +4115,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 - only rates paid at the hotel can be.`,
+            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 +4184,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 +4322,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 +4365,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 +4458,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 +4505,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 +4518,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 +4616,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 +4626,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 +4656,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 +4673,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 +4773,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);
@@ -4524,7 +4804,15 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         // 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
         // in the model's context.
-        const hotels = answer.hotels.slice(0, MAX_PAGE);
+        // ⚠️ A HOTEL NOT ON SALE HERE SAYS WHERE IT IS (review r2, T5): its page said
+        // the group's own channels, its tile on a list - the answer a model often
+        // stops at - only that nothing was on sale. In the text and the structure.
+        const hotels = answer.hotels.slice(0, MAX_PAGE).map((h) => h.noRoomsForStayCode === 'none-on-sale' && h.noRoomsForStay
+            ? {
+                ...h,
+                noRoomsForStay: `${h.noRoomsForStay.replace(/[.\s]+$/, '')} - it can be booked through ${groupNameOf(deps, h.id)}'s own channels: its app, its website or by phone.`,
+            }
+            : h);
         const offset = asked.offset ?? 0;
         const total = Math.max(answer.total, offset + hotels.length);
         const cities = [...new Set(hotels.map((h) => h.city))];
@@ -4666,8 +4954,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 {
@@ -4693,7 +4984,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             // assistant ask which city to list the rest in (2026-10-15 smoke run).
             // And not "tell me another city": the second run said there was one
             // hotel, then offered to look in another city (2026-10-15).
-            const inAll = `This connector has one ${branded(deps.vocab, deps.vocab.noun)} in all, ${sole.name}${sole.city ? ` in ${sole.city}` : ''}. There is no other hotel and no other city here - nothing else to search for or to offer.`;
+            const inAll = `There is one ${branded(deps.vocab, deps.vocab.noun)} here in all, ${sole.name}${sole.city ? ` in ${sole.city}` : ''}. There is no other hotel and no other city here - nothing else to search for or to offer.`;
             return {
                 ...page,
                 // In both, in the same words: a host may hand its model this rather
@@ -4910,8 +5201,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 here - ${NOT_SOLD_OUT}`
                         : ''}.`
                     : '',
         ].filter(Boolean);
@@ -4925,7 +5220,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         // only "2 hotels", the model asked for the list again to learn which.
         const degraded = degradedOf(deps, answer);
         const inAll = homeList
-            ? `This connector has ${total} ${branded(deps.vocab, deps.vocab.nounPlural)} in all, and this answer lists every one: ${hotels
+            ? `There are ${total} ${branded(deps.vocab, deps.vocab.nounPlural)} here in all, and this answer lists every one: ${hotels
                 .map((h) => `${hotelName(h.name)}${h.city ? ` in ${h.city}` : ''}`)
                 .join('; ')}. There is no other ${deps.vocab.noun} and no other city here - nothing else to list, search for or offer.`
             : '';
@@ -5029,7 +5324,9 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             };
         }
         const h = detail.hotel;
-        const description = hotelText('description', h.name, h.summary, DESCRIPTION_MAX, deps.vocab.demo);
+        const description = hotelText('description', h.name, 
+        // Its 【…】 parts a line each, the words as they came (`aboutLines`).
+        aboutLines(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 = {
@@ -5076,17 +5373,23 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             : [];
         const flex = dateFlex(dates, stay);
         if (detail.noRooms || !detail.rooms) {
+            // ⚠️ NOTHING ON SALE HERE SAYS WHERE TO BOOK IT (T5): the same sentence
+            // in the text and in `noRooms`, which the card does not draw for this code
+            // (it says it in the guest's language from `noRoomsCode`).
+            const said = detail.noRooms && detail.noRoomsCode === 'none-on-sale'
+                ? notOnSaleWords(groupNameOf(deps, h.id), detail.noRooms)
+                : detail.noRooms;
             return {
                 structured: {
                     view: 'no-rooms',
                     ...base,
                     stay,
-                    noRooms: detail.noRooms,
+                    noRooms: said,
                     ...(detail.noRoomsCode ? { noRoomsCode: detail.noRoomsCode } : {}),
                     ...(detail.noRoomsArgs ? { noRoomsArgs: detail.noRoomsArgs } : {}),
                     ...flex.structured,
                 },
-                text: [detail.noRooms ?? 'Nothing is available for those nights.', flex.text]
+                text: [said ?? 'Nothing is available for those nights.', flex.text]
                     .filter(Boolean)
                     .join(' '),
             };
@@ -5254,7 +5557,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 continue;
             const h = detail.hotel;
             read.push({ id: h.id, name: h.name });
-            const about = hotelText('description', h.name, [h.summary, h.amenities.length ? `Has: ${h.amenities.join(', ')}.` : '']
+            const about = hotelText('description', h.name, [aboutLines(h.summary), h.amenities.length ? `Has: ${h.amenities.join(', ')}.` : '']
                 .filter(Boolean)
                 .join('\n'), DESCRIPTION_MAX, deps.vocab.demo);
             const extras = await deps.backend.extrasFor(h.id, stay);
@@ -5409,7 +5712,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             text: extras.length
                 ? extras
                     .map((e) => `- ${e.name}${ctx.noCards ? ` (\`${e.id}\`)` : ''} — ${formatMoney(e.price)} ${unitWords(e.per)}${held[e.id] ? ` (${booked?.confirmationCode} holds ${held[e.id]})` : ''}`)
-                    .concat(deps.vocab.demo ? [noteFor(deps.vocab)] : [])
+                    .concat(deps.vocab.demo && noteFor(deps.vocab) ? [noteFor(deps.vocab)] : [])
                     .join('\n')
                 : `${detail.hotel.name} has no add-ons listed here.`,
         };
@@ -5445,7 +5748,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 +5797,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 +5825,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 +5833,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 +6194,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 +6248,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,25 +6280,25 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
                 fee: formatMoney(charged),
                 rule: preview.rule,
                 cancellable: false,
+                ...(couponNow ? { coupon: couponNow } : {}),
             },
             text: [
                 cancelled.payment
                     ? // Paid here in advance: what becomes of the money is the answer.
                         `${cancelled.confirmationCode} is ${cancelled.status === 'expired' ? 'called off before it was paid' : 'cancelled'}. ${paidLine(deps, cancelled, charged)}`
-                    : h.sandbox
-                        ? // A test booking cancelled in the simulation: no hotel, no charge (2026-10-05 audit, P2).
-                            `${cancelled.confirmationCode} is cancelled in the simulated system. ${charged.minor === 0 ? 'No fee.' : `A real booking on this rate would be charged ${formatMoney(charged)}; this one is a test, and nothing is charged.`}`
-                        : h.test
-                            ? `${cancelled.confirmationCode} is cancelled in ${h.name}'s test system. ${charged.minor === 0 ? 'No fee.' : `A live booking on this rate would be charged ${formatMoney(charged)}; this one is a test, and nothing is charged.`}`
-                            : h.demo
-                                ? // 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.`
-                    : '',
+                    : h.notReal
+                        ? // A market's group: the fact, in no environment's word (robin, 2026-11-03).
+                            `${cancelled.confirmationCode} is cancelled. ${charged.minor === 0 ? 'No fee.' : `A real booking on this rate would be charged ${formatMoney(charged)}; this booking was never sent to ${h.name}, and nothing is charged.`}`
+                        : h.sandbox
+                            ? // A simulated booking cancelled in the simulation: no hotel, no charge (2026-10-05 audit, P2).
+                                `${cancelled.confirmationCode} is cancelled in the simulated system. ${charged.minor === 0 ? 'No fee.' : `A real booking on this rate would be charged ${formatMoney(charged)}; this one is simulated, and nothing is charged.`}`
+                            : h.test
+                                ? `${cancelled.confirmationCode} is cancelled in ${h.name}'s test system. ${charged.minor === 0 ? 'No fee.' : `A live booking on this rate would be charged ${formatMoney(charged)}; this one is a test, and nothing is charged.`}`
+                                : h.demo
+                                    ? // 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)}.`}`,
+                couponNow?.said ?? '',
                 demoBookingNote(deps, cancelled.supplier),
                 deps.vocab.demo ? noteFor(deps.vocab) : '',
             ]
@@ -5982,7 +6322,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 +6335,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 +6392,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 +6421,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 +6483,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 +6508,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) : '',
             ]
@@ -6177,7 +6547,7 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             // would find out at the desk.
             return {
                 structured: { view: 'member-not-found', ...common(deps, key), query: number },
-                text: `No ${deps.vocab.brand} membership matches that number and surname. Check both as they are printed; nothing else is needed - this connector never asks for a password.`,
+                text: `No ${deps.vocab.brand} membership matches that number and surname. Check both as they are printed; nothing else is needed - a password is never asked for here.`,
             };
         }
         deps.members.set(key, member);