@alexkroman1/aai-cli 6.11.0 → 8.0.0

package/dist/templates/travel-concierge/shared.ts

@@ -14,6 +14,7 @@
  * | `ToFlightBookingAssistant` & friends (delegation tools) | the four tools {@link SPECIALISTS} generates in `routing.ts` |
  * | `CompleteOrEscalate` | `complete_or_escalate`, which pops the same stack |
  * | `interrupt_before=["…_sensitive_tools"]` | {@link stageAction} + `confirm_action` |
+ * | a specialist node's BOUND tool set | {@link requireDesk}, checked by every desk tool |
  * | `fetch_user_flight_information` (sqlite) | `lookup_booking` over {@link seedTrip} |
  *
  * **The dialog stack is what keeps a long call on the rails.** Their insight is
@@ -23,7 +24,9 @@
  * session's prompt is fixed at connect — so the specialist's brief arrives as
  * the DELEGATION TOOL'S RESULT, which is the last thing the model reads before
  * it answers. The stack itself is real state either way, which is what
- * `complete_or_escalate` pops and what the sidebar renders.
+ * `complete_or_escalate` pops and what the sidebar renders — and what
+ * {@link requireDesk} makes binding, so the position is never merely a label on
+ * work that happened somewhere else.
  *
  * **`interrupt_before` becomes a spoken confirmation, and that is not a
  * downgrade.** Their graph halts before a sensitive tool and waits for a human
@@ -35,7 +38,15 @@
  * agent that can rebook a flight and one that can rebook a flight *by mistake*.
  */
 
-import { type DeepReadonly, pushCapped, sessionSlot, type ToolFailure } from "@alexkroman1/aai";
+import {
+  type DeepReadonly,
+  type DialogSpec,
+  dialog,
+  pushCapped,
+  sessionSlot,
+  type ToolContext,
+  type ToolFailure,
+} from "@alexkroman1/aai";
 
 // ─── The booking world ───────────────────────────────────────────────────────
 // Their notebook downloads a sqlite database of a real airline's schedule and
@@ -199,6 +210,19 @@ export interface Specialist {
   instructions: string;
 }
 
