@alexkroman1/aai-cli 13.3.0 → 15.0.0

package/dist/templates/travel-concierge/agent.eval.test.ts

@@ -30,11 +30,11 @@
  */
 import agentDef from "virtual:aai/agent";
 import {
-  callsIn,
   describeTurn,
   type EvalSession,
   type EvalToolCall,
   lastStateIn,
+  toolCallsInTurns,
   toolNames,
   turnCalling,
 } from "@alexkroman1/aai-runtime/eval";
@@ -116,7 +116,7 @@ describeEval(agentDef, (test) => {
       // every turn's tool list AND tells the two findings apart: no
       // `update_ticket` at all, or calls that were all refused by the desk gate.
       const staging = turnCalling(turns, "update_ticket", stagedSomething);
-      const attempts = callsIn(turns).filter((call) => call.name === "update_ticket");
+      const attempts = toolCallsInTurns(turns).filter((call) => call.name === "update_ticket");
       // The staging call itself, by INDEX, because what follows it in the same
       // turn is the subject of the assertion below.
       const stagedAt = staging.toolCalls.findIndex(

package/dist/templates/travel-concierge/agent.test.ts

@@ -1,7 +1,12 @@
 /** The def a DEPLOYED agent runs: authored, plus what `tools/` declares. */
 import agentDef from "virtual:aai/agent";
 import type { ToolContext } from "@alexkroman1/aai";
-import { createToolContext, ok, okPosition, toolRunner } from "@alexkroman1/aai/testing";
+import {
+  createToolContext,
+  expectDialogOk,
+  expectToolOk,
+  toolRunner,
+} from "@alexkroman1/aai/testing";
 import { describe, expect, test } from "vitest";
 
 import {
@@ -196,11 +201,11 @@ describe("sensitive tools stage rather than act", () => {
     expect(gateFlow.position(ctx).state).toBe("awaitingConfirmation");
 
     // A gated tool answers the flow's POSITION wrapped around the body's own
-    // return value, so the applied sentence is under `result`. `okPosition`
+    // return value, so the applied sentence is under `result`. `expectDialogOk`
     // keeps the position and THROWS on a refusal, quoting it — where the cast
     // it replaces read `undefined` off the failure and died three assertions
     // later on a property of undefined.
-    const confirmed = okPosition<{ applied: string; reference: string }>(
+    const confirmed = expectDialogOk<{ applied: string; reference: string }>(
       await run("confirm_action", ctx),
     );
     expect(confirmed.result.applied).toContain("Harborview Suites");
@@ -225,7 +230,7 @@ describe("sensitive tools stage rather than act", () => {
     const ctx = makeCtx();
     await atDesk("flight", ctx);
     await run("update_ticket", { flightId: "LX54" }, ctx);
-    const dropped = okPosition<{ discarded: string }>(await run("cancel_action", ctx));
+    const dropped = expectDialogOk<{ discarded: string }>(await run("cancel_action", ctx));
     expect(dropped.result.discarded).toContain("LX54");
     expect(dropped.state).toBe("browsing");
 
@@ -291,9 +296,9 @@ describe("sensitive tools stage rather than act", () => {
     // A refused SECOND staging must not have moved the gate either — it was
     // already `awaitingConfirmation` and the refusal changed nothing.
     expect(gateFlow.position(ctx).state).toBe("awaitingConfirmation");
-    // `ok` is `okPosition` with `.result` taken off: this assertion is about
+    // `expectToolOk` is `expectDialogOk` with `.result` taken off: this assertion is about
     // what the apply DID, not about where the gate landed.
-    const applied = ok<{ applied: string }>(await run("confirm_action", ctx));
+    const applied = expectToolOk<{ applied: string }>(await run("confirm_action", ctx));
     expect(applied.applied).toContain("LX52");
     expect(stateOf(ctx).bookings).toEqual([]);
 
@@ -368,7 +373,10 @@ describe("search tools", () => {
     const all = (await run("search_hotels", { city: "Boston" }, ctx)) as {
       hotels: { perNight: string }[];
     };
-    expect(all.hotels.map((h) => h.perNight)).toEqual(["$180", "$265", "$340"]);
+    // Always to the cent: `formatMoney` is one shape at every desk, where
+    // this template's own `toLocaleString` copy dropped `.00` on a round
+    // number and kept it on a price with change.
+    expect(all.hotels.map((h) => h.perNight)).toEqual(["$180.00", "$265.00", "$340.00"]);
 
     const cheap = (await run("search_hotels", { city: "Boston", maxPerNight: 200 }, ctx)) as {
       hotels: { name: string }[];

package/dist/templates/travel-concierge/client.tsx

@@ -1,5 +1,5 @@
 import "@alexkroman1/aai-ui/styles.css";
-import { AutoScroll, client, useAgentState } from "@alexkroman1/aai-ui";
+import { AutoScroll, mountClient, useAgentState } from "@alexkroman1/aai-ui";
 import type { TripView } from "./shared.ts";
 import { SPECIALIST_IDS, SPECIALISTS, tripProjection } from "./shared.ts";
 
@@ -118,7 +118,7 @@ function ItinerarySidebar() {
   );
 }
 
-client({
+mountClient({
   name: "Swiss Air Concierge",
   sidebar: ItinerarySidebar,
   theme: {

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

@@ -6,7 +6,10 @@
  * `activeAssistant`, `applyPending`, `note`. Each is NAMED by a file under
  * `tools/`, which is what registers it: a tool's name is its file name, so
  * `tools/to_flight_assistant.ts` is one line handing {@link delegationTool} an
- * id, and `tools/confirm_action.ts` re-exports {@link confirmAction}.
+ * id, and `tools/confirm_action.ts` one line calling {@link confirmActionTool}.
+ * Every file in `tools/` therefore default-exports the RESULT of a call: a
+ * factory per tool rather than a shared const, so nothing here is a re-export
+ * — which is what `noExportedImports` would otherwise have to be told to allow.
  *
  * The delegation four are still generated rather than written out. The notebook
  * declares `ToFlightBookingAssistant`, `ToHotelBookingAssistant`,
@@ -77,33 +80,35 @@ export function delegationTool(id: SpecialistId): ToolDef {
  * a `done` tool will keep trying to answer things the desk has no tools for.
  * The `reason` is what the concierge is handed on the way back up.
  */
-export const completeOrEscalate = tripSlot.updateTool({
-  description:
-    "Hand the call back to the main concierge. Use this when the current desk's " +
-    "work is finished, when the caller changes the subject to something this " +
-    "desk does not handle, or when they change their mind.",
-  inputSchema: z.object({
-    reason: z
-      .string()
-      .max(300)
-      .describe("Why the call is going back — what is done, or what the caller now wants"),
-  }),
-  execute(args, trip) {
-    const left = activeAssistant(trip);
-    // `primary` stays at the bottom — the slot's `after` hook restores it if a
-    // pop ever empties the stack.
-    if (trip.dialogState.length > 1) trip.dialogState.pop();
-    note(trip, `← back to concierge: ${args.reason}`);
-    return {
-      returnedFrom: left === "primary" ? "concierge" : SPECIALISTS[left].title,
-      nowHandling: "concierge",
-      reason: args.reason,
-      instructions:
-        "You are the main concierge again. Pick up what the caller asked for; " +
-        "delegate again if it belongs to another desk.",
-    };
-  },
-});
+export function completeOrEscalateTool(): ToolDef {
+  return tripSlot.updateTool({
+    description:
+      "Hand the call back to the main concierge. Use this when the current desk's " +
+      "work is finished, when the caller changes the subject to something this " +
+      "desk does not handle, or when they change their mind.",
+    inputSchema: z.object({
+      reason: z
+        .string()
+        .max(300)
+        .describe("Why the call is going back — what is done, or what the caller now wants"),
+    }),
+    execute(args, trip) {
+      const left = activeAssistant(trip);
+      // `primary` stays at the bottom — the slot's `after` hook restores it if a
+      // pop ever empties the stack.
+      if (trip.dialogState.length > 1) trip.dialogState.pop();
+      note(trip, `← back to concierge: ${args.reason}`);
+      return {
+        returnedFrom: left === "primary" ? "concierge" : SPECIALISTS[left].title,
+        nowHandling: "concierge",
+        reason: args.reason,
+        instructions:
+          "You are the main concierge again. Pick up what the caller asked for; " +
+          "delegate again if it belongs to another desk.",
+      };
+    },
+  });
+}
 
 /**
  * `confirm_action` — the caller said yes.
@@ -121,14 +126,16 @@ export const completeOrEscalate = tripSlot.updateTool({
  * the body did NOT answer with a {@link ToolFailure}, so an application that
  * failed leaves the change staged and the caller still being asked.
  */
-export const confirmAction = gateFlow.tool({
-  description:
-    "Apply the change the caller has just confirmed out loud. Only call this " +
-    "after you have read the change back and heard a clear yes.",
-  when: "awaitingConfirmation",
-  send: { type: "SETTLED" },
-  execute: (_args, ctx) => tripSlot.update(ctx, (trip) => applyPending(trip)),
-});
+export function confirmActionTool(): ToolDef {
+  return gateFlow.tool({
+    description:
+      "Apply the change the caller has just confirmed out loud. Only call this " +
+      "after you have read the change back and heard a clear yes.",
+    when: "awaitingConfirmation",
+    send: { type: "SETTLED" },
+    execute: (_args, ctx) => tripSlot.update(ctx, (trip) => applyPending(trip)),
+  });
+}
 
 /**
  * `cancel_action` — the caller said no. Drops the staged action, changes nothing.
@@ -136,22 +143,24 @@ export const confirmAction = gateFlow.tool({
  * Gated for the same reason as `confirm_action`, and its own "nothing was
  * waiting" arm is gone with the same argument.
  */
-export const cancelAction = gateFlow.tool({
-  description:
-    "Discard the change the caller just declined. Call this when they say no, " +
-    "or when they want to change the details before confirming.",
-  when: "awaitingConfirmation",
-  send: { type: "SETTLED" },
-  execute: (_args, ctx) =>
-    tripSlot.update(ctx, (trip) => {
-      const action = trip.pending;
-      // Reachable only if the position and the payload disagree; see
-      // `applyPending`. Reported rather than thrown, mid-call.
-      if (!action) return { discarded: null, message: "Nothing was staged after all." };
-      trip.pending = null;
-      const described = describeAction(action);
-      const summary = typeof described === "string" ? described : action.kind;
-      note(trip, `Declined: ${summary}`);
-      return { discarded: summary, message: "Nothing was changed." };
-    }),
-});
+export function cancelActionTool(): ToolDef {
+  return gateFlow.tool({
+    description:
+      "Discard the change the caller just declined. Call this when they say no, " +
+      "or when they want to change the details before confirming.",
+    when: "awaitingConfirmation",
+    send: { type: "SETTLED" },
+    execute: (_args, ctx) =>
+      tripSlot.update(ctx, (trip) => {
+        const action = trip.pending;
+        // Reachable only if the position and the payload disagree; see
+        // `applyPending`. Reported rather than thrown, mid-call.
+        if (!action) return { discarded: null, message: "Nothing was staged after all." };
+        trip.pending = null;
+        const described = describeAction(action);
+        const summary = typeof described === "string" ? described : action.kind;
+        note(trip, `Declined: ${summary}`);
+        return { discarded: summary, message: "Nothing was changed." };
+      }),
+  });
+}

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

@@ -47,6 +47,7 @@ import {
   type ToolContext,
   type ToolFailure,
 } from "@alexkroman1/aai";
+import { formatMoney, plural } from "@alexkroman1/aai/utils";
 
 // ─── The booking world ───────────────────────────────────────────────────────
 // Their notebook downloads a sqlite database of a real airline's schedule and
@@ -180,11 +181,6 @@ export const EXCURSIONS: Excursion[] = [
   { id: "E4", name: "Lake Zurich cruise", city: "Zurich", kind: "boat", price: 52 },
 ];
 
-/** `$1,234` — one money format, so a spoken price and a rendered one agree. */
-export function formatPrice(amount: number): string {
-  return `$${amount.toLocaleString("en-US")}`;
-}
-
 // ─── The dialog stack ────────────────────────────────────────────────────────
 
 export const SPECIALIST_IDS = ["flight", "hotel", "car_rental", "excursion"] as const;
@@ -504,24 +500,24 @@ export function describeAction(action: DeepReadonly<PendingAction>): string | To
     case "update_ticket": {
       const flight = FLIGHTS.find((f) => f.id === action.flightId);
       if (!flight) return { error: `No flight ${action.flightId} in the schedule.` };
-      return `move your ticket to ${flight.id}, ${flight.route}, departing ${flight.departs}, at ${formatPrice(flight.fare)}`;
+      return `move your ticket to ${flight.id}, ${flight.route}, departing ${flight.departs}, at ${formatMoney(flight.fare)}`;
     }
     case "cancel_ticket":
       return "cancel your ticket entirely";
     case "book_hotel": {
       const hotel = HOTELS.find((h) => h.id === action.hotelId);
       if (!hotel) return { error: `No hotel ${action.hotelId}.` };
-      return `book ${hotel.name} in ${hotel.area} for ${action.nights} night${action.nights === 1 ? "" : "s"}, ${formatPrice(hotel.pricePerNight * action.nights)} total`;
+      return `book ${hotel.name} in ${hotel.area} for ${action.nights} ${plural(action.nights, "night")}, ${formatMoney(hotel.pricePerNight * action.nights)} total`;
     }
     case "book_car": {
       const car = CAR_RENTALS.find((c) => c.id === action.carId);
       if (!car) return { error: `No car ${action.carId}.` };
-      return `reserve the ${car.tier} from ${car.vendor} for ${action.days} day${action.days === 1 ? "" : "s"}, ${formatPrice(car.pricePerDay * action.days)} total`;
+      return `reserve the ${car.tier} from ${car.vendor} for ${action.days} ${plural(action.days, "day")}, ${formatMoney(car.pricePerDay * action.days)} total`;
     }
     case "book_excursion": {
       const excursion = EXCURSIONS.find((e) => e.id === action.excursionId);
       if (!excursion) return { error: `No excursion ${action.excursionId}.` };
-      return `book ${excursion.name} at ${formatPrice(excursion.price)}`;
+      return `book ${excursion.name} at ${formatMoney(excursion.price)}`;
     }
     // Unreachable while `PendingAction` is exhausted above — and the arm a new
     // member of the union lands in until it has one of its own, which is a
@@ -627,11 +623,11 @@ export function applyPending(
       state.bookings.push({
         kind: "hotel",
         reference,
-        summary: `${hotel.name} (${hotel.area}), ${action.nights} night${action.nights === 1 ? "" : "s"}`,
+        summary: `${hotel.name} (${hotel.area}), ${action.nights} ${plural(action.nights, "night")}`,
         price,
       });
       note(state, `Hotel booked: ${hotel.name} — ${reference}`);
-      return { applied: `${hotel.name} booked, ${formatPrice(price)}.`, reference };
+      return { applied: `${hotel.name} booked, ${formatMoney(price)}.`, reference };
     }
     case "book_car": {
       const car = CAR_RENTALS.find((c) => c.id === action.carId);
@@ -640,12 +636,12 @@ export function applyPending(
       state.bookings.push({
         kind: "car",
         reference,
-        summary: `${car.vendor} ${car.tier}, ${action.days} day${action.days === 1 ? "" : "s"}`,
+        summary: `${car.vendor} ${car.tier}, ${action.days} ${plural(action.days, "day")}`,
         price,
       });
       note(state, `Car reserved: ${car.vendor} ${car.tier} — ${reference}`);
       return {
-        applied: `${car.tier} from ${car.vendor} reserved, ${formatPrice(price)}.`,
+        applied: `${car.tier} from ${car.vendor} reserved, ${formatMoney(price)}.`,
         reference,
       };
     }
@@ -659,7 +655,7 @@ export function applyPending(
         price: excursion.price,
       });
       note(state, `Excursion booked: ${excursion.name} — ${reference}`);
-      return { applied: `${excursion.name} booked, ${formatPrice(excursion.price)}.`, reference };
+      return { applied: `${excursion.name} booked, ${formatMoney(excursion.price)}.`, reference };
     }
     // Same as `describeAction`: unreachable today, and a refusal rather than a
     // silent no-op for whatever the union grows next.

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

@@ -4,4 +4,6 @@
  * gives it its name.
  */
 
-export { cancelAction as default } from "../routing.ts";
+import { cancelActionTool } from "../routing.ts";
+
+export default cancelActionTool();

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

@@ -4,4 +4,6 @@
  * gives it its name.
  */
 
-export { completeOrEscalate as default } from "../routing.ts";
+import { completeOrEscalateTool } from "../routing.ts";
+
+export default completeOrEscalateTool();

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

@@ -4,4 +4,6 @@
  * gives it its name.
  */
 
-export { confirmAction as default } from "../routing.ts";
+import { confirmActionTool } from "../routing.ts";
+
+export default confirmActionTool();

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

@@ -1,4 +1,5 @@
-import { FLIGHTS, formatPrice, tripSlot } from "../shared.ts";
+import { formatMoney } from "@alexkroman1/aai/utils";
+import { FLIGHTS, tripSlot } from "../shared.ts";
 
 /**
  * Their `fetch_user_flight_information`, which the notebook runs ONCE and
@@ -22,13 +23,13 @@ export default tripSlot.tool({
               route: flight.route,
               departs: flight.departs,
               arrives: flight.arrives,
-              fare: formatPrice(flight.fare),
+              fare: formatMoney(flight.fare),
             }
           : null,
       bookings: trip.bookings.map((b) => ({
         reference: b.reference,
         what: b.summary,
-        price: formatPrice(b.price),
+        price: formatMoney(b.price),
       })),
     };
   },

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

@@ -1,5 +1,6 @@
+import { formatMoney } from "@alexkroman1/aai/utils";
 import { z } from "zod";
-import { CAR_RENTALS, formatPrice, requireDesk, tripSlot } from "../shared.ts";
+import { CAR_RENTALS, requireDesk, tripSlot } from "../shared.ts";
 
 /** Their `search_car_rentals`, by city and tier. */
 export default tripSlot.tool({
@@ -30,7 +31,7 @@ export default tripSlot.tool({
         id: c.id,
         vendor: c.vendor,
         tier: c.tier,
-        perDay: formatPrice(c.pricePerDay),
+        perDay: formatMoney(c.pricePerDay),
       })),
     };
   },

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

@@ -1,5 +1,6 @@
+import { formatMoney } from "@alexkroman1/aai/utils";
 import { z } from "zod";
-import { EXCURSIONS, formatPrice, requireDesk, tripSlot } from "../shared.ts";
+import { EXCURSIONS, 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. */
@@ -34,7 +35,7 @@ export default tripSlot.tool({
         id: e.id,
         name: e.name,
         kind: e.kind,
-        price: formatPrice(e.price),
+        price: formatMoney(e.price),
       })),
     };
   },

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

@@ -1,5 +1,6 @@
+import { formatMoney } from "@alexkroman1/aai/utils";
 import { z } from "zod";
-import { FLIGHTS, formatPrice, requireDesk, tripSlot } from "../shared.ts";
+import { FLIGHTS, requireDesk, tripSlot } from "../shared.ts";
 
 /**
  * Their `search_flights`, with the same "be generous" behaviour their flight
@@ -38,7 +39,7 @@ export default tripSlot.tool({
         route: f.route,
         departs: f.departs,
         arrives: f.arrives,
-        fare: formatPrice(f.fare),
+        fare: formatMoney(f.fare),
         seatsLeft: f.seatsLeft,
       })),
     };

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

@@ -1,5 +1,6 @@
+import { formatMoney } from "@alexkroman1/aai/utils";
 import { z } from "zod";
-import { formatPrice, HOTELS, requireDesk, tripSlot } from "../shared.ts";
+import { 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". */
@@ -33,7 +34,7 @@ export default tripSlot.tool({
         name: h.name,
         area: h.area,
         stars: h.stars,
-        perNight: formatPrice(h.pricePerNight),
+        perNight: formatMoney(h.pricePerNight),
       })),
     };
   },

package/dist/templates/web-researcher/agent.test.ts

@@ -0,0 +1,130 @@
+/** The def a DEPLOYED agent runs: authored, plus what `system-prompt.md` says. */
+import agentDef from "virtual:aai/agent";
+import { toAgentConfig } from "@alexkroman1/aai/manifest";
+import { describe, expect, test } from "vitest";
+import promptFile from "./system-prompt.md?raw";
+
+/**
+ * What a starter's spec may assert.
+ *
+ * `aai build` runs these tests before it bundles, so an assertion pinning the
+ * template's own identity — its literal name, its greeting, its voice, its
+ * model — turns a user's first customization into a build failure in a file
+ * they never wrote. Every test here therefore asserts a property that survives
+ * those edits, on the RESOLVED config rather than on the def's empty fields.
+ *
+ * What is left to `agent.eval.test.ts` is everything that needs a model: that
+ * Scout SEARCHES before answering a fact it is sure of, that the outlet it
+ * names appeared in results it actually read, and that the SSRF screen refuses
+ * a private address through the agent's own executor. Those are behaviour, and
+ * this tier may not reach the network at all — which is also why nothing here
+ * runs `web_search`. What a unit test can say is that the capability and the
+ * document that instructs it are both still THERE, which is the half that
+ * regresses in a diff rather than in a model.
+ *
+ * The def therefore comes from `virtual:aai/agent` rather than from
+ * `./agent.ts`: the prompt file is applied by the BUILD, so the raw default
+ * export carries the framework prompt and every claim below would be measuring
+ * an agent nobody deploys. This template has no `tools/` directory, so that
+ * import is also the file's existence check — `deployedAgent` is handed the
+ * prompt and nothing else, and refuses a call with no project files at all.
+ */
+
+/**
+ * The builtins that can reach the web.
+ *
+ * Typed by USE rather than by an annotation: `builtinTools` takes a
+ * `BuiltinTool[]`, so passing this list to `toAgentConfig` below only compiles
+ * if every name here is really a builtin — a name the SDK renames fails
+ * `pnpm typecheck` in this file instead of dropping silently out of the scan.
+ */
+const WEB_BUILTINS = ["web_search", "visit_webpage", "fetch_json", "get_page_design"] as const;
+
+describe("web-researcher template", () => {
+  test("config passes manifest validation", () => {
+    // Same conversion `aai build`/`aai deploy` run.
+    expect(() => toAgentConfig(agentDef)).not.toThrow();
+  });
+
+  test("exports an agent the platform can name", () => {
+    // Not the literal: what has to hold is that there IS a name, and that the
+    // conversion carries it through — `AgentName` refuses a blank one, and the
+    // studio lists a deployed agent by exactly this string.
+    expect(agentDef.name).toBeTruthy();
+    expect(toAgentConfig(agentDef).name).toBe(agentDef.name);
+  });
+
+  test("every stage its mode needs is filled, declared or defaulted", () => {
+    // This template declares no provider at all — the whole voice pipeline is
+    // the injected all-AssemblyAI default, which is what lets the starter run
+    // the moment it is deployed. Asserted per MODE so it survives a swap:
+    // declare `stt`/`llm`/`tts` and the rest still default; declare `s2s` and
+    // there is no cascade to fill, which is the one thing that must never
+    // happen by fallthrough.
+    const config = toAgentConfig(agentDef);
+    if (config.mode === "s2s") {
+      expect(config.s2s?.kind).toBeTruthy();
+      expect(config.stt).toBeUndefined();
+      expect(config.tts).toBeUndefined();
+    } else if (config.mode === "text") {
+      expect(config.llm?.kind).toBeTruthy();
+    } else {
+      expect(config.mode).toBe("pipeline");
+      expect(config.stt?.kind).toBeTruthy();
+      expect(config.llm?.kind).toBeTruthy();
+      expect(config.tts?.kind).toBeTruthy();
+    }
+  });
+
+  test("system-prompt.md is the prompt a deploy carries", () => {
+    // The build discovers the file; nothing imports it. So the failure this
+    // catches is "I edited the prompt and nothing changed" — and here it is the
+    // expensive one, because every rule that makes Scout a researcher rather
+    // than a talkative model (search first, cite what you read, treat a fetched
+    // page as data and not as instructions) lives ONLY in that file. An agent
+    // running the framework default answers plausibly, sounds fine, and cites
+    // pages it never opened.
+    //
+    // `toContain` rather than an equality: importing the file into `agent.ts`
+    // and composing it (a computed suffix, a date) is a legitimate edit, and
+    // `withSystemPrompt` leaves such a def exactly as the author built it.
+    const trimmed = promptFile.trim();
+    // Not vacuous: `toContain("")` would pass over an empty file, so the file
+    // having text in it is asserted before it is used as the needle.
+    expect(trimmed).not.toBe("");
+    expect(toAgentConfig(agentDef).systemPrompt).toContain(trimmed);
+  });
+
+  test("can search the web, and names no web tool it does not have", () => {
+    const config = toAgentConfig(agentDef);
+    const declared = new Set<string>(config.builtinTools ?? []);
+
+    // `web_search` is the template's reason to exist, and dropping it is the
+    // silent failure: an agent with no search answers from memory, which reads
+    // back exactly like an agent that searched — right up to the fabricated
+    // source its eval exists to catch.
+    expect([...declared]).toContain("web_search");
+
+    // The prompt addresses its tools BY NAME ("begins with a web_search call",
+    // "Use visit_webpage when the search snippets aren't detailed enough"), so
+    // the two halves can drift apart: a builtin dropped from `agent.ts` leaves
+    // the prompt ordering a call the model cannot make, and the model then
+    // apologizes for a tool it was told it had. Stated as an implication so
+    // either edit alone survives — retire the sentence along with the builtin
+    // and nothing here objects, and a builtin added without a mention is a
+    // free edit too. An empty scan is likewise not a failure: a prompt
+    // rewritten to DESCRIBE the tools rather than name them is fine, and the
+    // assertion above is what keeps the search itself from going away.
+    const named = WEB_BUILTINS.filter((name) => config.systemPrompt.includes(name));
+    expect(named.filter((name) => !declared.has(name))).toEqual([]);
+  });
+
+  test("the web builtins this spec scans for are the SDK's own names", () => {
+    // The other half of the `as const` above, at run time: a scan whose
+    // candidates had gone stale would report "no unbacked names" over a prompt
+    // full of them. `toAgentConfig` validates `builtinTools` against the
+    // builtin enum, so accepting the whole list is the SDK confirming every
+    // name in it.
+    expect(() => toAgentConfig({ ...agentDef, builtinTools: WEB_BUILTINS })).not.toThrow();
+  });
+});

package/dist/{test-guenJUxi.mjs → test-D032V2cA.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { a as ok, n as fail } from "./_output-DbJt9gsl.mjs";
+import { a as ok, n as fail } from "./_output-DBP9Op_d.mjs";
 import { n as log, r as notify } from "./_ui-DCt4qZrk.mjs";
-import { i as errorCode, o as errorMessage$1, r as binFromPackageJson } from "./_utils-Dhd058D9.mjs";
+import { a as errorCode, i as compareCodeUnits, l as formatCappedList, r as binFromPackageJson, s as errorMessage$1 } from "./_utils-D5JGcjiW.mjs";
 import { createRequire } from "node:module";
 import { existsSync, readdirSync } from "node:fs";
 import path from "node:path";
@@ -140,11 +140,6 @@ function coveredList(ran) {
 	if (ran === false) return [];
 	return typeof ran === "string" ? [ran] : ran;
 }
-/** Code-unit comparison — see {@link projectSpecFiles} for why not `localeCompare`. */
-function compareCodeUnits(a, b) {
-	if (a < b) return -1;
-	return a > b ? 1 : 0;
-}
 /** One directory of {@link projectSpecFiles}, recursing into the ones that count. */
 function collectSpecs(dir, prefix, out) {
 	let entries;
@@ -160,14 +155,6 @@ function collectSpecs(dir, prefix, out) {
 		} else if (SPEC_FILE_RE.test(e.name) && !e.name.includes(".eval.test.")) out.push(rel);
 	}
 }
-/** How many unrun spec names a message prints before it starts counting. */
-const MAX_NAMED_SPECS = 10;
-/** The unrun set as one phrase — capped, because a project may hold hundreds. */
-function formatSpecList(files) {
-	const named = files.slice(0, MAX_NAMED_SPECS).join(", ");
-	const rest = files.length - MAX_NAMED_SPECS;
-	return rest > 0 ? `${named}, and ${rest} more` : named;
-}
 /**
 * The remedy, named the same way wherever the narrowing is reported.
 *
@@ -191,7 +178,7 @@ function warnUnrunSpecs(cwd, ran) {
 	if (skipped.length === 0) return;
 	const ranList = coveredList(ran);
 	const preamble = ranList.length === 0 ? `No agent.test.ts, so vitest ran nothing. ${skipped.length} spec file(s) exist and were NOT run:` : `vitest ran ${ranList.join(", ")} only. ${skipped.length} other spec file(s) were NOT run:`;
-	notify("warn", `${preamble} ${formatSpecList(skipped)}. ${WIDEN_HINT}`);
+	notify("warn", `${preamble} ${formatCappedList(skipped)}. ${WIDEN_HINT}`);
 }
 /**
 * Execute agent tests and return structured result.
@@ -249,7 +236,7 @@ async function executeTest(cwd, opts = {}) {
 */
 function incomplete(ran, unrun) {
 	const preamble = ran === false ? `\`aai test\` found no agent.test.ts, so it ran nothing, but ${unrun.length} spec file(s) exist` : `\`aai test\` ran ${ran.join(", ")} only — ${unrun.length} other spec file(s) in this project were not run`;
-	return fail("incomplete_run", `${preamble}: ${formatSpecList(unrun)}. An unrun spec is not a passing one, so this is not a green result.`, WIDEN_HINT);
+	return fail("incomplete_run", `${preamble}: ${formatCappedList(unrun)}. An unrun spec is not a passing one, so this is not a green result.`, WIDEN_HINT);
 }
 //#endregion
 export { TEST_FILES, classifyVitestError, executeTest, runVitest };