@curless/hotel-storefront 0.47.2 → 0.47.4

package/dist/tools.js

@@ -8,7 +8,7 @@ import { namedExactly, roomNamesOf, withTraditional } from './names.js';
 import { MAX_COMPARED, MAX_CONS, MAX_DAYS, MAX_ITEMS_PER_DAY, MAX_MOMENTS, MAX_PROS, buildItinerary, candidatesFor, compareHotels, namesMoreThanOne, } from './present.js';
 import { regionOf } from './regions.js';
 import { activeKeysOf, byRoomType, facetsOf, keyWords, matchesTerms, optionsOf, roomTermsOf, termWords, } from './room-filters.js';
-import { MAX_EXTRA_QUANTITY, MAX_ROOMS_PER_LINE, clampCount, shownOf, tripKey, } from './trip.js';
+import { MAX_EXTRA_QUANTITY, MAX_ROOMS_PER_LINE, clampCount, pickedKey, shownOf, tripKey, } from './trip.js';
 import { DEMO_NOTE, branded, catalogue, noteFor, upFirst } from './vocab.js';
 // The eleven things a guest can do: find hotels, look at one on dates, see what
 // else it offers, build a trip, ask for the rooms, and deal with a booking they
@@ -182,7 +182,7 @@ const forCapabilities = (tools, n, v, caps) => {
                         },
                     }),
                 };
-            if (t.name === n.addToTrip)
+            if (t.name === n.addToTrip || t.name === n.pickRoom)
                 out = {
                     ...out,
                     inputSchema: withProps(out.inputSchema, {
@@ -194,7 +194,10 @@ const forCapabilities = (tools, n, v, caps) => {
                     }),
                 };
         }
