@curless/hotel-storefront 0.1.0 → 0.2.0

package/dist/tools.js

@@ -1,6 +1,7 @@
 import { isDay } from './dates.js';
 import { DESCRIPTION_MAX, POLICY_MAX, hotelText } from './fence.js';
-import { formatMoney } from './money.js';
+import { formatMoney, multiplyMoney } from './money.js';
+import { MAX_COMPARED, MAX_CONS, MAX_DAYS, MAX_ITEMS_PER_DAY, MAX_PROS, buildItinerary, compareHotels, } from './present.js';
 import { MAX_EXTRA_QUANTITY, MAX_ROOMS_PER_LINE, clampCount, tripKey, } from './trip.js';
 import { DEMO_NOTE } from './vocab.js';
 // The eleven things a guest can do: find hotels, look at one on dates, see what
@@ -83,7 +84,7 @@ export const buildTools = (n, v) => {
         },
         {
             name: n.getHotel,
-            description: `One ${v.noun} in full: description, amenities, address, check-in and check-out times. Given \`checkIn\` and \`checkOut\` it also returns the room types that can be booked for those nights, each with its nightly rate, the stay total including taxes and fees, whether it can be cancelled free and until when, and how many rooms are left. Without dates it returns the ${v.noun} only, because a room has no price until the nights are known.${v.hints.hotel ? ` ${v.hints.hotel}` : ''}`,
+            description: `One ${v.noun} in full: description, amenities, address, check-in and check-out times. Given \`checkIn\` and \`checkOut\` it also returns the room types that can be booked for those nights, each with its nightly rate, the stay total including taxes and fees, whether it can be cancelled free and until when, and how many rooms are left. \`rooms\` leaves out the types that have fewer than that many. Without dates it returns the ${v.noun} only, because a room has no price until the nights are known.${v.hints.hotel ? ` ${v.hints.hotel}` : ''}`,
             annotations: reads(`View one ${v.brand} ${v.noun}`, open),
             inputSchema: {
                 type: 'object',
@@ -93,6 +94,10 @@ export const buildTools = (n, v) => {
                         description: `The ${v.noun}'s name or id${v.hints.example ? `, e.g. "${v.hints.example}"` : ''}`,
                     },
                     ...stayProps,
+                    rooms: {
+                        type: 'number',
+                        description: `How many rooms of one type, 1 to ${MAX_ROOMS_PER_LINE}. Default 1`,
+                    },
                 },
                 required: ['hotel'],
             },
@@ -225,6 +230,101 @@ export const buildTools = (n, v) => {
                 required: ['booking'],
             },
         },