+/**
+ * Each brief spells the STAGE-then-read-back ORDER out, and that is a fix
+ * measured rather than a preference.
+ *
+ * The flight desk's used to say "read the fare change back to the caller before
+ * you change a ticket", which is true of `confirm_action` and reads as a rule
+ * about `update_ticket` — and live, that is how it was read: the desk searched,
+ * quoted a fare it had not staged, waited for a yes, and then called
+ * `confirm_action` with nothing waiting for it. Two of three runs never staged
+ * anything at all. The sentence to read back IS the staging tool's return
+ * value, so a brief that puts the read-back first describes a call the desk
+ * cannot make.
+ */
 export const SPECIALISTS: Record<SpecialistId, Specialist> = {
   flight: {
     title: "flight desk",
@@ -206,9 +230,22 @@ export const SPECIALISTS: Record<SpecialistId, Specialist> = {
       "You are now the flight desk. Handle searching and changing flights only.",
       "Search before you quote anything, and be persistent: if the first search",
       "finds nothing, widen it rather than telling the caller there is nothing.",
-      "Read the flight number, the day, the departure time and the fare change",
-      "back to the caller before you change a ticket. A ticket is only changed",
-      "once confirm_action has run.",
+      "update_ticket is a QUOTE, not a change: it moves nothing, so call it as",
+      "soon as you know which flight they want and never ask permission first.",
+      "Changing a ticket is TWO steps and never one: call update_ticket first —",
+      "it changes nothing and hands you the sentence to say — then read the",
+      "flight number, the day, the departure time and the fare change back to",
+      "the caller and ask them plainly to confirm. A ticket is only changed once",
+      "confirm_action has run, and confirm_action has nothing to apply until",
+      "update_ticket has staged it.",
+      "Never quote a departure time or a fare you did not just read out of a",
+      "tool result, and never end a turn on 'shall I confirm?' with nothing",
+      "staged: update_ticket goes out in the SAME turn as that question, before",
+      "you stop. There is nothing for a yes to apply until it has.",
+      "Your next action, right now, is a TOOL and not a sentence: call",
+      "update_ticket if you already know which flight they want, or",
+      "search_flights if you do not. Do not speak until one of them has",
+      "answered — anything you would say before that is invented.",
       "If the caller wants a hotel, a car or something to do, or changes their",
       "mind, call complete_or_escalate instead of improvising.",
     ].join(" "),
@@ -219,8 +256,18 @@ export const SPECIALISTS: Record<SpecialistId, Specialist> = {
       "You are now the hotel desk. Handle searching and booking hotels only.",
       "Ask which city and roughly what budget, then search. Offer at most three",
       "options out loud, cheapest first, with the neighbourhood and nightly rate.",
-      "Confirm the hotel, the number of nights and the total before booking.",
-      "A room is only held once confirm_action has run.",
+      "book_hotel is a QUOTE, not a change: it holds nothing, so call it as",
+      "soon as you know what the caller wants and never ask permission",
+      "first.",
+      "Booking is TWO steps and never one: call book_hotel first — it holds",
+      "nothing and hands you the sentence to say — then read the hotel, the",
+      "number of nights and the total back and ask them to confirm. A room is",
+      "only held once confirm_action has run, and confirm_action has nothing to",
+      "apply until book_hotel has staged it.",
+      "Your next action, right now, is a TOOL and not a sentence: call",
+      "book_hotel if you already know which room and how many nights, or",
+      "search_hotels if you do not. Do not speak until one of them has",
+      "answered — anything you would say before that is invented.",
       "If the caller wants flights, a car or an excursion, call",
       "complete_or_escalate.",
     ].join(" "),
@@ -230,8 +277,19 @@ export const SPECIALISTS: Record<SpecialistId, Specialist> = {
     instructions: [
       "You are now the car rental desk. Handle searching and booking cars only.",
       "Ask the city and how many days, then search. Name the vendor, the tier",
-      "and the daily rate, and confirm the total before booking.",
-      "A car is only reserved once confirm_action has run.",
+      "and the daily rate.",
+      "book_car_rental is a QUOTE, not a change: it holds nothing, so call it as",
+      "soon as you know what the caller wants and never ask permission",
+      "first.",
+      "Reserving is TWO steps and never one: call book_car_rental first — it",
+      "reserves nothing and hands you the sentence to say — then read the total",
+      "back and ask them to confirm. A car is only reserved once confirm_action",
+      "has run, and confirm_action has nothing to apply until book_car_rental",
+      "has staged it.",
+      "Your next action, right now, is a TOOL and not a sentence: call",
+      "book_car_rental if you already know which car and how many days, or",
+      "search_car_rentals if you do not. Do not speak until one of them has",
+      "answered — anything you would say before that is invented.",
       "If the caller wants flights, a hotel or an excursion, call",
       "complete_or_escalate.",
     ].join(" "),
@@ -243,7 +301,17 @@ export const SPECIALISTS: Record<SpecialistId, Specialist> = {
       "to do only. Ask the city and what kind of thing they enjoy, then search.",
       "Describe two or three options in a sentence each — this is the part of",
       "the call a caller actually wants to hear about.",
-      "A booking is only made once confirm_action has run.",
+      "book_excursion is a QUOTE, not a change: it holds nothing, so call it as",
+      "soon as you know what the caller wants and never ask permission",
+      "first.",
+      "Booking is TWO steps and never one: call book_excursion first — it books",
+      "nothing and hands you the sentence to say — then read it back and ask",
+      "them to confirm. A booking is only made once confirm_action has run, and",
+      "confirm_action has nothing to apply until book_excursion has staged it.",
+      "Your next action, right now, is a TOOL and not a sentence: call",
+      "book_excursion if you already know which one they want, or",
+      "search_excursions if you do not. Do not speak until one of them has",
+      "answered — anything you would say before that is invented.",
       "If the caller wants flights, a hotel or a car, call complete_or_escalate.",
     ].join(" "),
   },
@@ -339,8 +407,94 @@ export function note(state: TripState, entry: string): void {
   pushCapped(state.log, entry, MAX_LOG_ENTRIES);
 }
 
+// ─── The desk gate ───────────────────────────────────────────────────────────
+
+/**
+ * Is the call at `id`'s desk? A {@link ToolFailure} naming the way in if not.
+ *
+ * **This is the narrowing their graph gets for free, and it used to be prose.**
+ * Each specialist node there binds its own tool set, so a node physically cannot
+ * call another desk's tools; a voice session has ONE model with ONE tool list
+ * for its whole life, so for a long time the stack was real state that the model
+ * was merely ASKED to respect — `agent.ts` said so in place, and this guide's
+ * own eval predicted the failure. Measured: the prompt lost 0 of 5 live runs.
+ * The caller said "I need a hotel in Boston" and the model called
+ * `search_hotels` at the concierge desk every time, so `dialogState` said
+ * `primary` while the call was plainly doing hotel work — a stack the sidebar
+ * renders and nothing keeps true.
+ *
+ * A tool list cannot be narrowed mid-session, but a tool can REFUSE, and a
+ * refusal is a thing the model recovers from inside the same turn: it reads the
+ * failure, calls `to_hotel_assistant`, gets the desk's brief, and searches. So
+ * the delegation is now structural — every desk tool is reachable only from its
+ * own desk — and the brief the delegation returns is guaranteed to have been
+ * read before any of that desk's work happens, which was the whole point of
+ * handing it back as a tool result.
+ *
+ * It costs one wasted round trip the first time the model reaches past the
+ * stack, which is the right price: the alternative is a desk whose position is
+ * decoration.
+ */
+export function requireDesk(state: FrozenTripState, id: SpecialistId): ToolFailure | undefined {
+  const at = activeAssistant(state);
+  if (at === id) return undefined;
+  const here = at === "primary" ? "the main concierge" : SPECIALISTS[at].title;
+  return {
+    error:
+      `That tool belongs to the ${SPECIALISTS[id].title} and this call is at ${here}. ` +
+      `Nothing was searched, staged or booked. Call to_${id}_assistant with what the ` +
+      "caller asked for — its answer is that desk's brief — and then call this tool again. " +
+      "Do not tell the caller about any of this; they should hear one continuous conversation.",
+  };
+}
+
 // ─── The confirmation gate ───────────────────────────────────────────────────
 
+/**
+ * The gate as a STATE MAP — their `interrupt_before`, which is a graph construct.
+ *
+ * This port had to hand-roll it: a voice session had no graph, so "halt before a
+ * sensitive tool and resume on approval" became "every sensitive tool STAGES and
+ * `confirm_action` is the only thing that applies one". That half is unchanged
+ * and is still the mechanism — see {@link stageAction}. What the machine adds is
+ * the PRECONDITION on the other side of the halt: `confirm_action` and
+ * `cancel_action` are legal only while something is actually waiting, which was
+ * a null check inside each of them and is now `when`.
+ *
+ * **The staging tools are deliberately NOT gated on `browsing`.**
+ * {@link stageAction}'s refusal NAMES the sentence already waiting, which is what
+ * lets the model settle that one first and restage the rest; a state gate can
+ * only say "you are in awaitingConfirmation", since a state's instruction is
+ * static. So the specific refusal stays where it is and the flow follows it.
+ */
+const gateSpec = {
+  initial: "browsing",
+  states: {
+    browsing: {
+      instruction:
+        "Nothing is waiting for the caller's yes. Stage a change with a booking tool first.",
+      on: { STAGED: "awaitingConfirmation" },
+    },
+    awaitingConfirmation: {
+      instruction:
+        "Read the staged change back and hear a clear yes or no, then use confirm_action or cancel_action.",
+      on: { SETTLED: "browsing" },
+    },
+  },
+} as const satisfies DialogSpec;
+
+/**
+ * Whether a change is waiting on the caller's word.
+ *
+ * Its own slot, beside {@link tripSlot}: the flow holds the POSITION and the
+ * trip holds the staged action itself, because an inspectable
+ * {@link PendingAction} is what `confirm_action` re-derives the effect from. One
+ * tool call always moves both — {@link stageAction} sends `STAGED` in the same
+ * synchronous window it writes `pending` in, and the two settling tools send
+ * `SETTLED` only on success.
+ */
+export const gateFlow = dialog("gate", gateSpec);
+
 /**
  * Describe a staged action in one sentence, in the second person — this is
  * read aloud, so it is a question's worth of text and not a receipt.
@@ -396,6 +550,7 @@ export function describeAction(action: DeepReadonly<PendingAction>): string | To
  * model ask about that one first and restage the rest afterwards.
  */
 export function stageAction(
+  ctx: ToolContext,
   state: TripState,
   action: PendingAction,
 ):
@@ -413,6 +568,11 @@ export function stageAction(
     };
   }
   state.pending = action;
+  // The flow moves in the SAME synchronous window `pending` is written in, so
+  // the position and the payload cannot be observed disagreeing. `gateFlow` is
+  // a different slot from `tripSlot`, so this is not a nested write to the draft
+  // being held — the open-draft guard is per slot.
+  gateFlow.send(ctx, { type: "STAGED" });
   note(state, `Awaiting confirmation: ${described}`);
   return {
     awaitingConfirmation: true,
@@ -421,13 +581,21 @@ export function stageAction(
   };
 }
 
-/** Apply the staged action. The ONE place any of them takes effect. */
+/**
+ * Apply the staged action. The ONE place any of them takes effect.
+ *
+ * The "nothing is waiting" guard is gone: `confirm_action` is gated on
+ * `awaitingConfirmation`, so reaching here means something IS staged. The
+ * remaining `!action` arm is the flow and the payload disagreeing, which one
+ * synchronous window per transition is what rules out — it reports rather than
+ * throwing, because a live call is the wrong place to find out.
+ */
 export function applyPending(
   state: TripState,
 ): { applied: string; reference?: string } | ToolFailure {
   const action = state.pending;
   if (!action) {
-    return { error: "Nothing is waiting for confirmation. Use the booking tool first." };
+    return { error: "Nothing is staged after all — ask the caller again what they want." };
   }
   const described = describeAction(action);
   if (typeof described !== "string") return described;

package/dist/templates/travel-concierge/system-prompt.md

@@ -10,15 +10,21 @@ You do not do the specialist work yourself. There are four desks, and each one h
 How to run a call:
 
 - Start with `lookup_booking` so you know who you are speaking to and what they are holding.
-- The moment the caller raises something a desk owns, hand it over with that desk's tool and pass along what they asked for. Do not mention the transfer — the caller should hear one continuous conversation.
+- **A desk's tools only work while the call is at that desk, and they refuse from anywhere else.** So the moment the caller raises something a desk owns — flights, hotels, cars, excursions — your very next tool call is that desk's `to_…_assistant`, passing along what they asked for. Never a search or a booking first: at the concierge desk those refuse, and you have spent the caller's time on nothing.
+- Do not mention the transfer — the caller should hear one continuous conversation.
 - The desk's reply tells you how it works. Follow it until it is done, then use `complete_or_escalate` to come back.
 - Answer small talk, general questions and anything about the existing booking yourself.
 
 Confirming changes — this part matters:
 
 - Every tool that would change a booking stages the change instead of making it. Nothing has happened until `confirm_action` runs.
+- **Staging is a QUOTE, not a change, so it needs no permission.** `update_ticket`, `book_hotel`, `book_car_rental` and `book_excursion` price the request and hand you the sentence to say; they move nothing. Call the staging tool as soon as you know what the caller wants — you are getting them a quote, not doing the thing — and never ask whether you may.
+- **So the staging tool comes before the question, always.** "Shall I confirm?" is a question about a staged change, so the tool that stages it runs first and its answer is what you read back. Asking before staging is asking about something that does not exist, and the yes it earns has nothing to apply.
+- **Never end a turn on "shall I confirm?" with nothing staged.** The staging call and that question belong to the same turn: stage, then ask, in that order, before you stop. If you have already asked and the caller says anything other than no, stage it now — asking a second time does not stage it either, and a caller who has to repeat themselves is a caller nobody is helping.
+- **Never say a time, a fare or a total that did not come out of a tool result on this call**, and never say you are doing something — "I'll move your ticket", "I'm booking that" — before the tool that stages it has answered. If you need a number you have not got, call the desk's search first.
 - When a tool answers with `awaitingConfirmation`, read the change back in your own words and ask a yes-or-no question. Say the price.
 - If the caller says yes, call `confirm_action`. If they say no, or want different details, call `cancel_action`.
+- **`confirm_action` only ever answers a read-back you have just given.** If no tool has answered `awaitingConfirmation` on this call, there is nothing staged, `confirm_action` will refuse, and the caller's request is still waiting to be done — reach for the tool that stages it instead. A caller who says "yes" or "go ahead" before anything is staged is agreeing to the request they already made, not to a read-back.
 - Never call `confirm_action` on your own initiative, and never claim something is booked before it has run.
 
 Voice manners: numbers spoken out ("six forty" not "$640.00"), flight numbers letter by letter when reading them back, and one question at a time.

package/dist/templates/travel-concierge/tools/book_car_rental.ts

@@ -1,17 +1,20 @@
 import { z } from "zod";
-import { stageAction, tripSlot } from "../shared.ts";
+import { requireDesk, stageAction, tripSlot } from "../shared.ts";
 
 /** SENSITIVE — their `book_car_rental`, staged rather than applied. */
 export default tripSlot.updateTool({
   description:
-    "Reserve a rental car. This does NOT reserve anything yet — it stages the " +
-    "reservation so you can read the total back and hear a yes.",
+    "The CAR RENTAL DESK's booking tool: reserve a rental car. Only usable while the call " +
+    "is at that desk. This does NOT reserve anything yet — it stages the reservation so " +
+    "you can read the total back and hear a yes.",
   inputSchema: z.object({
     carId: z.string().max(20).describe("The car id from search_car_rentals, e.g. 'C2'"),
     days: z.number().int().min(1).max(60).describe("How many days"),
   }),
-  execute(args, trip) {
-    return stageAction(trip, {
+  execute(args, trip, ctx) {
+    const offDesk = requireDesk(trip, "car_rental");
+    if (offDesk) return offDesk;
+    return stageAction(ctx, trip, {
       kind: "book_car",
       carId: args.carId.toUpperCase(),
       days: args.days,

package/dist/templates/travel-concierge/tools/book_excursion.ts

@@ -1,16 +1,19 @@
 import { z } from "zod";
-import { stageAction, tripSlot } from "../shared.ts";
+import { requireDesk, stageAction, tripSlot } from "../shared.ts";
 
 /** SENSITIVE — their `book_excursion`, staged rather than applied. */
 export default tripSlot.updateTool({
   description:
-    "Book an excursion. This does NOT book anything yet — it stages the " +
-    "booking so you can read it back and hear a yes.",
+    "The EXCURSIONS DESK's booking tool: book an excursion. Only usable while the call is " +
+    "at that desk. This does NOT book anything yet — it stages the booking so you can read " +
+    "it back and hear a yes.",
   inputSchema: z.object({
     excursionId: z.string().max(20).describe("The excursion id from search_excursions, e.g. 'E2'"),
   }),
-  execute(args, trip) {
-    return stageAction(trip, {
+  execute(args, trip, ctx) {
+    const offDesk = requireDesk(trip, "excursion");
+    if (offDesk) return offDesk;
+    return stageAction(ctx, trip, {
       kind: "book_excursion",
       excursionId: args.excursionId.toUpperCase(),
     });

package/dist/templates/travel-concierge/tools/book_hotel.ts

@@ -1,17 +1,20 @@
 import { z } from "zod";
-import { stageAction, tripSlot } from "../shared.ts";
+import { requireDesk, stageAction, tripSlot } from "../shared.ts";
 
 /** SENSITIVE — their `book_hotel`, staged rather than applied. */
 export default tripSlot.updateTool({
   description:
-    "Hold a hotel room. This does NOT book anything yet — it stages the " +
-    "booking so you can read the total back and hear a yes.",
+    "The HOTEL DESK's booking tool: hold a hotel room. Only usable while the call is at " +
+    "that desk. This does NOT book anything yet — it stages the booking so you can read " +
+    "the total back and hear a yes.",
   inputSchema: z.object({
     hotelId: z.string().max(20).describe("The hotel id from search_hotels, e.g. 'H1'"),
     nights: z.number().int().min(1).max(30).describe("How many nights"),
   }),
-  execute(args, trip) {
-    return stageAction(trip, {
+  execute(args, trip, ctx) {
+    const offDesk = requireDesk(trip, "hotel");
+    if (offDesk) return offDesk;
+    return stageAction(ctx, trip, {
       kind: "book_hotel",
       hotelId: args.hotelId.toUpperCase(),
       nights: args.nights,

package/dist/templates/travel-concierge/tools/cancel_ticket.ts

@@ -1,4 +1,4 @@
-import { stageAction, tripSlot } from "../shared.ts";
+import { requireDesk, stageAction, tripSlot } from "../shared.ts";
 
 /**
  * SENSITIVE — their `cancel_ticket`. The most destructive thing on the call and
@@ -7,10 +7,13 @@ import { stageAction, tripSlot } from "../shared.ts";
  */
 export default tripSlot.updateTool({
   description:
-    "Cancel the caller's ticket outright. This does NOT cancel anything yet — " +
-    "it stages the cancellation so you can read it back and hear a yes.",
-  execute(_args, trip) {
+    "The FLIGHT DESK's cancellation tool: cancel the caller's ticket outright. Only usable " +
+    "while the call is at that desk. This does NOT cancel anything yet — it stages the " +
+    "cancellation so you can read it back and hear a yes.",
+  execute(_args, trip, ctx) {
+    const offDesk = requireDesk(trip, "flight");
+    if (offDesk) return offDesk;
     if (!trip.ticket) return { error: "There is no ticket to cancel." };
-    return stageAction(trip, { kind: "cancel_ticket" });
+    return stageAction(ctx, trip, { kind: "cancel_ticket" });
   },
 });

package/dist/templates/travel-concierge/tools/search_car_rentals.ts

@@ -1,15 +1,19 @@
-import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
-import { CAR_RENTALS, formatPrice } from "../shared.ts";
+import { CAR_RENTALS, formatPrice, requireDesk, tripSlot } from "../shared.ts";
 
 /** Their `search_car_rentals`, by city and tier. */
-export default tool({
-  description: "Search rental cars by city, and optionally by tier (compact, midsize, suv).",
+export default tripSlot.tool({
+  description:
+    "The CAR RENTAL DESK's search: cars by city, and optionally by tier (compact, midsize, " +
+    "suv). Only usable while the call is at that desk — from anywhere else it refuses, so " +
+    "call to_car_rental_assistant first.",
   inputSchema: z.object({
     city: z.string().max(80).describe("City to search, e.g. 'Boston'"),
     tier: z.string().max(40).describe("compact, midsize or suv").optional(),
   }),
-  execute(args) {
+  execute(args, trip) {
+    const offDesk = requireDesk(trip, "car_rental");
+    if (offDesk) return offDesk;
     const city = args.city.trim().toLowerCase();
     const tier = args.tier?.trim().toLowerCase();
     const cars = CAR_RENTALS.filter(

package/dist/templates/travel-concierge/tools/search_excursions.ts

@@ -1,11 +1,13 @@
-import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
-import { EXCURSIONS, formatPrice } from "../shared.ts";
+import { EXCURSIONS, formatPrice, requireDesk, tripSlot } from "../shared.ts";
 
 /** Their `search_trip_recommendations` — city plus a loose keyword, matched
  *  against the name and the kind so "boat" and "sail" both land. */
-export default tool({
-  description: "Find things to do in a city. The keyword is optional and matched loosely.",
+export default tripSlot.tool({
+  description:
+    "The EXCURSIONS DESK's search: things to do in a city, with an optional keyword matched " +
+    "loosely. Only usable while the call is at that desk — from anywhere else it refuses, so " +
+    "call to_excursion_assistant first.",
   inputSchema: z.object({
     city: z.string().max(80).describe("City to search, e.g. 'Boston'"),
     keyword: z
@@ -14,7 +16,9 @@ export default tool({
       .describe("What they enjoy, e.g. 'food', 'boat', 'history'")
       .optional(),
   }),
-  execute(args) {
+  execute(args, trip) {
+    const offDesk = requireDesk(trip, "excursion");
+    if (offDesk) return offDesk;
     const city = args.city.trim().toLowerCase();
     const keyword = args.keyword?.trim().toLowerCase();
     const inCity = EXCURSIONS.filter((e) => e.city.toLowerCase().includes(city));

package/dist/templates/travel-concierge/tools/search_flights.ts

@@ -1,6 +1,5 @@
-import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
-import { FLIGHTS, formatPrice } from "../shared.ts";
+import { FLIGHTS, formatPrice, requireDesk, tripSlot } from "../shared.ts";
 
 /**
  * Their `search_flights`, with the same "be generous" behaviour their flight
@@ -8,10 +7,12 @@ import { FLIGHTS, formatPrice } from "../shared.ts";
  * rather than an empty list, so the desk can say what it DOES fly instead of
  * "nothing found" — which is what sends a caller to a human.
  */
-export default tool({
+export default tripSlot.tool({
   description:
-    "Search the flight schedule. Match on any part of the route, e.g. " +
-    "'Boston' or 'Zurich to Boston'. Omit the route to hear everything.",
+    "The FLIGHT DESK's search: the schedule, matched on any part of the route, e.g. " +
+    "'Boston' or 'Zurich to Boston'. Omit the route to hear everything. Only usable while " +
+    "the call is at that desk — from anywhere else it refuses, so call to_flight_assistant " +
+    "first.",
   inputSchema: z.object({
     route: z
       .string()
@@ -20,7 +21,9 @@ export default tool({
       .optional(),
     maxFare: z.number().positive().describe("Only flights at or under this fare").optional(),
   }),
-  execute(args) {
+  execute(args, trip) {
+    const offDesk = requireDesk(trip, "flight");
+    if (offDesk) return offDesk;
     const needle = args.route?.trim().toLowerCase();
     const matched = FLIGHTS.filter(
       (f) =>

package/dist/templates/travel-concierge/tools/search_hotels.ts

@@ -1,16 +1,20 @@
-import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
-import { formatPrice, HOTELS } from "../shared.ts";
+import { formatPrice, HOTELS, requireDesk, tripSlot } from "../shared.ts";
 
 /** Their `search_hotels`, with `price_tier` collapsed to a nightly ceiling —
  *  a caller says "under two hundred", not "midscale". */
-export default tool({
-  description: "Search hotels by city, and optionally by the most they want to pay per night.",
+export default tripSlot.tool({
+  description:
+    "The HOTEL DESK's search: hotels by city, and optionally by the most they want to pay " +
+    "per night. Only usable while the call is at that desk — from anywhere else it refuses, " +
+    "so call to_hotel_assistant first.",
   inputSchema: z.object({
     city: z.string().max(80).describe("City to search, e.g. 'Boston'"),
     maxPerNight: z.number().positive().describe("Nightly ceiling in dollars").optional(),
   }),
-  execute(args) {
+  execute(args, trip) {
+    const offDesk = requireDesk(trip, "hotel");
+    if (offDesk) return offDesk;
     const city = args.city.trim().toLowerCase();
     const hotels = HOTELS.filter(
       (h) =>

package/dist/templates/travel-concierge/tools/update_ticket.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { stageAction, tripSlot } from "../shared.ts";
+import { requireDesk, stageAction, tripSlot } from "../shared.ts";
 
 /**
  * SENSITIVE — their `update_ticket_to_new_flight`, behind the confirmation
@@ -8,15 +8,18 @@ import { stageAction, tripSlot } from "../shared.ts";
  */
 export default tripSlot.updateTool({
   description:
-    "Move the caller's ticket to a different flight. This does NOT change the " +
-    "ticket — it stages the change so you can read it back and hear a yes.",
+    "The FLIGHT DESK's rebooking tool: move the caller's ticket to a different flight. " +
+    "Only usable while the call is at that desk. This does NOT change the ticket — it " +
+    "stages the change so you can read it back and hear a yes.",
   inputSchema: z.object({
     flightId: z.string().max(20).describe("The flight to move to, e.g. 'LX52'"),
   }),
-  execute(args, trip) {
+  execute(args, trip, ctx) {
+    const offDesk = requireDesk(trip, "flight");
+    if (offDesk) return offDesk;
     if (!trip.ticket) {
       return { error: "This caller has no ticket to move — it was cancelled on this call." };
     }
-    return stageAction(trip, { kind: "update_ticket", flightId: args.flightId.toUpperCase() });
+    return stageAction(ctx, trip, { kind: "update_ticket", flightId: args.flightId.toUpperCase() });
   },
 });