-        if (t.name === n.requestBooking) {
+        // ⚠️ THE PICKED ROOM'S BOOKING TAKES THE SAME GUEST FIELDS as the trip's:
+        // a phone where the hotel needs one, and no `rememberRequests` without
+        // members. Its description is its own (below, only request_booking's).
+        if (t.name === n.requestBooking || t.name === n.bookPicked) {
             if (caps.requiresPhone) {
                 const schema = out.inputSchema;
                 out = {
@@ -223,7 +226,7 @@ const forCapabilities = (tools, n, v, caps) => {
             if (!caps.members)
                 out = { ...out, inputSchema: without(out.inputSchema, 'rememberRequests') };
             // A market's suppliers book differently - its own description says so.
-            if (caps.booking === 'pay-at-hotel' && !v.market) {
+            if (t.name === n.requestBooking && caps.booking === 'pay-at-hotel' && !v.market) {
                 out = {
                     ...out,
                     // ⚠️ A SANDBOX BOOKS NOTHING REAL, and its description says so
@@ -257,6 +260,33 @@ const allTools = (n, v) => {
             description: 'People in the room. Default 2',
         },
     };
+    // The guest and what they ask of the desk: the fields of a booking, whether
+    // the rooms come from the trip (request_booking) or from the picked room.
+    const guestProps = {
+        name: {
+            type: 'string',
+            description: "The guest's full name, as it should appear on the booking",
+        },
+        email: { type: 'string', description: 'The email the confirmation goes to' },
+        phone: { type: 'string', description: 'Optional' },
+        requests: {
+            type: 'array',
+            items: { type: 'string', enum: REQUEST_KINDS },
+            description: 'Preferences the desk tries to meet on the day. None of them is held; the answer says so',
+        },
+        arrivingAt: {
+            type: 'string',
+            description: "What time the guest reaches the hotel, `HH:MM` on the hotel's own clock. A time counts as a late arrival on its own",
+        },
+        notes: {
+            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 or connecting room; an accessible room is asked for on each stay and is not kept',
+        },
+    };
     return [
         {
             name: n.listHotels,
@@ -499,29 +529,7 @@ const allTools = (n, v) => {
             inputSchema: {
                 type: 'object',
                 properties: {
-                    name: {
-                        type: 'string',
-                        description: "The guest's full name, as it should appear on the booking",
-                    },
-                    email: { type: 'string', description: 'The email the confirmation goes to' },
-                    phone: { type: 'string', description: 'Optional' },
-                    requests: {
-                        type: 'array',
-                        items: { type: 'string', enum: REQUEST_KINDS },
-                        description: 'Preferences the desk tries to meet on the day. None of them is held; the answer says so',
-                    },
-                    arrivingAt: {
-                        type: 'string',
-                        description: "What time the guest reaches the hotel, `HH:MM` on the hotel's own clock. A time counts as a late arrival on its own",
-                    },
-                    notes: {
-                        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 or connecting room; an accessible room is asked for on each stay and is not kept',
-                    },
+                    ...guestProps,
                     // A booking is made with one group at a time; a trip holding two
                     // groups' hotels is booked group by group (Marketplace, §6-1).
                     ...(v.market
@@ -853,6 +861,47 @@ const allTools = (n, v) => {
                 required: ['booking', 'email'],
             },
         },
+        {
+            // ⚠️ THE CARD'S, NEVER THE MODEL'S (`ui.visibility: ['app']`, server.ts):
+            // the press on Reserve. The picked room is a slot of its own beside the
+            // trip (`pickedKey`) - this never reads or writes the trip.
+            name: n.pickRoom,
+            description: "The card's own step when the guest presses Reserve on one rate: the one room being booked, replacing whatever was picked before. It does not touch the trip, which holds the stays an assistant arranges.",
+            annotations: edits(`Pick a ${v.brand} room`, open),
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    hotel: { type: 'string', description: `The ${v.noun}'s name or id` },
+                    room: {
+                        type: 'string',
+                        description: 'The room type id or name, as the hotel returned it',
+                    },
+                    ...stayProps,
+                    rooms: {
+                        type: 'integer',
+                        minimum: 0,
+                        maximum: MAX_ROOMS_PER_LINE,
+                        description: `How many of that room type, 1 to ${MAX_ROOMS_PER_LINE}. Default 1; 0 empties the pick`,
+                    },
+                },
+                required: ['hotel', 'room'],
+            },
+        },
+        {
+            // ⚠️ THE CARD'S, NEVER THE MODEL'S - the booking form's submit for the
+            // picked room. The same booking as request_booking's; only where the
+            // room comes from differs (`bookTripLines`).
+            name: n.bookPicked,
+            description: "The card's own step when the guest submits the booking form for the room they picked with Reserve: books that one room for the named guest, the way a trip's rooms are booked. Leaves the trip as it is.",
+            annotations: books(v.market ? `Book the picked room on ${v.brand}` : `Book the picked ${v.brand} room`, open),
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    ...guestProps,
+                },
+                required: ['name', 'email'],
+            },
+        },
     ];
 };
 // The shape of each tool's `structuredContent`, so a reader knows what it is
@@ -1082,6 +1131,43 @@ const HOTEL_PAGE = {
      */
     soldOut: ARR,
 };
+/**
+ * What request_booking answers - and book_picked_room, which books the same way
+ * from the picked room (`direct`, below).
+ */
+const BOOKING_SCHEMA = {
+    type: 'object',
+    properties: {
+        // `trip`: nothing was booked and the trip is shown again - its price
+        // moved, or (in a market) it holds two groups' stays.
+        view: { enum: ['booking', 'needs-guest', 'empty-trip', 'error', 'trip'] },
+        brand: STR,
+        toolNames: OBJ,
+        bookingMode: STR,
+        demo: BOOL,
+        demoNote: STR,
+        booking: OBJ,
+        /** Always false here: this connector holds rooms and takes no money. */
+        paid: BOOL,
+        holdUntil: STR,
+        total: STR,
+        /** Each preference written out as what it is - something asked for, not held. */
+        requested: ARR,
+        /** An accessible room was asked for, which this booking does not reserve. */
+        accessibility: BOOL,
+        /** One per stay, when the trip held several. */
+        bookings: ARR,
+        /** What all of `bookings` come to, where they are in one currency (the card's first screen). */
+        totalAll: STR,
+        /**
+         * The stays that could not be booked when the others were - each with
+         * why, still in the trip, and what could be booked instead (robin,
+         * 2026-10-14).
+         */
+        failed: ARR,
+    },
+    required: ['view'],
+};
 export const buildOutputSchemas = (n) => ({
     [n.listHotels]: {
         type: 'object',
@@ -1176,38 +1262,16 @@ export const buildOutputSchemas = (n) => ({
     [n.addToTrip]: TRIP_SCHEMA,
     [n.viewTrip]: TRIP_SCHEMA,
     [n.clearTrip]: TRIP_SCHEMA,
-    [n.requestBooking]: {
-        type: 'object',
-        properties: {
-            // `trip`: nothing was booked and the trip is shown again - its price
-            // moved, or (in a market) it holds two groups' stays.
-            view: { enum: ['booking', 'needs-guest', 'empty-trip', 'error', 'trip'] },
-            brand: STR,
-            toolNames: OBJ,
-            bookingMode: STR,
-            demo: BOOL,
-            demoNote: STR,
-            booking: OBJ,
-            /** Always false here: this connector holds rooms and takes no money. */
-            paid: BOOL,
-            holdUntil: STR,
-            total: STR,
-            /** Each preference written out as what it is - something asked for, not held. */
-            requested: ARR,
-            /** An accessible room was asked for, which this booking does not reserve. */
-            accessibility: BOOL,
-            /** One per stay, when the trip held several. */
-            bookings: ARR,
-            /** What all of `bookings` come to, where they are in one currency (the card's first screen). */
-            totalAll: STR,
-            /**
-             * The stays that could not be booked when the others were - each with
-             * why, still in the trip, and what could be booked instead (robin,
-             * 2026-10-14).
-             */
-            failed: ARR,
-        },
-        required: ['view'],
+    [n.requestBooking]: BOOKING_SCHEMA,
+    // The card's own steps for ONE picked room (`pickedKey`): the same answers as
+    // the trip's, each saying `direct` - the pick, not the trip.
+    [n.pickRoom]: {
+        ...TRIP_SCHEMA,
+        properties: { ...TRIP_SCHEMA.properties, direct: BOOL },
+    },
+    [n.bookPicked]: {
+        ...BOOKING_SCHEMA,
+        properties: { ...BOOKING_SCHEMA.properties, direct: BOOL },
     },
     [n.listBookings]: {
         type: 'object',
@@ -2391,7 +2455,10 @@ const countProblem = (t, name, args) => {
     };
     // 0 means something here: take the line out of the trip, or - on a change -
     // the backend's own "a booking keeps at least one room; cancel it instead".
-    const removes = name === t.addToTrip || name === t.previewChange || name === t.changeBooking;
+    const removes = name === t.addToTrip ||
+        name === t.pickRoom ||
+        name === t.previewChange ||
+        name === t.changeBooking;
     return (check('guests', 1, MAX_GUESTS) ??
         check('rooms', removes ? 0 : 1, MAX_ROOMS_PER_LINE) ??
         check('quantity', 0, MAX_EXTRA_QUANTITY));
@@ -2503,14 +2570,19 @@ const needsRoomIn = (t, lines, parts) => {
             .join('\n'),
     };
 };
-const currentTrip = async (deps, key, who) => {
-    const lines = deps.trips.read(key);
+/**
+ * The lines in one slot of the trip store, priced - the trip itself, or (with
+ * `store`) the picked room's slot. `key` stays the conversation's trip key: it
+ * is the one `common` reads, so a header's trip count never counts a pick.
+ */
+const currentTrip = async (deps, key, who, store = key) => {
+    const lines = deps.trips.read(store);
     const parts = await quoteParts(deps, lines, who);
     // ⚠️ WHAT THE GUEST IS SHOWN IS WHAT IS BOOKED - see `ShownQuote`. Every
     // priced trip answer goes through here: add_to_trip, view_trip, and the
     // card's own trip view.
     if (lines.length)
-        deps.trips.show(key, shownOf(parts));
+        deps.trips.show(store, shownOf(parts));
     const [only] = parts;
     const orphans = needsRoomIn(deps.tools, lines, parts);
     const needs = orphans.needsRoom.length ? { needsRoom: orphans.needsRoom } : {};
@@ -2853,6 +2925,497 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
 const fitsManyOf = (deps, dropped) => dropped.flatMap((d) => d.candidates?.length
     ? [`"${d.name}" ${namesMoreThanOne(d.candidates, branded(deps.vocab, deps.vocab.noun))}`]
     : []);
+/** The hotel a call named - or the answer that says there is none, or several by that name. */
+const hotelNamed = async (deps, key, wanted) => {
+    const detail = await deps.backend.getHotel(wanted);
+    if (detail)
+        return { detail };
+    const candidates = candidatesFor(deps.backend, wanted);
+    return {
+        answer: {
+            structured: {
+                view: 'error',
+                ...common(deps, key),
+                error: 'hotel-not-found',
+                query: wanted,
+                ...(candidates.length ? { candidates } : {}),
+            },
+            text: candidates.length
+                ? `"${wanted}" ${namesMoreThanOne(candidates, branded(deps.vocab, deps.vocab.noun))}`
+                : `No ${branded(deps.vocab, deps.vocab.noun)} by that name.`,
+        },
+    };
+};
+/** An answer of the card's own pick: it says so, so the card knows it never touched the trip. */
+const direct = (a) => ({
+    ...a,
+    structured: { ...a.structured, direct: true },
+});
+/**
+ * A room line, validated and priced against the hotel's calendar and put into
+ * one slot of the trip store - THE ONE ROOM-LINE CODE, for `add_to_trip` (`store`
+ * the trip's own key) and for the card's pick (`pick_room`, `store` its
+ * `pickedKey`). `key` is the conversation's trip key and keeps everything else:
+ * the member the price is worked out for, and every answer's `common`.
+ */
+const putRoomLine = async (deps, t, ctx, key, store, args, detail) => {
+    const hotelId = detail.hotel.id;
+    const roomRef = str(args.room);
+    if (!roomRef) {
+        return {
+            structured: { view: 'error', ...common(deps, key), error: 'no-room-named' },
+            text: `Say which room type, or which add-on. ${t.getHotel} with the dates lists the room types.`,
+        };
+    }
+    // A room by the hour: today, from the start the guest gave - checked here,
+    // against the starts the room takes, and never moved to fit (总线程,
+    // 2026-10-12).
+    const who = identity(deps, ctx, key);
+    const startTime = str(args.startTime);
+    const today = (startTime || !asStay(args)
+        ? deps.backend.hourlyRooms?.(hotelId, guestsOf(args), who)
+        : undefined);
+    const byTheHour = async () => {
+        const sold = ((await today)?.rooms ?? []).filter((r) => r.hourly);
+        return sold.find((r) => r.id === roomRef) ?? namedExactly(sold, roomRef);
+    };
+    if (startTime && deps.backend.hourlyRooms) {
+        const hourlyRoom = await byTheHour();
+        if (!hourlyRoom?.hourly) {
+            const sold = ((await today)?.rooms ?? []).filter((r) => r.hourly);
+            return {
+                structured: {
+                    view: 'error',
+                    ...common(deps, key),
+                    error: 'no-such-room',
+                    query: roomRef,
+                    rooms: sold.map((r) => ({
+                        id: r.id,
+                        name: r.name,
+                        ...(r.names ? { names: r.names } : {}),
+                    })),
+                },
+                text: sold.length
+                    ? `${detail.hotel.name} has no room by the hour by that name today. It has: ${sold.map((r) => `${r.name} (\`${r.id}\`, ${windowWords(r.hourly)})`).join('; ')}.`
+                    : ((await today)?.noRooms ?? `${detail.hotel.name} has no rooms by the hour today.`),
+            };
+        }
+        const bad = startProblem(hourlyRoom.hourly, startTime);
+        if (bad) {
+            return {
+                structured: {
+                    view: 'error',
+                    ...common(deps, key),
+                    error: 'start-time',
+                    query: startTime,
+                    // The starts it does take. Not `hourly`: that is the flag above.
+                    window: hourlyRoom.hourly,
+                },
+                text: bad,
+            };
+        }
+        deps.trips.set(store, {
+            kind: 'room',
+            hotelId,
+            roomId: hourlyRoom.id,
+            stay: {
+                checkIn: hourlyRoom.hourly.date,
+                checkOut: hourlyRoom.hourly.date,
+                guests: guestsOf(args),
+            },
+            rooms: clampCount(args.rooms ?? 1, MAX_ROOMS_PER_LINE),
+            hourly: {
+                start: clockOf(minutesOf(startTime)),
+                hours: hourlyRoom.hourly.hours,
+            },
+        });
+        return currentTrip(deps, key, who, store);
+    }
+    const stay = asStay(args);
+    // ⚠️ NO DATES, NO LINE. Guessing "tonight" or "this weekend" here is how a
+    // connector books someone the wrong nights, and the guest finds out at the
+    // desk. The trip stays as it was and the answer asks.
+    if (!stay) {
+        const hourlyRoom = await byTheHour();
+        return {
+            structured: {
+                view: 'needs-dates',
+                ...common(deps, key),
+                hotel: detail.hotel,
+                room: roomRef,
+                ...(hourlyRoom?.hourly ? { window: hourlyRoom.hourly } : {}),
+            },
+            text: hourlyRoom?.hourly
+                ? `That is a room by the hour, sold for today: it takes \`startTime\` - ${windowWords(hourlyRoom.hourly)}.`
+                : 'Which nights? A room needs a check-in and a check-out date before it can go into the trip.',
+        };
+    }
+    // ⚠️ TAKING A ROOM OUT NEEDS NO ROOM FOR SALE. The lookup below is of
+    // what is for sale, so a room that had gone since it went into the trip -
+    // the stay a booking could not make - could not be taken out of it
+    // (2026-10-14). The line in the trip is the one asked about.
+    if (args.rooms !== undefined && clampCount(args.rooms, MAX_ROOMS_PER_LINE) === 0) {
+        const held = deps.trips
+            .read(store)
+            .find((l) => l.kind === 'room' &&
+            l.hotelId === hotelId &&
+            l.roomId === roomRef &&
+            l.stay.checkIn === stay.checkIn &&
+            l.stay.checkOut === stay.checkOut);
+        if (held) {
+            deps.trips.set(store, unset(held));
+            return currentTrip(deps, key, identity(deps, ctx, key), store);
+        }
+    }
+    // The backend owns the calendar - it knows each hotel's own timezone, and a
+    // second opinion computed from this process's clock would disagree with it
+    // for eight hours a day.
+    const dated = await deps.backend.getHotel(hotelId, stay, identity(deps, ctx, key));
+    if (!dated?.rooms) {
+        return {
+            structured: {
+                view: 'needs-dates',
+                ...common(deps, key),
+                hotel: detail.hotel,
+                room: roomRef,
+                why: dated?.noRooms,
+                ...(dated?.noRoomsCode ? { whyCode: dated.noRoomsCode } : {}),
+                ...(dated?.noRoomsArgs ? { whyArgs: dated.noRoomsArgs } : {}),
+            },
+            text: dated?.noRooms ?? 'Those nights cannot be booked here.',
+        };
+    }
+    // ⚠️ BY THE OFFER'S WHOLE NAME, in any language it has: a guest who read
+    // 「豪华大床房 · 双早 · 不可取消」 on the card says that, and it is the same offer
+    // as "Deluxe King Room · Breakfast for 2 · Non-refundable". Never a part of
+    // it, and never a room type's bare name when it has several rates.
+    const room = dated.rooms.find((r) => r.id === roomRef) ?? namedExactly(dated.rooms, roomRef);
+    if (!room) {
+        return {
+            structured: {
+                view: 'error',
+                ...common(deps, key),
+                error: 'no-such-room',
+                query: roomRef,
+                rooms: dated.rooms.map((r) => ({
+                    id: r.id,
+                    name: r.name,
+                    ...(r.names ? { names: r.names } : {}),
+                })),
+                // The hotel and the nights, so the card can take the guest straight
+                // back to its rooms rather than to the start (round-2 jury).
+                hotel: { id: detail.hotel.id, name: detail.hotel.name },
+                stay,
+            },
+            text: `${detail.hotel.name} has no room type by that name for those nights. It has: ${dated.rooms.map((r) => (/\p{Script=Han}/u.test(roomRef) && r.names?.zh ? `${r.name} (${r.names.zh})` : r.name)).join(', ')}.`,
+        };
+    }
+    deps.trips.set(store, {
+        kind: 'room',
+        hotelId,
+        roomId: room.id,
+        stay,
+        rooms: clampCount(args.rooms ?? 1, MAX_ROOMS_PER_LINE),
+    });
+    return currentTrip(deps, key, identity(deps, ctx, key), store);
+};
+/**
+ * Books the rooms in one slot of the trip store for a named guest - THE ONE
+ * BOOKING CODE, for the trip (`request_booking`, `store` the trip's own key)
+ * and for the picked room (`book_picked_room`, `store` its `pickedKey`).
+ *
+ * ⚠️ TWO KEYS, AND THEY ARE NOT THE SAME THING. `key` is the conversation's
+ * trip key: the signed-in member, the identity a booking is made as, the
+ * limits and every answer's `common` keep it. `store` is only where the LINES
+ * come from and where what was booked leaves from - so a pick is booked at the
+ * member rate and under the same limits, and the trip is never read or emptied.
+ * `nothingThere` is what is said when the slot is empty.
+ */
+const bookTripLines = async (deps, t, ctx, key, store, args, nothingThere) => {
+    const inTrip = deps.trips.read(store);
+    if (inTrip.length === 0) {
+        return {
+            structured: { view: 'empty-trip', ...common(deps, key) },
+            text: nothingThere,
+        };
+    }
+    // ⚠️ ONE GROUP AT A TIME, in a market: a booking cannot be all-or-nothing
+    // across two groups' systems (Marketplace, §6-1). `group` books one
+    // group's stays and leaves the rest in the trip.
+    const asked = deps.backend.suppliers ? str(args.group) : '';
+    const group = asked ? groupNamed(deps, asked) : undefined;
+    const groupOf = (l) => deps.backend.supplierOf?.(l.hotelId);
+    const lines = group ? inTrip.filter((l) => groupOf(l) === group.id) : inTrip;
+    if (asked && (!group || lines.length === 0)) {
+        const there = [...new Set(inTrip.map(groupOf))]
+            .map((id) => holderOf(deps, id).name)
+            .filter(Boolean);
+        const words = group
+            ? `Nothing in the trip is with ${group.name}. It holds stays with ${listAnd(there)}.`
+            : `No hotel group here is called "${asked}". The trip holds stays with ${listAnd(there)}.`;
+        return {
+            structured: { view: 'error', ...common(deps, key), error: 'no-such-group', detail: words },
+            text: words,
+        };
+    }
+    const guest = { name: str(args.name), email: str(args.email) };
+    // A phone where the backend needs one: a booking paid at the hotel and
+    // guaranteed by nobody, which the hotel has to be able to follow up.
+    // In a market, the trip's own groups decide - not whichever group needs most.
+    const phoneNeeded = deps.backend.suppliers
+        ? lines.some((l) => !!holderOf(deps, deps.backend.supplierOf?.(l.hotelId)).caps.requiresPhone)
+        : !!(deps.backend.capabilities ?? FULL_CAPABILITIES).requiresPhone;
+    const phone = str(args.phone);
+    const missing = [
+        !guest.name && 'a name',
+        !guest.email.includes('@') && 'an email',
+        phoneNeeded && phone.replace(/\D/g, '').length < 6 && 'a phone number',
+        // Too long is as unusable as missing - see GUEST_LIMITS.
+        ...guestTooLong({ ...guest, phone }),
+    ].filter((x) => typeof x === 'string');
+    if (missing.length) {
+        const said = missing.length > 1
+            ? `${missing.slice(0, -1).join(', ')} and ${missing.at(-1)}`
+            : (missing[0] ?? '');
+        return {
+            structured: { view: 'needs-guest', ...common(deps, key), missing },
+            text: `The booking needs ${said}. Ask the guest for ${missing.length > 1 ? 'them' : 'it'} - do not use a ${phoneNeeded ? 'name, email or phone number' : 'name or email'} you know from anywhere else.`,
+        };
+    }
+    const { requests, dropped } = readRequests(args);
+    try {
+        const shown = deps.trips.shown(store);
+        const { booked: made, failed } = await deps.backend.requestBooking({ lines, ...(shown ? { shown } : {}) }, {
+            ...guest,
+            ...(str(args.phone) ? { phone: str(args.phone) } : {}),
+            ...(requests?.note ? { notes: requests.note } : {}),
+        }, 
+        // ⚠️ THE SIGNED-IN MEMBER, NOT A HAND-BUILT IDENTITY. This read
+        // `{ sessionId, email }` and nothing else, so the booking was re-quoted
+        // with no member and written at the PUBLIC rate - after the card had
+        // shown the member rate, the saving, and the tier. A guest was quoted a
+        // discount and then booked without it, which is the one step where
+        // being wrong leaves a record (robin, 2026-09-21). `identity()` is the
+        // only place an Identity is built; the guest's email still overrides,
+        // because a booking is found by the address it was made with.
+        { ...identity(deps, ctx, key), email: guest.email }, requests);
+        // ⚠️ WHAT WAS BOOKED LEAVES THE TRIP; WHAT WAS NOT STAYS IN IT, add-ons
+        // and all - to ask again, or to put another hotel in its place (robin,
+        // 2026-10-14).
+        const stillOut = (l) => failed.some((f) => inFailedStay(l, f));
+        if (lines.length === inTrip.length && !lines.some(stillOut))
+            deps.trips.clear(store);
+        else
+            for (const l of lines)
+                if (!stillOut(l))
+                    deps.trips.set(store, unset(l));
+        // What is left is priced again, and that price is what the next
+        // booking is held to (ShownQuote).
+        const rest = lines.length === inTrip.length && !failed.length
+            ? undefined
+            : await currentTrip(deps, key, identity(deps, ctx, key), store);
+        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
+            ? alternativesFor(deps, f, lines, shown, identity(deps, ctx, key))
+            : Promise.resolve({ hotels: [] })));
+        // ⚠️ 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 {
+                // ADDED TO what is kept, not in place of it: a quiet room remembered
+                // this time silently dropped the king bed remembered last time. A new
+                // request does replace its opposite - twin beds over a king bed.
+                const clash = (k) => lasting.some((n) => OPPOSITES.some((pair) => pair.includes(n) && pair.includes(k)));
+                const merged = [
+                    ...(signedIn.preferences ?? []).filter((k) => !lasting.includes(k) && !clash(k)),
+                    ...lasting,
+                ];
+                const kept = await deps.backend.rememberPreferences(signedIn, merged);
+                deps.members.set(key, { ...signedIn, preferences: kept });
+                deps.members.setPreferences(signedIn.number, kept);
+                remembered = {
+                    kept,
+                    line: `Remembered on this ${signedIn.programme} membership for next time: ${kept.map((k) => REQUEST_WORDS[k]).join(', ')}. ${t.forgetPreferences} forgets them.`,
+                };
+            }
+        }
+        // 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.
+        // 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);
+            return {
+                booking,
+                // The requests that could not both be asked for are said once.
+                asked: requestLines(booking, i === 0 ? dropped : [], hotel?.hotel.checkInFrom),
+            };
+        }));
+        const [first] = booked;
+        const several = booked.length > 1;
+        const waiting = booked.filter(({ booking }) => confirming(deps, booking)).length;
+        const notBooked = failed.map((f, i) => ({
+            hotelId: f.hotelId,
+            hotelName: f.hotelName,
+            stay: f.stay,
+            ...(f.hourly ? { hourly: f.hourly } : {}),
+            ...(f.roomName ? { roomName: f.roomName } : {}),
+            rooms: roomsIn(lines, f),
+            // What to take out of the trip to put another hotel in its place.
+            roomRefs: lines.flatMap((l) => (l.kind === 'room' && inFailedStay(l, f) ? [l.roomId] : [])),
+            extraRefs: lines.flatMap((l) => l.kind === 'extra' && inFailedStay(l, f) ? [l.extraId] : []),
+            why: f.why,
+            ...(f.code ? { code: f.code } : {}),
+            ...(f.args ? { args: f.args } : {}),
+            ...(instead[i]?.city ? { city: instead[i]?.city } : {}),
+            alternatives: (instead[i]?.hotels ?? []).map((h) => ({
+                hotelId: h.id,
+                name: h.name,
+                brand: h.brand,
+                ...(h.forStay
+                    ? {
+                        total: formatMoney(h.forStay.total),
+                        room: h.forStay.room,
+                        ...(h.forStay.roomNames ? { roomNames: h.forStay.roomNames } : {}),
+                        freeCancellation: h.forStay.freeCancellation,
+                    }
+                    : {}),
+            })),
+        }));
+        const failedText = notBooked.map((f) => `NOT BOOKED - ${f.hotelName} · ${stayWords(f.stay, f.hourly)}: ${f.why} It is still in the trip.${f.alternatives.length
+            ? ` Bookable instead for the same nights: ${f.alternatives.map((a) => `${a.name}${a.room ? ` (${a.room}` : ''}${a.total ? `${a.room ? ', ' : ' ('}${a.total} for the stay)` : a.room ? ')' : ''} [hotel \`${a.hotelId}\`]`).join('; ')}.`
+            : ''} The guest can ask again, take another hotel, or leave it.`);
+        if (!first) {
+            // Nothing booked at all: every stay said, each with its way on.
+            return {
+                structured: {
+                    view: 'booking',
+                    ...common(deps, key),
+                    paid: false,
+                    failed: notBooked,
+                },
+                text: [
+                    `Nothing was booked: ${notBooked.length === 1 ? 'the stay' : `none of the ${notBooked.length} stays`} could be.`,
+                    ...failedText,
+                ].join('\n'),
+            };
+        }
+        return {
+            structured: {
+                // ⚠️ 'booking' EVEN WHEN IT IS AWAITING PAYMENT: the card draws a view
+                // only once it knows it, and the card-contract test holds every view
+                // here to that. 香格里拉's card turns this into its own 'payment' step
+                // (booking.status 'awaiting-payment', booking.payment) - and moves the
+                // view with it.
+                view: 'booking',
+                ...common(deps, key),
+                booking: madeForCard(deps, first.booking),
+                // ⚠️ ONE PER STAY - see `requestBooking`. The card draws each with its
+                // own code; `booking` stays the first, for a host that reads one.
+                ...(several
+                    ? {
+                        bookings: booked.map(({ booking, asked }) => ({
+                            ...madeForCard(deps, booking),
+                            total: formatMoney(booking.quote.total),
+                            ...(asked.length ? { requested: asked } : {}),
+                            // Each its own warning colour - it rode on the first alone.
+                            ...(booking.requests?.kinds.includes('accessible-room')
+                                ? { accessibility: true }
+                                : {}),
+                        })),
+                    }
+                    : {}),
+                paid: false,
+                ...(remembered ? { remembered: remembered.kept } : {}),
+                // What they come to together, said by the server like every figure on
+                // the card - never added up there (r10, #15). Only in one currency.
+                ...(several &&
+                    booked.every(({ booking }) => booking.quote.total.currency === first.booking.quote.total.currency)
+                    ? {
+                        totalAll: formatMoney({
+                            minor: booked.reduce((n, { booking }) => n + booking.quote.total.minor, 0),
+                            currency: first.booking.quote.total.currency,
+                        }),
+                    }
+                    : {}),
+                holdUntil: first.booking.holdUntil,
+                total: formatMoney(first.booking.quote.total),
+                ...(first.asked.length ? { requested: first.asked } : {}),
+                ...(first.booking.requests?.kinds.includes('accessible-room')
+                    ? { accessibility: true }
+                    : {}),
+                ...(notBooked.length ? { failed: notBooked } : {}),
+            },
+            text: [
+                // ⚠️ BOOKED IS CONFIRMED: a stay still being confirmed is said as
+                // that, and not counted (总线程, 2026-10-14).
+                notBooked.length || (booked.length > 1 && waiting)
+                    ? `${booked.length - waiting} of ${booked.length + notBooked.length} stays booked${waiting ? `, ${waiting} being confirmed by the hotel - no code until it is` : ''}${notBooked.length ? `; ${notBooked.length === 1 ? 'one' : notBooked.length} could not be, said below` : ''} - what was booked stays booked.`
+                    : '',
+                several
+                    ? `${booked.length} bookings, one for each stay - each hotel keeps its own nights under its own code, and each is ${holderOf(deps, first.booking.supplier).caps.changes ? 'changed or cancelled' : 'cancelled'} on its own.`
+                    : '',
+                ...booked.flatMap(({ booking, asked }) => [
+                    `**${confirming(deps, booking) ? 'Being confirmed' : booking.confirmationCode}** · ${booking.hotelName} · ${stayWords(booking.stay, booking.hourly)}`,
+                    bookedLine(deps, booking),
+                    ...asked,
+                ]),
+                ...failedText,
+                remembered?.line ?? '',
+                others ? `The trip's other stays are still in it, not booked:\n${rest?.text ?? ''}` : '',
+                deps.vocab.demo ? noteFor(deps.vocab) : '',
+            ]
+                .filter(Boolean)
+                .join('\n'),
+        };
+    }
+    catch (err) {
+        const words = guestWords(err, BOOKING_FAULT);
+        // The price or terms moved since the guest saw them: nothing was booked,
+        // 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);
+            return { ...again, text: [words, again.text].join('\n\n') };
+        }
+        if (err.code === 'mixed-supplier') {
+            const again = await currentTrip(deps, key, identity(deps, ctx, key), store);
+            return {
+                ...again,
+                text: [
+                    words,
+                    `${t.requestBooking} with \`group\` books one group's stays and leaves the others in the trip.`,
+                    again.text,
+                ].join('\n\n'),
+            };
+        }
+        return {
+            structured: {
+                view: 'error',
+                ...common(deps, key),
+                error: 'not-bookable',
+                detail: words,
+            },
+            text: words,
+        };
+    }
+};
 const answerTool = async (deps, name, rawArgs, ctx) => {
     const args = countsAsNumbers((rawArgs ?? {}));
     const t = deps.tools;
@@ -3682,23 +4245,10 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         };
     }
     if (name === t.addToTrip) {
-        const wanted = str(args.hotel);
-        const detail = await deps.backend.getHotel(wanted);
-        if (!detail) {
-            const candidates = candidatesFor(deps.backend, wanted);
-            return {
-                structured: {
-                    view: 'error',
-                    ...common(deps, key),
-                    error: 'hotel-not-found',
-                    query: wanted,
-                    ...(candidates.length ? { candidates } : {}),
-                },
-                text: candidates.length
-                    ? `"${wanted}" ${namesMoreThanOne(candidates, branded(deps.vocab, deps.vocab.noun))}`
-                    : `No ${branded(deps.vocab, deps.vocab.noun)} by that name.`,
-            };
-        }
+        const found = await hotelNamed(deps, key, str(args.hotel));
+        if ('answer' in found)
+            return found.answer;
+        const { detail } = found;
         const hotelId = detail.hotel.id;
         const extraRef = str(args.extra);
         if (extraRef) {
@@ -3727,164 +4277,24 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
             deps.trips.set(key, line);
             return currentTrip(deps, key, identity(deps, ctx, key));
         }
-        const roomRef = str(args.room);
-        if (!roomRef) {
-            return {
-                structured: { view: 'error', ...common(deps, key), error: 'no-room-named' },
-                text: `Say which room type, or which add-on. ${t.getHotel} with the dates lists the room types.`,
-            };
-        }
-        // A room by the hour: today, from the start the guest gave - checked here,
-        // against the starts the room takes, and never moved to fit (总线程,
-        // 2026-10-12).
-        const who = identity(deps, ctx, key);
-        const startTime = str(args.startTime);
-        const today = (startTime || !asStay(args)
-            ? deps.backend.hourlyRooms?.(hotelId, guestsOf(args), who)
-            : undefined);
-        const byTheHour = async () => {
-            const sold = ((await today)?.rooms ?? []).filter((r) => r.hourly);
-            return sold.find((r) => r.id === roomRef) ?? namedExactly(sold, roomRef);
-        };
-        if (startTime && deps.backend.hourlyRooms) {
-            const hourlyRoom = await byTheHour();
-            if (!hourlyRoom?.hourly) {
-                const sold = ((await today)?.rooms ?? []).filter((r) => r.hourly);
-                return {
-                    structured: {
-                        view: 'error',
-                        ...common(deps, key),
-                        error: 'no-such-room',
-                        query: roomRef,
-                        rooms: sold.map((r) => ({
-                            id: r.id,
-                            name: r.name,
-                            ...(r.names ? { names: r.names } : {}),
-                        })),
-                    },
-                    text: sold.length
-                        ? `${detail.hotel.name} has no room by the hour by that name today. It has: ${sold.map((r) => `${r.name} (\`${r.id}\`, ${windowWords(r.hourly)})`).join('; ')}.`
-                        : ((await today)?.noRooms ?? `${detail.hotel.name} has no rooms by the hour today.`),
-                };
-            }
-            const bad = startProblem(hourlyRoom.hourly, startTime);
-            if (bad) {
-                return {
-                    structured: {
-                        view: 'error',
-                        ...common(deps, key),
-                        error: 'start-time',
-                        query: startTime,
-                        // The starts it does take. Not `hourly`: that is the flag above.
-                        window: hourlyRoom.hourly,
-                    },
-                    text: bad,
-                };
-            }
-            deps.trips.set(key, {
-                kind: 'room',
-                hotelId,
-                roomId: hourlyRoom.id,
-                stay: {
-                    checkIn: hourlyRoom.hourly.date,
-                    checkOut: hourlyRoom.hourly.date,
-                    guests: guestsOf(args),
-                },
-                rooms: clampCount(args.rooms ?? 1, MAX_ROOMS_PER_LINE),
-                hourly: {
-                    start: clockOf(minutesOf(startTime)),
-                    hours: hourlyRoom.hourly.hours,
-                },
-            });
-            return currentTrip(deps, key, who);
-        }
-        const stay = asStay(args);
-        // ⚠️ NO DATES, NO LINE. Guessing "tonight" or "this weekend" here is how a
-        // connector books someone the wrong nights, and the guest finds out at the
-        // desk. The trip stays as it was and the answer asks.
-        if (!stay) {
-            const hourlyRoom = await byTheHour();
-            return {
-                structured: {
-                    view: 'needs-dates',
-                    ...common(deps, key),
-                    hotel: detail.hotel,
-                    room: roomRef,
-                    ...(hourlyRoom?.hourly ? { window: hourlyRoom.hourly } : {}),
-                },
-                text: hourlyRoom?.hourly
-                    ? `That is a room by the hour, sold for today: it takes \`startTime\` - ${windowWords(hourlyRoom.hourly)}.`
-                    : 'Which nights? A room needs a check-in and a check-out date before it can go into the trip.',
-            };
-        }
-        // ⚠️ TAKING A ROOM OUT NEEDS NO ROOM FOR SALE. The lookup below is of
-        // what is for sale, so a room that had gone since it went into the trip -
-        // the stay a booking could not make - could not be taken out of it
-        // (2026-10-14). The line in the trip is the one asked about.
-        if (args.rooms !== undefined && clampCount(args.rooms, MAX_ROOMS_PER_LINE) === 0) {
-            const held = deps.trips
-                .read(key)
-                .find((l) => l.kind === 'room' &&
-                l.hotelId === hotelId &&
-                l.roomId === roomRef &&
-                l.stay.checkIn === stay.checkIn &&
-                l.stay.checkOut === stay.checkOut);
-            if (held) {
-                deps.trips.set(key, unset(held));
-                return currentTrip(deps, key, identity(deps, ctx, key));
-            }
-        }
-        // The backend owns the calendar - it knows each hotel's own timezone, and a
-        // second opinion computed from this process's clock would disagree with it
-        // for eight hours a day.
-        const dated = await deps.backend.getHotel(hotelId, stay, identity(deps, ctx, key));
-        if (!dated?.rooms) {
+        return putRoomLine(deps, t, ctx, key, key, args, detail);
+    }
+    // The card's own: the press on Reserve. The picked room has a slot of its
+    // own (`pickedKey`), emptied first - so a second pick REPLACES the first and
+    // a pick that fails leaves none - and the trip is never read or written.
+    if (name === t.pickRoom) {
+        const slot = pickedKey(key);
+        deps.trips.clear(slot);
+        if (clampCount(args.rooms ?? 1, MAX_ROOMS_PER_LINE) === 0) {
             return {
-                structured: {
-                    view: 'needs-dates',
-                    ...common(deps, key),
-                    hotel: detail.hotel,
-                    room: roomRef,
-                    why: dated?.noRooms,
-                    ...(dated?.noRoomsCode ? { whyCode: dated.noRoomsCode } : {}),
-                    ...(dated?.noRoomsArgs ? { whyArgs: dated.noRoomsArgs } : {}),
-                },
-                text: dated?.noRooms ?? 'Those nights cannot be booked here.',
+                structured: { view: 'trip', direct: true, ...common(deps, key), lines: [], count: 0 },
+                text: 'Nothing is picked.',
             };
         }
-        // ⚠️ BY THE OFFER'S WHOLE NAME, in any language it has: a guest who read
-        // 「豪华大床房 · 双早 · 不可取消」 on the card says that, and it is the same offer
-        // as "Deluxe King Room · Breakfast for 2 · Non-refundable". Never a part of
-        // it, and never a room type's bare name when it has several rates.
-        const room = dated.rooms.find((r) => r.id === roomRef) ?? namedExactly(dated.rooms, roomRef);
-        if (!room) {
-            return {
-                structured: {
-                    view: 'error',
-                    ...common(deps, key),
-                    error: 'no-such-room',
-                    query: roomRef,
-                    rooms: dated.rooms.map((r) => ({
-                        id: r.id,
-                        name: r.name,
-                        ...(r.names ? { names: r.names } : {}),
-                    })),
-                    // The hotel and the nights, so the card can take the guest straight
-                    // back to its rooms rather than to the start (round-2 jury).
-                    hotel: { id: detail.hotel.id, name: detail.hotel.name },
-                    stay,
-                },
-                text: `${detail.hotel.name} has no room type by that name for those nights. It has: ${dated.rooms.map((r) => (/\p{Script=Han}/u.test(roomRef) && r.names?.zh ? `${r.name} (${r.names.zh})` : r.name)).join(', ')}.`,
-            };
-        }
-        deps.trips.set(key, {
-            kind: 'room',
-            hotelId,
-            roomId: room.id,
-            stay,
-            rooms: clampCount(args.rooms ?? 1, MAX_ROOMS_PER_LINE),
-        });
-        return currentTrip(deps, key, identity(deps, ctx, key));
+        const found = await hotelNamed(deps, key, str(args.hotel));
+        if ('answer' in found)
+            return direct(found.answer);
+        return direct(await putRoomLine(deps, t, ctx, key, slot, args, found.detail));
     }
     if (name === t.viewTrip)
         return currentTrip(deps, key, identity(deps, ctx, key));
@@ -3897,289 +4307,12 @@ const answerTool = async (deps, name, rawArgs, ctx) => {
         };
     }
     if (name === t.requestBooking) {
-        const inTrip = deps.trips.read(key);
-        if (inTrip.length === 0) {
-            return {
-                structured: { view: 'empty-trip', ...common(deps, key) },
-                text: `There is nothing in the trip yet. ${t.addToTrip} puts room nights in it.`,
-            };
-        }
-        // ⚠️ ONE GROUP AT A TIME, in a market: a booking cannot be all-or-nothing
-        // across two groups' systems (Marketplace, §6-1). `group` books one
-        // group's stays and leaves the rest in the trip.
-        const asked = deps.backend.suppliers ? str(args.group) : '';
-        const group = asked ? groupNamed(deps, asked) : undefined;
-        const groupOf = (l) => deps.backend.supplierOf?.(l.hotelId);
-        const lines = group ? inTrip.filter((l) => groupOf(l) === group.id) : inTrip;
-        if (asked && (!group || lines.length === 0)) {
-            const there = [...new Set(inTrip.map(groupOf))]
-                .map((id) => holderOf(deps, id).name)
-                .filter(Boolean);
-            const words = group
-                ? `Nothing in the trip is with ${group.name}. It holds stays with ${listAnd(there)}.`
-                : `No hotel group here is called "${asked}". The trip holds stays with ${listAnd(there)}.`;
-            return {
-                structured: { view: 'error', ...common(deps, key), error: 'no-such-group', detail: words },
-                text: words,
-            };
-        }
-        const guest = { name: str(args.name), email: str(args.email) };
-        // A phone where the backend needs one: a booking paid at the hotel and
-        // guaranteed by nobody, which the hotel has to be able to follow up.
-        // In a market, the trip's own groups decide - not whichever group needs most.
-        const phoneNeeded = deps.backend.suppliers
-            ? lines.some((l) => !!holderOf(deps, deps.backend.supplierOf?.(l.hotelId)).caps.requiresPhone)
-            : !!(deps.backend.capabilities ?? FULL_CAPABILITIES).requiresPhone;
-        const phone = str(args.phone);
-        const missing = [
-            !guest.name && 'a name',
-            !guest.email.includes('@') && 'an email',
-            phoneNeeded && phone.replace(/\D/g, '').length < 6 && 'a phone number',
-            // Too long is as unusable as missing - see GUEST_LIMITS.
-            ...guestTooLong({ ...guest, phone }),
-        ].filter((x) => typeof x === 'string');
-        if (missing.length) {
-            const said = missing.length > 1
-                ? `${missing.slice(0, -1).join(', ')} and ${missing.at(-1)}`
-                : (missing[0] ?? '');
-            return {
-                structured: { view: 'needs-guest', ...common(deps, key), missing },
-                text: `The booking needs ${said}. Ask the guest for ${missing.length > 1 ? 'them' : 'it'} - do not use a ${phoneNeeded ? 'name, email or phone number' : 'name or email'} you know from anywhere else.`,
-            };
-        }
-        const { requests, dropped } = readRequests(args);
-        try {
-            const shown = deps.trips.shown(key);
-            const { booked: made, failed } = await deps.backend.requestBooking({ lines, ...(shown ? { shown } : {}) }, {
-                ...guest,
-                ...(str(args.phone) ? { phone: str(args.phone) } : {}),
-                ...(requests?.note ? { notes: requests.note } : {}),
-            }, 
-            // ⚠️ THE SIGNED-IN MEMBER, NOT A HAND-BUILT IDENTITY. This read
-            // `{ sessionId, email }` and nothing else, so the booking was re-quoted
-            // with no member and written at the PUBLIC rate - after the card had
-            // shown the member rate, the saving, and the tier. A guest was quoted a
-            // discount and then booked without it, which is the one step where
-            // being wrong leaves a record (robin, 2026-09-21). `identity()` is the
-            // only place an Identity is built; the guest's email still overrides,
-            // because a booking is found by the address it was made with.
-            { ...identity(deps, ctx, key), email: guest.email }, requests);
-            // ⚠️ WHAT WAS BOOKED LEAVES THE TRIP; WHAT WAS NOT STAYS IN IT, add-ons
-            // and all - to ask again, or to put another hotel in its place (robin,
-            // 2026-10-14).
-            const stillOut = (l) => failed.some((f) => inFailedStay(l, f));
-            if (lines.length === inTrip.length && !lines.some(stillOut))
-                deps.trips.clear(key);
-            else
-                for (const l of lines)
-                    if (!stillOut(l))
-                        deps.trips.set(key, unset(l));
-            // What is left is priced again, and that price is what the next
-            // booking is held to (ShownQuote).
-            const rest = lines.length === inTrip.length && !failed.length
-                ? undefined
-                : await currentTrip(deps, key, identity(deps, ctx, key));
-            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
-                ? alternativesFor(deps, f, lines, shown, identity(deps, ctx, key))
-                : Promise.resolve({ hotels: [] })));
-            // ⚠️ 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 {
-                    // ADDED TO what is kept, not in place of it: a quiet room remembered
-                    // this time silently dropped the king bed remembered last time. A new
-                    // request does replace its opposite - twin beds over a king bed.
-                    const clash = (k) => lasting.some((n) => OPPOSITES.some((pair) => pair.includes(n) && pair.includes(k)));
-                    const merged = [
-                        ...(signedIn.preferences ?? []).filter((k) => !lasting.includes(k) && !clash(k)),
-                        ...lasting,
-                    ];
-                    const kept = await deps.backend.rememberPreferences(signedIn, merged);
-                    deps.members.set(key, { ...signedIn, preferences: kept });
-                    deps.members.setPreferences(signedIn.number, kept);
-                    remembered = {
-                        kept,
-                        line: `Remembered on this ${signedIn.programme} membership for next time: ${kept.map((k) => REQUEST_WORDS[k]).join(', ')}. ${t.forgetPreferences} forgets them.`,
-                    };
-                }
-            }
-            // 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.
-            // 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);
-                return {
-                    booking,
-                    // The requests that could not both be asked for are said once.
-                    asked: requestLines(booking, i === 0 ? dropped : [], hotel?.hotel.checkInFrom),
-                };
-            }));
-            const [first] = booked;
-            const several = booked.length > 1;
-            const waiting = booked.filter(({ booking }) => confirming(deps, booking)).length;
-            const notBooked = failed.map((f, i) => ({
-                hotelId: f.hotelId,
-                hotelName: f.hotelName,
-                stay: f.stay,
-                ...(f.hourly ? { hourly: f.hourly } : {}),
-                ...(f.roomName ? { roomName: f.roomName } : {}),
-                rooms: roomsIn(lines, f),
-                // What to take out of the trip to put another hotel in its place.
-                roomRefs: lines.flatMap((l) => (l.kind === 'room' && inFailedStay(l, f) ? [l.roomId] : [])),
-                extraRefs: lines.flatMap((l) => l.kind === 'extra' && inFailedStay(l, f) ? [l.extraId] : []),
-                why: f.why,
-                ...(f.code ? { code: f.code } : {}),
-                ...(f.args ? { args: f.args } : {}),
-                ...(instead[i]?.city ? { city: instead[i]?.city } : {}),
-                alternatives: (instead[i]?.hotels ?? []).map((h) => ({
-                    hotelId: h.id,
-                    name: h.name,
-                    brand: h.brand,
-                    ...(h.forStay
-                        ? {
-                            total: formatMoney(h.forStay.total),
-                            room: h.forStay.room,
-                            ...(h.forStay.roomNames ? { roomNames: h.forStay.roomNames } : {}),
-                            freeCancellation: h.forStay.freeCancellation,
-                        }
-                        : {}),
-                })),
-            }));
-            const failedText = notBooked.map((f) => `NOT BOOKED - ${f.hotelName} · ${stayWords(f.stay, f.hourly)}: ${f.why} It is still in the trip.${f.alternatives.length
-                ? ` Bookable instead for the same nights: ${f.alternatives.map((a) => `${a.name}${a.room ? ` (${a.room}` : ''}${a.total ? `${a.room ? ', ' : ' ('}${a.total} for the stay)` : a.room ? ')' : ''} [hotel \`${a.hotelId}\`]`).join('; ')}.`
-                : ''} The guest can ask again, take another hotel, or leave it.`);
-            if (!first) {
-                // Nothing booked at all: every stay said, each with its way on.
-                return {
-                    structured: {
-                        view: 'booking',
-                        ...common(deps, key),
-                        paid: false,
-                        failed: notBooked,
-                    },
-                    text: [
-                        `Nothing was booked: ${notBooked.length === 1 ? 'the stay' : `none of the ${notBooked.length} stays`} could be.`,
-                        ...failedText,
-                    ].join('\n'),
-                };
-            }
-            return {
-                structured: {
-                    // ⚠️ 'booking' EVEN WHEN IT IS AWAITING PAYMENT: the card draws a view
-                    // only once it knows it, and the card-contract test holds every view
-                    // here to that. 香格里拉's card turns this into its own 'payment' step
-                    // (booking.status 'awaiting-payment', booking.payment) - and moves the
-                    // view with it.
-                    view: 'booking',
-                    ...common(deps, key),
-                    booking: madeForCard(deps, first.booking),
-                    // ⚠️ ONE PER STAY - see `requestBooking`. The card draws each with its
-                    // own code; `booking` stays the first, for a host that reads one.
-                    ...(several
-                        ? {
-                            bookings: booked.map(({ booking, asked }) => ({
-                                ...madeForCard(deps, booking),
-                                total: formatMoney(booking.quote.total),
-                                ...(asked.length ? { requested: asked } : {}),
-                                // Each its own warning colour - it rode on the first alone.
-                                ...(booking.requests?.kinds.includes('accessible-room')
-                                    ? { accessibility: true }
-                                    : {}),
-                            })),
-                        }
-                        : {}),
-                    paid: false,
-                    ...(remembered ? { remembered: remembered.kept } : {}),
-                    // What they come to together, said by the server like every figure on
-                    // the card - never added up there (r10, #15). Only in one currency.
-                    ...(several &&
-                        booked.every(({ booking }) => booking.quote.total.currency === first.booking.quote.total.currency)
-                        ? {
-                            totalAll: formatMoney({
-                                minor: booked.reduce((n, { booking }) => n + booking.quote.total.minor, 0),
-                                currency: first.booking.quote.total.currency,
-                            }),
-                        }
-                        : {}),
-                    holdUntil: first.booking.holdUntil,
-                    total: formatMoney(first.booking.quote.total),
-                    ...(first.asked.length ? { requested: first.asked } : {}),
-                    ...(first.booking.requests?.kinds.includes('accessible-room')
-                        ? { accessibility: true }
-                        : {}),
-                    ...(notBooked.length ? { failed: notBooked } : {}),
-                },
-                text: [
-                    // ⚠️ BOOKED IS CONFIRMED: a stay still being confirmed is said as
-                    // that, and not counted (总线程, 2026-10-14).
-                    notBooked.length || (booked.length > 1 && waiting)
-                        ? `${booked.length - waiting} of ${booked.length + notBooked.length} stays booked${waiting ? `, ${waiting} being confirmed by the hotel - no code until it is` : ''}${notBooked.length ? `; ${notBooked.length === 1 ? 'one' : notBooked.length} could not be, said below` : ''} - what was booked stays booked.`
-                        : '',
-                    several
-                        ? `${booked.length} bookings, one for each stay - each hotel keeps its own nights under its own code, and each is ${holderOf(deps, first.booking.supplier).caps.changes ? 'changed or cancelled' : 'cancelled'} on its own.`
-                        : '',
-                    ...booked.flatMap(({ booking, asked }) => [
-                        `**${confirming(deps, booking) ? 'Being confirmed' : booking.confirmationCode}** · ${booking.hotelName} · ${stayWords(booking.stay, booking.hourly)}`,
-                        bookedLine(deps, booking),
-                        ...asked,
-                    ]),
-                    ...failedText,
-                    remembered?.line ?? '',
-                    others ? `The trip's other stays are still in it, not booked:\n${rest?.text ?? ''}` : '',
-                    deps.vocab.demo ? noteFor(deps.vocab) : '',
-                ]
-                    .filter(Boolean)
-                    .join('\n'),
-            };
-        }
-        catch (err) {
-            const words = guestWords(err, BOOKING_FAULT);
-            // The price or terms moved since the guest saw them: nothing was booked,
-            // 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));
-                return { ...again, text: [words, again.text].join('\n\n') };
-            }
-            if (err.code === 'mixed-supplier') {
-                const again = await currentTrip(deps, key, identity(deps, ctx, key));
-                return {
-                    ...again,
-                    text: [
-                        words,
-                        `${t.requestBooking} with \`group\` books one group's stays and leaves the others in the trip.`,
-                        again.text,
-                    ].join('\n\n'),
-                };
-            }
-            return {
-                structured: {
-                    view: 'error',
-                    ...common(deps, key),
-                    error: 'not-bookable',
-                    detail: words,
-                },
-                text: words,
-            };
-        }
+        return bookTripLines(deps, t, ctx, key, key, args, `There is nothing in the trip yet. ${t.addToTrip} puts room nights in it.`);
+    }
+    // The card's own: the room the guest picked with Reserve, booked exactly as
+    // a trip is - and the trip left as it is.
+    if (name === t.bookPicked) {
+        return direct(await bookTripLines(deps, t, ctx, key, pickedKey(key), args, 'Nothing is picked: the guest presses Reserve on a room first.'));
     }
     if (name === t.listBookings) {
         const who = identity(deps, ctx, key, args);