+        {
+            name: n.compare,
+            // ⚠️ NO PRICES IN, NO PRICES OUT OF THE MODEL. The arguments carry ids and
+            // prose; every figure on the card is read off the hotel's own record. A
+            // model that could send a price could one day send the wrong one, onto a
+            // card that looks official.
+            description: `Puts two to four ${v.nounPlural} side by side as one card. Each column's price, rate, cancellation terms, breakfast and rooms left come from the ${v.noun}'s own record; the arguments carry only the ids, one line on who each suits, and its pros and cons. With \`checkIn\`/\`checkOut\` the columns carry each ${v.noun}'s cheapest room for those nights; without them, a from-price.`,
+            annotations: reads(`Compare ${v.brand} ${v.nounPlural}`, open),
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    entries: {
+                        type: 'array',
+                        minItems: 2,
+                        maxItems: MAX_COMPARED,
+                        description: `The ${v.nounPlural} to set beside each other, in the order they should appear`,
+                        items: {
+                            type: 'object',
+                            properties: {
+                                hotel: { type: 'string', description: `The ${v.noun}'s name or id` },
+                                bestFor: {
+                                    type: 'string',
+                                    description: 'One line on who this one suits, in your own words',
+                                },
+                                pros: { type: 'array', items: { type: 'string' }, maxItems: MAX_PROS },
+                                cons: { type: 'array', items: { type: 'string' }, maxItems: MAX_CONS },
+                            },
+                            required: ['hotel'],
+                        },
+                    },
+                    recommended: { type: 'string', description: `The one ${v.noun} to mark as the pick` },
+                    title: { type: 'string', description: 'A heading for the card' },
+                    ...stayProps,
+                },
+                required: ['entries'],
+            },
+        },
+        {
+            name: n.itinerary,
+            description: `A day-by-day plan as one card: each day carries its own label, an optional note, and the ${v.nounPlural} and add-ons attached to it, with their details filled in from their own records. Each item is marked with whether it is in the trip or only in the plan, and the card says how many of each. Nothing is added to the trip.`,
+            annotations: reads(`Lay out a ${v.brand} itinerary`, open),
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    title: { type: 'string', description: 'What to call the trip' },
+                    days: {
+                        type: 'array',
+                        minItems: 1,
+                        maxItems: MAX_DAYS,
+                        items: {
+                            type: 'object',
+                            properties: {
+                                label: { type: 'string', description: 'e.g. "Day 1 — Arrive in Hong Kong"' },
+                                note: {
+                                    type: 'string',
+                                    description: 'One or two lines on the day, in your own words',
+                                },
+                                items: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    maxItems: MAX_ITEMS_PER_DAY,
+                                    description: `${v.nounPlural} and add-ons for that day, by name or id`,
+                                },
+                            },
+                            required: ['label'],
+                        },
+                    },
+                    ...stayProps,
+                },
+                required: ['title', 'days'],
+            },
+        },
+        {
+            name: n.signIn,
+            // ⚠️ A MEMBERSHIP NUMBER AND A SURNAME. No password appears in this
+            // schema because none exists: the connector has nowhere to put one, and
+            // a description that mentioned passwords would invite a model to ask for
+            // one in a chat transcript.
+            description: `Signs a ${v.brand} loyalty member in for this conversation with their membership number and the surname on it, and answers with their tier, their point balance and what the tier takes off the public rate. Room rates and trip totals are then quoted at the member rate until they are signed out.`,
+            annotations: edits(`Sign in to ${v.brand}`, open),
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    number: { type: 'string', description: 'The membership number, as it is printed' },
+                    surname: { type: 'string', description: 'The surname on that membership' },
+                },
+                required: ['number', 'surname'],
+            },
+        },
+        {
+            name: n.signOut,
+            description: 'Ends the membership sign-in for this conversation. Rates go back to the public ones; the trip and any bookings are left as they are.',
+            annotations: edits(`Sign out of ${v.brand}`, 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.`,
@@ -269,6 +369,10 @@ const TRIP_SCHEMA = {
         subtotal: STR,
         taxesAndFees: STR,
         total: STR,
+        /** Who is signed in, on every payload. */
+        member: OBJ,
+        /** What the tier took off THIS trip, and what it earns. */
+        memberSaving: OBJ,
         days: ARR,
         dropped: ARR,
     },
@@ -302,7 +406,9 @@ export const buildOutputSchemas = (n) => ({
             demo: BOOL,
             demoNote: STR,
             hotels: ARR,
+            /** How many MATCHED. `shown` is how many are in `hotels`. */
             total: { type: 'number' },
+            shown: { type: 'number' },
             cities: ARR,
             query: STR,
         },
@@ -322,6 +428,8 @@ export const buildOutputSchemas = (n) => ({
             rooms: ARR,
             /** True when no dates were given: the card asks for them instead of showing rooms. */
             needsDates: BOOL,
+            /** How many rooms of one type the list was filtered to. */
+            rooms_wanted: { type: 'number' },
             noRooms: STR,
             extras: ARR,
             policies: ARR,
@@ -347,7 +455,7 @@ export const buildOutputSchemas = (n) => ({
     [n.requestBooking]: {
         type: 'object',
         properties: {
-            view: { enum: ['booking', 'empty-trip', 'error'] },
+            view: { enum: ['booking', 'needs-guest', 'empty-trip', 'error'] },
             brand: STR,
             toolNames: OBJ,
             demo: BOOL,
@@ -375,6 +483,56 @@ export const buildOutputSchemas = (n) => ({
     },
     [n.previewCancellation]: CANCEL_SCHEMA,
     [n.cancelBooking]: CANCEL_SCHEMA,
+    [n.compare]: {
+        type: 'object',
+        properties: {
+            view: { enum: ['comparison', 'nothing-to-compare'] },
+            brand: STR,
+            toolNames: OBJ,
+            demo: BOOL,
+            demoNote: STR,
+            title: STR,
+            stay: OBJ,
+            columns: ARR,
+            dropped: ARR,
+        },
+        required: ['view'],
+    },
+    [n.itinerary]: {
+        type: 'object',
+        properties: {
+            view: { enum: ['itinerary', 'empty-itinerary'] },
+            brand: STR,
+            toolNames: OBJ,
+            demo: BOOL,
+            demoNote: STR,
+            title: STR,
+            stay: OBJ,
+            days: ARR,
+            /** How many of the planned items are actually in the trip. Computed, never written. */
+            inTrip: { type: 'number' },
+            planned: { type: 'number' },
+            dropped: ARR,
+        },
+        required: ['view'],
+    },
+    [n.signIn]: {
+        type: 'object',
+        properties: {
+            view: { enum: ['member', 'member-not-found'] },
+            brand: STR,
+            toolNames: OBJ,
+            demo: BOOL,
+            demoNote: STR,
+            member: OBJ,
+        },
+        required: ['view'],
+    },
+    [n.signOut]: {
+        type: 'object',
+        properties: { view: { const: 'signed-out' }, brand: STR, toolNames: OBJ },
+        required: ['view'],
+    },
     [n.policies]: {
         type: 'object',
         properties: {
@@ -401,13 +559,30 @@ const asStay = (args) => {
     const guests = typeof args.guests === 'number' ? Math.floor(args.guests) : 2;
     return { checkIn, checkOut, guests };
 };
-/** What every payload carries, so the card can draw a header and say whose data this is. */
-const common = (deps) => ({
+/**
+ * What every payload carries, so the card can draw a header and say whose data
+ * this is.
+ *
+ * ⚠️ THE MEMBER BELONGS HERE, not on the sign-in view alone. A member rate is a
+ * fact about EVERY price on the card, so the tier has to travel with every
+ * answer - otherwise the header says "sign in" over a list of discounted rates,
+ * which is what it did the first time (2026-09-18). The name and the number are
+ * left out: the chip needs a tier, and a payload that repeats somebody's
+ * membership number on every call is carrying it further than it has to go.
+ */
+const memberBadge = (deps, key) => {
+    const m = deps.members.read(key);
+    return m
+        ? { member: { programme: m.programme, tier: { name: m.tier.name, discount: m.tier.discount } } }
+        : {};
+};
+const common = (deps, key) => ({
     brand: deps.vocab.brand,
     ...(deps.logoUrl ? { logoUrl: deps.logoUrl } : {}),
     toolNames: deps.tools,
     vocab: { noun: deps.vocab.noun, nounPlural: deps.vocab.nounPlural },
     ...(deps.vocab.demo ? { demo: true, demoNote: DEMO_NOTE } : { demo: false }),
+    ...(key ? memberBadge(deps, key) : {}),
 });
 /** One line of a trip, flattened for the card. Prices are strings: the card never does arithmetic. */
 const quoteForCard = (quote) => ({
@@ -431,6 +606,12 @@ const quoteForCard = (quote) => ({
     subtotal: formatMoney(quote.subtotal),
     taxesAndFees: formatMoney(quote.taxesAndFees),
     total: formatMoney(quote.total),
+    // ⚠️ NOT `member`: that key means "who is signed in" on every payload, and
+    // the quote's block is a different shape (a tier NAME, a saving, points).
+    // Two shapes on one key is how a card reads `member.tier.name` off a string.
+    ...(quote.member
+        ? { memberSaving: { ...quote.member, saved: formatMoney(quote.member.saved) } }
+        : {}),
     ...(quote.stay ? { stay: quote.stay } : {}),
     ...(quote.dropped ? { dropped: quote.dropped } : {}),
 });
@@ -450,16 +631,46 @@ const tripText = (quote, demo) => {
         .join('\n');
 };
 const bookingLine = (b) => `${b.confirmationCode} · ${b.hotelName} · ${b.stay.checkIn} to ${b.stay.checkOut} · ${b.status}`;
-const identity = (ctx, args) => {
+const identity = (deps, ctx, key, args = {}) => {
     const email = str(args.email);
-    return email ? { sessionId: ctx.session, email } : { sessionId: ctx.session };
+    const member = deps.members.read(key);
+    return {
+        sessionId: ctx.session,
+        ...(email ? { email } : {}),
+        // ⚠️ THE MEMBER BUYS A RATE, NOT A LOOKUP. `listBookings` and the
+        // cancellation tools still key on the conversation and on the email the
+        // booking was made with - a membership number plus a surname is what a desk
+        // checks, not authentication, and it must never become a way to read
+        // somebody else's booking.
+        ...(member ? { member } : {}),
+    };
 };
-/** The trip, priced, as both views need it. */
-const currentTrip = async (deps, key) => {
+/**
+ * Why this hotel cannot join the trip that is already there - or null.
+ *
+ * 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.
+ */
+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 - book those nights as their own trip, or clear this one first.`;
+};
+/** 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);
     return {
-        structured: { view: 'trip', ...common(deps), ...quoteForCard(quote), count: lines.length },
+        structured: { view: 'trip', ...common(deps, key), ...quoteForCard(quote), count: lines.length },
         text: tripText(quote, deps.vocab.demo),
     };
 };
@@ -469,15 +680,19 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
     const key = ctx.tripKey ?? tripKey(ctx.session, deps.vocab.brand);
     if (name === t.listHotels) {
         const query = str(args.query);
-        const hotels = await deps.backend.searchHotels({
+        const { hotels, total } = await deps.backend.searchHotels({
             query: query || undefined,
             city: str(args.city) || undefined,
             limit: typeof args.limit === 'number' ? args.limit : undefined,
         });
         const cities = [...new Set(hotels.map((h) => h.city))];
+        // How many were left behind. The group has ninety-odd properties, so an
+        // unnarrowed browse is a page of a much longer list, and neither the card
+        // nor the model may present the page as the whole answer.
+        const more = Math.max(0, total - hotels.length);
         if (hotels.length === 0) {
             return {
-                structured: { view: 'no-hotels', ...common(deps), hotels: [], total: 0, query },
+                structured: { view: 'no-hotels', ...common(deps, key), hotels: [], total: 0, query },
                 text: `No ${deps.vocab.brand} ${deps.vocab.nounPlural} match that.`,
             };
         }
@@ -491,22 +706,28 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
         return {
             structured: {
                 view: 'hotels',
-                ...common(deps),
+                ...common(deps, key),
                 hotels: forCard,
-                total: hotels.length,
+                total,
+                shown: hotels.length,
                 cities,
                 query,
             },
-            text: `${hotels.length} ${deps.vocab.brand} ${hotels.length === 1 ? deps.vocab.noun : deps.vocab.nounPlural}${where} — tap one to see rooms.`,
+            text: [
+                `${total} ${deps.vocab.brand} ${total === 1 ? deps.vocab.noun : deps.vocab.nounPlural}${where}`,
+                more > 0
+                    ? `— the ${hotels.length} below, and ${more} more. Narrow by city or country, or ask for a bigger \`limit\`.`
+                    : '— tap one to see rooms.',
+            ].join(' '),
         };
     }
     if (name === t.getHotel) {
         const wanted = str(args.hotel);
         const stay = asStay(args);
-        const detail = await deps.backend.getHotel(wanted, stay);
+        const detail = await deps.backend.getHotel(wanted, stay, identity(deps, ctx, key));
         if (!detail) {
             return {
-                structured: { view: 'hotel-not-found', ...common(deps), query: wanted },
+                structured: { view: 'hotel-not-found', ...common(deps, key), query: wanted },
                 text: `No ${deps.vocab.brand} ${deps.vocab.noun} by that name. ${t.listHotels} lists them.`,
             };
         }
@@ -515,7 +736,7 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
         const policies = await deps.backend.policies(h.id);
         const extras = await deps.backend.extrasFor(h.id, stay);
         const base = {
-            ...common(deps),
+            ...common(deps, key),
             hotel: {
                 ...h,
                 summary: description.text,
@@ -542,17 +763,48 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
                 text: detail.noRooms ?? 'Nothing is available for those nights.',
             };
         }
-        const rooms = detail.rooms.map((r) => ({
+        // ⚠️ THE ROOM COUNT FILTERS THE LIST, it does not just ride along. A guest
+        // who needs two rooms and is shown a type with one left finds out when the
+        // trip drops the line, which is later and worse than not offering it.
+        const roomsWanted = Math.max(1, Math.min(MAX_ROOMS_PER_LINE, Math.floor(Number(args.rooms) || 1)));
+        const enough = detail.rooms.filter((r) => r.roomsLeft >= roomsWanted);
+        if (enough.length === 0) {
+            return {
+                structured: {
+                    view: 'no-rooms',
+                    ...base,
+                    stay,
+                    rooms_wanted: roomsWanted,
+                    noRooms: `No room type here has ${roomsWanted} left for those nights.`,
+                },
+                text: `No room type at ${h.name} has ${roomsWanted} left for ${stay.checkIn} to ${stay.checkOut}.`,
+            };
+        }
+        const rooms = enough.map((r) => ({
             ...r,
             nightly: formatMoney(r.nightly),
             stayTotal: formatMoney(r.stayTotal),
             taxesAndFees: formatMoney(r.taxesAndFees),
+            // ⚠️ THE NUMBER THE GUEST IS LOOKING AT HAS TO BE THE ONE THEY ASKED FOR.
+            // With two rooms picked, the card was still showing one room's total and
+            // nothing said so - robin changed the count and watched the price not
+            // move (2026-09-18). Multiplied HERE, in minor units, because the card
+            // holds formatted strings and must never do arithmetic on money.
+            ...(roomsWanted > 1
+                ? { roomsTotal: formatMoney(multiplyMoney(r.stayTotal, roomsWanted)) }
+                : {}),
+            // ⚠️ THE PUBLIC RATE IS MONEY TOO. It went out as a raw
+            // `{ minor, currency }` and the card would have drawn "[object Object]"
+            // through the middle with a line - caught by the test that asserted the
+            // string, not by anyone looking at it.
+            ...(r.publicNightly ? { publicNightly: formatMoney(r.publicNightly) } : {}),
+            ...(r.publicStayTotal ? { publicStayTotal: formatMoney(r.publicStayTotal) } : {}),
         }));
         return {
-            structured: { view: 'hotel', ...base, stay, rooms },
+            structured: { view: 'hotel', ...base, stay, rooms, rooms_wanted: roomsWanted },
             text: [
-                `**${h.name}** · ${detail.rooms.length} room ${detail.rooms.length === 1 ? 'type' : 'types'} for ${stay.checkIn} to ${stay.checkOut}, ${stay.guests} guests.`,
-                ...detail.rooms.map((r) => `- ${r.name} — ${formatMoney(r.nightly)} a night, ${formatMoney(r.stayTotal)} for the stay incl. taxes and fees${r.refundable ? `, free to cancel${r.freeCancellationUntil ? ` until ${r.freeCancellationUntil.slice(0, 10)}` : ''}` : ', non-refundable'}`),
+                `**${h.name}** · ${enough.length} room ${enough.length === 1 ? 'type' : 'types'} for ${stay.checkIn} to ${stay.checkOut}, ${stay.guests} guests${roomsWanted > 1 ? `, ${roomsWanted} rooms` : ''}.`,
+                ...enough.map((r) => `- ${r.name} — ${formatMoney(r.nightly)} a night, ${formatMoney(r.stayTotal)} for the stay incl. taxes and fees${roomsWanted > 1 ? ` (${formatMoney(multiplyMoney(r.stayTotal, roomsWanted))} for ${roomsWanted} rooms)` : ''}${r.refundable ? `, free to cancel${r.freeCancellationUntil ? ` until ${r.freeCancellationUntil.slice(0, 10)}` : ''}` : ', non-refundable'}`),
                 deps.vocab.demo ? DEMO_NOTE : '',
             ]
                 .filter(Boolean)
@@ -564,7 +816,7 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
         const detail = await deps.backend.getHotel(wanted);
         if (!detail) {
             return {
-                structured: { view: 'hotel-not-found', ...common(deps), query: wanted },
+                structured: { view: 'hotel-not-found', ...common(deps, key), query: wanted },
                 text: `No ${deps.vocab.brand} ${deps.vocab.noun} by that name.`,
             };
         }
@@ -572,7 +824,7 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
         return {
             structured: {
                 view: 'extras',
-                ...common(deps),
+                ...common(deps, key),
                 hotel: detail.hotel,
                 extras: extras.map((e) => ({
                     ...e,
@@ -593,7 +845,12 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
         const detail = await deps.backend.getHotel(wanted);
         if (!detail) {
             return {
-                structured: { view: 'error', ...common(deps), error: 'hotel-not-found', query: wanted },
+                structured: {
+                    view: 'error',
+                    ...common(deps, key),
+                    error: 'hotel-not-found',
+                    query: wanted,
+                },
                 text: `No ${deps.vocab.brand} ${deps.vocab.noun} by that name.`,
             };
         }
@@ -604,10 +861,27 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
             const extra = extras.find((e) => e.id === extraRef || e.name.toLowerCase() === extraRef.toLowerCase());
             if (!extra) {
                 return {
-                    structured: { view: 'error', ...common(deps), error: 'no-such-extra', query: extraRef },
+                    structured: {
+                        view: 'error',
+                        ...common(deps, key),
+                        error: 'no-such-extra',
+                        query: extraRef,
+                    },
                     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,
@@ -616,12 +890,12 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
                 ...(isDay(str(args.day)) ? { day: str(args.day) } : {}),
             };
             deps.trips.set(key, line);
-            return currentTrip(deps, key);
+            return currentTrip(deps, key, identity(deps, ctx, key));
         }
         const roomRef = str(args.room);
         if (!roomRef) {
             return {
-                structured: { view: 'error', ...common(deps), error: 'no-room-named' },
+                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.`,
             };
         }
@@ -631,19 +905,24 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
         // desk. The trip stays as it was and the answer asks.
         if (!stay) {
             return {
-                structured: { view: 'needs-dates', ...common(deps), hotel: detail.hotel, room: roomRef },
+                structured: {
+                    view: 'needs-dates',
+                    ...common(deps, key),
+                    hotel: detail.hotel,
+                    room: roomRef,
+                },
                 text: 'Which nights? A room needs a check-in and a check-out date before it can go into the trip.',
             };
         }
         // 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);
+        const dated = await deps.backend.getHotel(hotelId, stay, identity(deps, ctx, key));
         if (!dated?.rooms) {
             return {
                 structured: {
                     view: 'needs-dates',
-                    ...common(deps),
+                    ...common(deps, key),
                     hotel: detail.hotel,
                     room: roomRef,
                     why: dated?.noRooms,
@@ -656,7 +935,7 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
             return {
                 structured: {
                     view: 'error',
-                    ...common(deps),
+                    ...common(deps, key),
                     error: 'no-such-room',
                     query: roomRef,
                     rooms: dated.rooms.map((r) => ({ id: r.id, name: r.name })),
@@ -664,6 +943,24 @@ 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,
@@ -671,14 +968,14 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
             stay,
             rooms: clampCount(args.rooms ?? 1, MAX_ROOMS_PER_LINE),
         });
-        return currentTrip(deps, key);
+        return currentTrip(deps, key, identity(deps, ctx, key));
     }
     if (name === t.viewTrip)
-        return currentTrip(deps, key);
+        return currentTrip(deps, key, identity(deps, ctx, key));
     if (name === t.clearTrip) {
         deps.trips.clear(key);
         return {
-            structured: { view: 'trip', ...common(deps), lines: [], count: 0, total: null },
+            structured: { view: 'trip', ...common(deps, key), lines: [], count: 0, total: null },
             text: 'The trip is empty.',
         };
     }
@@ -686,11 +983,18 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
         const lines = deps.trips.read(key);
         if (lines.length === 0) {
             return {
-                structured: { view: 'empty-trip', ...common(deps) },
+                structured: { view: 'empty-trip', ...common(deps, key) },
                 text: `There is nothing in the trip yet. ${t.addToTrip} puts room nights in it.`,
             };
         }
         const guest = { name: str(args.name), email: str(args.email) };
+        const missing = [!guest.name && 'a name', !guest.email.includes('@') && 'an email'].filter((x) => typeof x === 'string');
+        if (missing.length) {
+            return {
+                structured: { view: 'needs-guest', ...common(deps, key), missing },
+                text: `The booking needs ${missing.join(' and ')}. Ask the guest for ${missing.length > 1 ? 'them' : 'it'} - do not use a name or email you know from anywhere else.`,
+            };
+        }
         try {
             const booking = await deps.backend.requestBooking({ lines }, {
                 ...guest,
@@ -701,7 +1005,7 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
             return {
                 structured: {
                     view: 'booking',
-                    ...common(deps),
+                    ...common(deps, key),
                     booking: { ...booking, quote: quoteForCard(booking.quote) },
                     paid: false,
                     holdUntil: booking.holdUntil,
@@ -720,7 +1024,7 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
             return {
                 structured: {
                     view: 'error',
-                    ...common(deps),
+                    ...common(deps, key),
                     error: 'not-bookable',
                     detail: err.message,
                 },
@@ -729,11 +1033,11 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
         }
     }
     if (name === t.listBookings) {
-        const bookings = await deps.backend.listBookings(identity(ctx, args), typeof args.limit === 'number' ? args.limit : undefined);
+        const bookings = await deps.backend.listBookings(identity(deps, ctx, key, args), typeof args.limit === 'number' ? args.limit : undefined);
         return {
             structured: {
                 view: 'bookings',
-                ...common(deps),
+                ...common(deps, key),
                 bookings: bookings.map((b) => ({ ...b, quote: quoteForCard(b.quote) })),
                 count: bookings.length,
             },
@@ -744,18 +1048,18 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
     }
     if (name === t.previewCancellation || name === t.cancelBooking) {
         const ref = str(args.booking);
-        const who = identity(ctx, args);
+        const who = identity(deps, ctx, key, args);
         const preview = await deps.backend.previewCancellation(ref, who);
         if (!preview) {
             return {
-                structured: { view: 'booking-not-found', ...common(deps), query: ref },
+                structured: { view: 'booking-not-found', ...common(deps, key), query: ref },
                 text: 'No booking here matches that code. A booking made in another conversation needs the email it was made with.',
             };
         }
         const asPreview = {
             structured: {
                 view: 'cancellation-preview',
-                ...common(deps),
+                ...common(deps, key),
                 booking: { id: preview.bookingId, confirmationCode: preview.confirmationCode },
                 fee: formatMoney(preview.fee),
                 refund: formatMoney(preview.refund),
@@ -787,7 +1091,7 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
         return {
             structured: {
                 view: 'cancelled',
-                ...common(deps),
+                ...common(deps, key),
                 booking: { ...cancelled, quote: quoteForCard(cancelled.quote) },
                 fee: formatMoney(preview.fee),
                 refund: formatMoney(preview.refund),
@@ -797,12 +1101,122 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
             text: `${cancelled.confirmationCode} is cancelled. ${preview.fee.minor === 0 ? 'No fee.' : `The hotel charges ${formatMoney(preview.fee)}.`}`,
         };
     }
+    if (name === t.compare) {
+        const asks = Array.isArray(args.entries) ? args.entries : [];
+        const comparison = await compareHotels(deps.backend, asks.map((e) => ({
+            hotel: str(e.hotel),
+            bestFor: typeof e.bestFor === 'string' ? e.bestFor : undefined,
+            pros: e.pros,
+            cons: e.cons,
+        })), {
+            stay: asStay(args),
+            recommended: str(args.recommended) || undefined,
+            title: str(args.title) || undefined,
+        });
+        if (comparison.columns.length === 0) {
+            return {
+                structured: {
+                    view: 'nothing-to-compare',
+                    ...common(deps, key),
+                    dropped: comparison.dropped,
+                },
+                text: `None of those are ${deps.vocab.brand} ${deps.vocab.nounPlural}: ${comparison.dropped.map((d) => d.name).join(', ')}.`,
+            };
+        }
+        return {
+            structured: {
+                view: 'comparison',
+                ...common(deps, key),
+                ...comparison,
+                columns: comparison.columns.map((c) => ({
+                    ...c,
+                    hotel: { ...c.hotel, fromNightly: undefined },
+                })),
+            },
+            text: [
+                // The card carries the table; the text carries only what the model
+                // could not see before it asked - what was dropped, and why.
+                `${comparison.columns.length} side by side${comparison.stay ? ` for ${comparison.stay.checkIn} to ${comparison.stay.checkOut}` : ''}.`,
+                ...comparison.dropped.map((d) => `Left out: ${d.name} — ${d.why}`),
+                deps.vocab.demo ? DEMO_NOTE : '',
+            ]
+                .filter(Boolean)
+                .join('\n'),
+        };
+    }
+    if (name === t.itinerary) {
+        const days = Array.isArray(args.days) ? args.days : [];
+        const plan = await buildItinerary(deps.backend, days.map((d) => ({
+            label: str(d.label),
+            note: typeof d.note === 'string' ? d.note : undefined,
+            items: d.items ?? [],
+        })), { title: str(args.title), stay: asStay(args), trip: deps.trips.read(key) });
+        if (plan.days.length === 0) {
+            return {
+                structured: { view: 'empty-itinerary', ...common(deps, key) },
+                text: 'An itinerary needs at least one day with a label.',
+            };
+        }
+        // ⚠️ THE SENTENCE THE PLAN MUST NOT BE ALLOWED TO SKIP. A four-day plan
+        // with one room actually added looks exactly like a booking unless
+        // somebody says otherwise, and this counts it rather than describing it.
+        const gap = plan.planned === 0
+            ? 'Nothing on this plan is in the trip yet.'
+            : plan.inTrip === plan.planned
+                ? `All ${plan.planned} are in the trip.`
+                : `${plan.inTrip} of ${plan.planned} are in the trip; the rest are a plan, not a booking.`;
+        return {
+            structured: { view: 'itinerary', ...common(deps, key), ...plan, gap },
+            text: [
+                `**${plan.title}** · ${plan.days.length} ${plan.days.length === 1 ? 'day' : 'days'}. ${gap}`,
+                ...plan.dropped.map((d) => `Left out: ${d.name} — ${d.why}`),
+                deps.vocab.demo ? DEMO_NOTE : '',
+            ]
+                .filter(Boolean)
+                .join('\n'),
+        };
+    }
+    if (name === t.signIn) {
+        const number = str(args.number);
+        const surname = str(args.surname);
+        const member = await deps.backend.signInMember(number, surname);
+        if (!member) {
+            // ⚠️ NO TIER FOR A NUMBER THAT DID NOT MATCH. Being generous here - "close
+            // enough, have the discount" - is inventing a membership, and the guest
+            // would find out at the desk.
+            return {
+                structured: { view: 'member-not-found', ...common(deps, key), query: number },
+                text: `No ${deps.vocab.brand} membership matches that number and surname. Check both as they are printed; nothing else is needed - this connector never asks for a password.`,
+            };
+        }
+        deps.members.set(key, member);
+        return {
+            structured: { view: 'member', ...common(deps, key), member },
+            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.`,
+                deps.vocab.demo ? DEMO_NOTE : '',
+            ]
+                .filter(Boolean)
+                .join(' '),
+        };
+    }
+    if (name === t.signOut) {
+        const was = deps.members.read(key);
+        deps.members.clear(key);
+        return {
+            structured: { view: 'signed-out', ...common(deps, key) },
+            text: was
+                ? `Signed out of ${was.programme}. Rates are the public ones again; the trip and any bookings are untouched.`
+                : 'Nobody was signed in.',
+        };
+    }
     if (name === t.policies) {
         const wanted = str(args.hotel);
         const detail = await deps.backend.getHotel(wanted);
         if (!detail) {
             return {
-                structured: { view: 'hotel-not-found', ...common(deps), query: wanted },
+                structured: { view: 'hotel-not-found', ...common(deps, key), query: wanted },
                 text: `No ${deps.vocab.brand} ${deps.vocab.noun} by that name.`,
             };
         }
@@ -814,7 +1228,7 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
                 return {
                     structured: {
                         view: 'policy-missing',
-                        ...common(deps),
+                        ...common(deps, key),
                         hotel: detail.hotel,
                         topic,
                         topics: policies.map((p) => ({ topic: p.topic, title: p.title })),
@@ -825,11 +1239,11 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
                     text: `${detail.hotel.name} does not publish anything about that here.${detail.hotel.url ? ` Its own page: ${detail.hotel.url}` : ''}`,
                 };
             }
-            const fenced = hotelText(one.title, detail.hotel.name, one.text, POLICY_MAX);
+            const fenced = hotelText(one.title, detail.hotel.name, one.text, POLICY_MAX, deps.vocab.demo);
             return {
                 structured: {
                     view: 'policy',
-                    ...common(deps),
+                    ...common(deps, key),
                     hotel: detail.hotel,
                     topic: one.topic,
                     title: one.title,
@@ -840,12 +1254,12 @@ export const handleTool = async (deps, name, rawArgs, ctx) => {
             };
         }
         const all = policies
-            .map((p) => hotelText(p.title, detail.hotel.name, p.text, POLICY_MAX).fenced)
+            .map((p) => hotelText(p.title, detail.hotel.name, p.text, POLICY_MAX, deps.vocab.demo).fenced)
             .join('\n\n');
         return {
             structured: {
                 view: 'policies',
-                ...common(deps),
+                ...common(deps, key),
                 hotel: detail.hotel,
                 topics: policies.map((p) => ({
                     topic: p.topic,