@curless/hotel-storefront 0.13.1 → 0.14.0

package/dist/tools.js

@@ -1,4 +1,4 @@
-import { MAX_PAGE, REQUEST_KINDS, REQUEST_NOTE_MAX } from './backend.js';
+import { LASTING_REQUESTS, MAX_PAGE, REQUEST_KINDS, REQUEST_NOTE_MAX } from './backend.js';
 import { isDay, nights as nightsBetween } from './dates.js';
 import { DESCRIPTION_MAX, POLICY_MAX, hotelText } from './fence.js';
 import { formatMoney, money, multiplyMoney, toMinor } from './money.js';
@@ -124,8 +124,11 @@ export const buildTools = (n, v) => {
                 properties: {
                     hotel: { type: 'string', description: `The ${v.noun}'s name or id` },
                     ...stayProps,
+                    booking: {
+                        type: 'string',
+                        description: `A booking's confirmation code. The answer is then that booking's ${v.noun}, its add-ons for those nights and how many of each the booking holds; ${n.previewChange} changes them`,
+                    },
                 },
-                required: ['hotel'],
             },
         },
         {
@@ -195,6 +198,10 @@ export const buildTools = (n, v) => {
                         type: 'string',
                         description: `Anything else for the desk, in the guest's own words, up to ${REQUEST_NOTE_MAX} characters`,
                     },
+                    rememberRequests: {
+                        type: 'boolean',
+                        description: 'True when the guest asked for these room preferences to be remembered for their next stays. Needs a signed-in member; what is kept is the lasting kind - a bed type, a floor, a quiet, connecting or accessible room',
+                    },
                 },
                 required: ['name', 'email'],
             },
@@ -254,7 +261,7 @@ export const buildTools = (n, v) => {
         },
         {
             name: n.previewChange,
-            description: `What moving a booking to other nights, another room type or a different number of rooms would cost: the stay it holds now, the stay it would hold, and the difference between them. The new nights are priced at what those nights cost today, not at the rate the booking was made on. A rate that cannot be moved, a ${v.noun} that has no room left for the new nights and a booking that is already gone are each said in those words. Nothing is changed.`,
+            description: `What moving a booking to other nights, another room type or a different number of rooms - or putting an add-on on it, taking one off or changing how many - would cost: what it holds now, what it would hold, and the difference between them. The new nights are priced at what those nights cost today, not at the rate the booking was made on. A rate that cannot be moved, a ${v.noun} that has no room left for the new nights and a booking that is already gone are each said in those words. Nothing is changed.`,
             annotations: reads('Preview a booking change', open),
             inputSchema: {
                 type: 'object',
@@ -276,6 +283,14 @@ export const buildTools = (n, v) => {
                         type: 'string',
                         description: 'A different room type at the same hotel, by id or name',
                     },
+                    extra: {
+                        type: 'string',
+                        description: `An add-on at this ${v.noun}, by id or name, to put on the booking, take off or change - with \`quantity\``,
+                    },
+                    quantity: {
+                        type: 'number',
+                        description: `How many of that add-on the booking should hold, 0 to ${MAX_EXTRA_QUANTITY}; 0 takes it off`,
+                    },
                     email: {
                         type: 'string',
                         description: 'The email the booking was made with, when it was made elsewhere',
@@ -286,7 +301,7 @@ export const buildTools = (n, v) => {
         },
         {
             name: n.changeBooking,
-            description: 'Moves a booking to other nights, another room type or a different number of rooms. Called without `confirmed` it returns the same preview - the two stays and the difference - and changes nothing; it changes only when `confirmed` is true. The confirmation code stays the same.',
+            description: 'Moves a booking to other nights, another room type or a different number of rooms, or sets one of its add-ons (`extra` and `quantity`; 0 takes it off). Called without `confirmed` it returns the same preview - the two stays and the difference - and changes nothing; it changes only when `confirmed` is true. The confirmation code stays the same.',
             annotations: edits('Change a booking', open),
             inputSchema: {
                 type: 'object',
@@ -308,6 +323,14 @@ export const buildTools = (n, v) => {
                         type: 'string',
                         description: 'A different room type at the same hotel, by id or name',
                     },
+                    extra: {
+                        type: 'string',
+                        description: `An add-on at this ${v.noun}, by id or name, to put on the booking, take off or change - with \`quantity\``,
+                    },
+                    quantity: {
+                        type: 'number',
+                        description: `How many of that add-on the booking should hold, 0 to ${MAX_EXTRA_QUANTITY}; 0 takes it off`,
+                    },
                     email: {
                         type: 'string',
                         description: 'The email the booking was made with, when it was made elsewhere',
@@ -415,6 +438,18 @@ export const buildTools = (n, v) => {
             annotations: edits(`Sign out of ${v.brand}`, open),
             inputSchema: { type: 'object', properties: {} },
         },
+        {
+            name: n.forgetPreferences,
+            description: `Forgets the room preferences saved on the signed-in ${v.brand} membership - a bed type, a floor, a quiet or accessible room. Bookings already made keep what they asked for.`,
+            annotations: {
+                title: 'Forget my saved preferences',
+                readOnlyHint: false,
+                destructiveHint: true,
+                idempotentHint: true,
+                openWorldHint: open,
+            },
+            inputSchema: { type: 'object', properties: {} },
+        },
         {
             name: n.policies,
             description: `What one ${v.noun} publishes about cancellation, check-in and check-out, children and extra beds, pets, deposits and accessibility. With \`topic\` it returns that topic; without, all of them.`,
@@ -666,6 +701,16 @@ export const buildOutputSchemas = (n) => ({
         properties: { view: { const: 'signed-out' }, brand: STR, toolNames: OBJ },
         required: ['view'],
     },
+    [n.forgetPreferences]: {
+        type: 'object',
+        properties: {
+            view: { enum: ['member', 'no-member'] },
+            brand: STR,
+            toolNames: OBJ,
+            member: OBJ,
+        },
+        required: ['view'],
+    },
     [n.policies]: {
         type: 'object',
         properties: {
@@ -705,9 +750,19 @@ const asStay = (args) => {
  */
 const memberBadge = (deps, key) => {
     const m = deps.members.read(key);
+    // ⚠️ `signedIn` ON EVERY ANSWER, false included. The card cleared its tier
+    // chip only on the sign-out view, so after signing out in the chat - or a
+    // sign-in that lapsed - older cards kept "Gold · 5% off" over public prices.
     return m
-        ? { member: { programme: m.programme, tier: { name: m.tier.name, discount: m.tier.discount } } }
-        : {};
+        ? {
+            signedIn: true,
+            member: {
+                programme: m.programme,
+                tier: { name: m.tier.name, discount: m.tier.discount },
+                ...(m.preferences?.length ? { preferences: m.preferences } : {}),
+            },
+        }
+        : { signedIn: false };
 };
 const common = (deps, key) => ({
     brand: deps.vocab.brand,
@@ -912,6 +967,26 @@ const widen = (ask) => {
     }
     return undefined;
 };
+/** What a change would do, in one sentence - the nights, and the add-on when it sets one. */
+const changeSentence = (p) => {
+    const moves = !!p.to &&
+        (p.to.stay.checkIn !== p.from.stay.checkIn ||
+            p.to.stay.checkOut !== p.from.stay.checkOut ||
+            p.to.rooms !== p.from.rooms ||
+            p.to.roomName !== p.from.roomName);
+    const a = p.addOn;
+    const addOn = !a
+        ? ''
+        : a.to === 0
+            ? `take ${a.name} off`
+            : a.from === 0
+                ? `add ${a.to}× ${a.name}`
+                : `change ${a.name} from ${a.from} to ${a.to}`;
+    const nights = moves
+        ? `move to ${p.to?.stay.checkIn} - ${p.to?.stay.checkOut}${p.to && p.to.rooms > 1 ? `, ${p.to.rooms} rooms` : ''}`
+        : '';
+    return `${p.confirmationCode} would ${[nights, addOn].filter(Boolean).join(' and ')}.`;
+};
 /**
  * How much of a plan is real, in the one sentence the model is told to repeat:
  * what is booked, what is in the trip, and that the rest is only a plan.
@@ -1030,35 +1105,130 @@ const identity = (deps, ctx, key, args = {}) => {
     };
 };
 /**
- * Why this hotel cannot join the trip that is already there - or null.
+ * The trip priced one currency at a time, in the order the currencies first
+ * appear in it.
  *
- * One trip, one currency. Not a limitation to route around: converting HKD to
- * CNY means picking a rate, and a rate we picked is a number the guest would
- * read off a card as if the hotel had said it.
+ * ⚠️ TWO CURRENCIES ARE TWO TOTALS (robin, 2026-09-28: 「4 ok」). A Hong Kong -
+ * Shanghai trip used to be refused at the second hotel, because one total would
+ * have needed an exchange rate and a rate we picked is a number a guest would
+ * read as the hotel's. Now it is two quotes, drawn side by side and never
+ * added up; each hotel is booked, and paid, in its own.
  */
-const currencyClash = async (deps, key, hotel) => {
-    const lines = deps.trips.read(key);
-    if (lines.length === 0)
-        return null;
-    const theirs = hotel.fromNightly?.currency;
-    if (!theirs)
-        return null;
-    const quote = await deps.backend.quote({ lines });
-    const ours = quote.lines.length ? quote.total.currency : undefined;
-    if (!ours || ours === theirs)
-        return null;
-    return `This trip is priced in ${ours} and ${hotel.name} charges in ${theirs}. No exchange rate is invented here, so one trip is one currency: request this trip first - a booked trip is empty again - and then put ${hotel.name} in it, or clear this one.`;
+const quoteParts = async (deps, lines, who) => {
+    const byCurrency = new Map();
+    for (const l of lines) {
+        const c = (await deps.backend.getHotel(l.hotelId))?.hotel.currency ?? '';
+        byCurrency.set(c, [...(byCurrency.get(c) ?? []), l]);
+    }
+    if (byCurrency.size === 0)
+        return [await deps.backend.quote({ lines: [] }, who)];
+    return Promise.all([...byCurrency.values()].map((g) => deps.backend.quote({ lines: g }, who)));
 };
 /** The trip, priced, as both views need it. */
 const currentTrip = async (deps, key, who) => {
     const lines = deps.trips.read(key);
-    const quote = await deps.backend.quote({ lines }, who);
+    const parts = await quoteParts(deps, lines, who);
+    const [only] = parts;
+    if (parts.length === 1 && only) {
+        return {
+            structured: {
+                view: 'trip',
+                ...common(deps, key),
+                ...quoteForCard(only),
+                count: lines.length,
+            },
+            text: tripText(only, deps.vocab.demo),
+        };
+    }
+    const shaped = parts.map(quoteForCard);
     return {
-        structured: { view: 'trip', ...common(deps, key), ...quoteForCard(quote), count: lines.length },
-        text: tripText(quote, deps.vocab.demo),
+        structured: {
+            view: 'trip',
+            ...common(deps, key),
+            lines: shaped.flatMap((p) => p.lines),
+            // One block per currency, each with its own taxes and total. `total` is
+            // the totals side by side for anything that reads one string - a list,
+            // never a sum.
+            groups: shaped.map((p, i) => ({ ...p, currency: parts[i]?.total.currency })),
+            currencies: parts.map((p) => p.total.currency),
+            total: shaped.map((p) => p.total).join(' + '),
+            ...(shaped.some((p) => p.dropped) ? { dropped: shaped.flatMap((p) => p.dropped ?? []) } : {}),
+            count: lines.length,
+        },
+        text: [
+            `This trip is in ${parts.length} currencies, priced separately and not converted - each hotel is booked and paid in its own.`,
+            ...parts.map((q) => tripText(q, false)),
+            deps.vocab.demo ? DEMO_NOTE : '',
+        ]
+            .filter(Boolean)
+            .join('\n\n'),
     };
 };
+/**
+ * What the guest might say next, as a few chips under the card.
+ *
+ * ⚠️ WRITTEN HERE, FROM WHAT IS ON SCREEN - not by the model. Each is a
+ * sentence the GUEST would say, sent to the chat as theirs when pressed, so
+ * it names what it is about ("the cancellation policy at the Island
+ * Shangri-La") rather than pointing at the screen: the same words have to make
+ * sense in a transcript. Only what this answer can actually lead to - no
+ * "compare" beside a city with one hotel, no transfer beside a booking that
+ * has one - and three at most, so they read as a hint and not a menu
+ * (robin, 2026-09-28: 「建议按钮」).
+ */
+const suggestionsFor = async (deps, d) => {
+    const view = String(d.view ?? '');
+    const out = [];
+    const hotel = d.hotel;
+    if (view === 'hotel' && hotel && Array.isArray(d.rooms) && d.rooms.length) {
+        if ((await deps.backend.extrasFor(hotel.id)).length)
+            out.push(`What add-ons does ${hotel.name} offer?`);
+        out.push(`What is the cancellation policy at ${hotel.name}?`);
+        const nearby = await deps.backend.searchHotels({ city: hotel.city, limit: 2 });
+        if (nearby.total > 1)
+            out.push(`Compare ${hotel.name} with the other ${hotel.city} hotels`);
+    }
+    // Not across currencies: that sort is refused there (see `sort`), and a chip
+    // for it would ask for something the next answer says it will not do.
+    if (view === 'hotels' &&
+        Array.isArray(d.hotels) &&
+        d.hotels.length > 1 &&
+        d.sort !== 'price-low' &&
+        !d.currencies)
+        out.push('Show the cheapest first');
+    if (view === 'comparison') {
+        const pick = (d.columns ?? []).find((c) => c.recommended);
+        if (pick) {
+            out.push(`Show me the rooms at ${pick.hotel.name}`);
+            out.push(`Plan the days at ${pick.hotel.name}`);
+        }
+    }
+    if (view === 'itinerary' && Number(d.planned) > Number(d.inTrip) + Number(d.booked ?? 0))
+        out.push('Put the stays on this plan in the trip');
+    if (view === 'booking') {
+        const all = (Array.isArray(d.bookings) ? d.bookings : [d.booking]);
+        for (const b of all.slice(0, 2)) {
+            if (!b?.hotelId)
+                continue;
+            const transfer = (await deps.backend.extrasFor(b.hotelId, b.stay)).find((e) => e.kind === 'transfer');
+            const has = b.quote?.lines?.some((l) => l.extraRef === transfer?.id);
+            if (transfer && !has)
+                out.push(`Add ${transfer.name.toLowerCase()} to ${b.confirmationCode}`);
+        }
+        const first = all[0];
+        if (first?.hotelName)
+            out.push(`What time is check-in at ${first.hotelName}?`);
+    }
+    return out.slice(0, 3);
+};
 export const handleTool = async (deps, name, rawArgs, ctx) => {
+    const answer = await answerTool(deps, name, rawArgs, ctx);
+    const suggestions = await suggestionsFor(deps, answer.structured).catch(() => []);
+    return suggestions.length
+        ? { ...answer, structured: { ...answer.structured, suggestions } }
+        : answer;
+};
+const answerTool = async (deps, name, rawArgs, ctx) => {
     const args = (rawArgs ?? {});
     const t = deps.tools;
     const key = ctx.tripKey ?? tripKey(ctx.session, deps.vocab.brand);
@@ -1324,7 +1494,22 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
         };
     }
     if (name === t.listExtras) {
-        const wanted = str(args.hotel);
+        // ⚠️ AN ADD-ON FOR A BOOKING ALREADY MADE (robin, 2026-09-28). Add-ons
+        // could only go in the trip before the request; once booked, an airport
+        // transfer had nowhere to go. Asked with a booking, this lists that
+        // hotel's add-ons for that booking's nights, with what it already holds.
+        const code = str(args.booking);
+        const booked = code
+            ? (await deps.backend.listBookings(identity(deps, ctx, key, args), 50)).find((b) => (b.confirmationCode === code || b.id === code) &&
+                (b.status === 'requested' || b.status === 'confirmed'))
+            : undefined;
+        if (code && !booked) {
+            return {
+                structured: { view: 'booking-not-found', ...common(deps, key), query: code },
+                text: 'No booking here matches that code. A booking made in another conversation needs the email it was made with.',
+            };
+        }
+        const wanted = booked ? booked.hotelId : str(args.hotel);
         const detail = await deps.backend.getHotel(wanted);
         if (!detail) {
             return {
@@ -1332,12 +1517,22 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
                 text: `No ${deps.vocab.brand} ${deps.vocab.noun} by that name.`,
             };
         }
-        const extras = await deps.backend.extrasFor(detail.hotel.id, asStay(args));
+        const extras = await deps.backend.extrasFor(detail.hotel.id, booked?.stay ?? asStay(args));
+        const held = Object.fromEntries((booked?.quote.lines ?? []).flatMap((l) => l.kind === 'extra' && l.extraRef ? [[l.extraRef, l.ordered ?? l.quantity ?? 1]] : []));
         return {
             structured: {
                 view: 'extras',
                 ...common(deps, key),
                 hotel: detail.hotel,
+                ...(booked
+                    ? {
+                        forBooking: {
+                            confirmationCode: booked.confirmationCode,
+                            stay: booked.stay,
+                            held,
+                        },
+                    }
+                    : {}),
                 extras: extras.map((e) => ({
                     ...e,
                     description: hotelText('add-on', detail.hotel.name, e.description, DESCRIPTION_MAX).text,
@@ -1346,7 +1541,7 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
             },
             text: extras.length
                 ? extras
-                    .map((e) => `- ${e.name} — ${formatMoney(e.price)} per ${e.per}`)
+                    .map((e) => `- ${e.name} — ${formatMoney(e.price)} per ${e.per}${held[e.id] ? ` (${booked?.confirmationCode} holds ${held[e.id]})` : ''}`)
                     .concat(deps.vocab.demo ? [DEMO_NOTE] : [])
                     .join('\n')
                 : `${detail.hotel.name} has no add-ons listed here.`,
@@ -1382,18 +1577,6 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
                     text: `${detail.hotel.name} does not offer that. ${t.listExtras} lists what it has.`,
                 };
             }
-            const clash = await currencyClash(deps, key, detail.hotel);
-            if (clash) {
-                return {
-                    structured: {
-                        view: 'error',
-                        ...common(deps, key),
-                        error: 'mixed-currency',
-                        detail: clash,
-                    },
-                    text: clash,
-                };
-            }
             const line = {
                 kind: 'extra',
                 hotelId,
@@ -1455,24 +1638,6 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
                 text: `${detail.hotel.name} has no room type by that name for those nights. It has: ${dated.rooms.map((r) => r.name).join(', ')}.`,
             };
         }
-        // ⚠️ A LINE THAT WILL NEVER PRICE DOES NOT GO IN. The quote drops a hotel
-        // billing in another currency - no exchange rate is invented here - but
-        // until now the line still went into the trip, so the guest carried
-        // something that was silently dropped from every total from then on
-        // (2026-09-18). Refused here, with the trip left exactly as it was; the
-        // quote's own drop stays as the backstop for a hotel whose currency moves.
-        const wrongCurrency = await currencyClash(deps, key, detail.hotel);
-        if (wrongCurrency) {
-            return {
-                structured: {
-                    view: 'error',
-                    ...common(deps, key),
-                    error: 'mixed-currency',
-                    detail: wrongCurrency,
-                },
-                text: wrongCurrency,
-            };
-        }
         deps.trips.set(key, {
             kind: 'room',
             hotelId,
@@ -1524,6 +1689,33 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
             // because a booking is found by the address it was made with.
             { ...identity(deps, ctx, key), email: guest.email }, requests);
             deps.trips.clear(key);
+            // ⚠️ REMEMBERED ONLY WHEN ASKED - see `rememberPreferences`. Said either
+            // way, so neither the guest nor the model assumes something was kept.
+            const signedIn = deps.members.read(key);
+            let remembered;
+            if (args.rememberRequests === true) {
+                const lasting = (requests?.kinds ?? []).filter((k) => LASTING_REQUESTS.includes(k));
+                if (!signedIn) {
+                    remembered = {
+                        kept: [],
+                        line: 'Nothing was remembered: saved preferences belong to a membership, and nobody is signed in.',
+                    };
+                }
+                else if (!lasting.length) {
+                    remembered = {
+                        kept: signedIn.preferences ?? [],
+                        line: 'Nothing new was remembered: an early check-in, a late arrival and a note are for one stay, not every stay.',
+                    };
+                }
+                else {
+                    const kept = await deps.backend.rememberPreferences(signedIn, lasting);
+                    deps.members.set(key, { ...signedIn, preferences: kept });
+                    remembered = {
+                        kept,
+                        line: `Remembered on this ${signedIn.programme} membership for next time: ${kept.map((k) => REQUEST_WORDS[k]).join(', ')}. ${t.forgetPreferences} forgets them.`,
+                    };
+                }
+            }
             // The hotel's own check-in hour, so an early-check-in request is answered
             // with the time it is early against - London opens at 16:00 and Hong Kong
             // at 15:00, and a generic "check-in is in the afternoon" is not an answer.
@@ -1558,6 +1750,7 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
                         }
                         : {}),
                     paid: false,
+                    ...(remembered ? { remembered: remembered.kept } : {}),
                     holdUntil: first.booking.holdUntil,
                     total: formatMoney(first.booking.quote.total),
                     ...(first.asked.length ? { requested: first.asked } : {}),
@@ -1574,6 +1767,7 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
                         `${formatMoney(booking.quote.total)} all in. **Nothing has been charged** - the rooms are held until ${booking.holdUntil?.slice(0, 16).replace('T', ' ')} UTC, and ${booking.guest.name} presents a card at check-in.`,
                         ...asked,
                     ]),
+                    remembered?.line ?? '',
                     deps.vocab.demo ? DEMO_NOTE : '',
                 ]
                     .filter(Boolean)
@@ -1614,6 +1808,8 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
             ...(str(args.checkOut) ? { checkOut: str(args.checkOut) } : {}),
             ...(typeof args.rooms === 'number' ? { rooms: args.rooms } : {}),
             ...(str(args.room) ? { room: str(args.room) } : {}),
+            ...(str(args.extra) ? { extra: str(args.extra) } : {}),
+            ...(typeof args.quantity === 'number' ? { quantity: args.quantity } : {}),
         };
         const preview = await deps.backend.previewChange(ref, change, who);
         if (!preview) {
@@ -1647,12 +1843,13 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
                 ...(diff ? { difference: diff, refundDue } : {}),
                 changeable: preview.changeable,
                 ...(preview.roomsLeft === undefined ? {} : { roomsLeft: preview.roomsLeft }),
+                ...(preview.addOn ? { addOn: preview.addOn } : {}),
                 rule: preview.rule,
                 toolToConfirm: t.changeBooking,
             },
             text: preview.changeable
                 ? [
-                    `${preview.confirmationCode} would move to ${preview.to?.stay.checkIn} - ${preview.to?.stay.checkOut}${preview.to && preview.to.rooms > 1 ? `, ${preview.to.rooms} rooms` : ''}.`,
+                    changeSentence(preview),
                     diff && preview.difference?.minor !== 0
                         ? refundDue
                             ? `That is ${diff} less than it holds now.`
@@ -1683,6 +1880,7 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
                     from: stayOf(preview.from),
                     ...(preview.to ? { to: stayOf(preview.to) } : {}),
                     ...(diff ? { difference: diff, refundDue } : {}),
+                    ...(preview.addOn ? { addOn: preview.addOn } : {}),
                     changeable: false,
                     rule: preview.rule,
                 },
@@ -1856,6 +2054,9 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
             text: [
                 `Signed in as ${member.name} · ${member.programme} ${member.tier.name} · ${member.points.toLocaleString('en-GB')} points.`,
                 `Rates now show the ${member.tier.name} member rate, ${Math.round(member.tier.discount * 100)}% off the public one.`,
+                member.preferences?.length
+                    ? `Saved preferences on this membership: ${member.preferences.map((k) => REQUEST_WORDS[k]).join(', ')}. They are ticked on the booking form; mention them, and ask before booking with them.`
+                    : '',
                 deps.vocab.demo ? DEMO_NOTE : '',
             ]
                 .filter(Boolean)
@@ -1872,6 +2073,22 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
                 : 'Nobody was signed in.',
         };
     }
+    if (name === t.forgetPreferences) {
+        const m = deps.members.read(key);
+        if (!m) {
+            return {
+                structured: { view: 'no-member', ...common(deps, key) },
+                text: `Nobody is signed in, so there is nothing saved to forget. ${t.signIn} signs a member in.`,
+            };
+        }
+        await deps.backend.rememberPreferences(m, []);
+        const { preferences: _gone, ...member } = m;
+        deps.members.set(key, member);
+        return {
+            structured: { view: 'member', ...common(deps, key), member },
+            text: `Forgot the room preferences saved on ${m.programme} ${m.tier.name}. Bookings already made keep what they asked for.`,
+        };
+    }
     if (name === t.policies) {
         const wanted = str(args.hotel);
         const detail = await deps.backend.getHotel(wanted);