@alexkroman1/aai-cli 5.13.2 → 6.1.0

package/dist/templates/retail/shared.test.ts

@@ -1,11 +1,12 @@
 import { describe, expect, test } from "vitest";
 import seedJson from "./seed.json";
-import type { RetailState, Store } from "./shared.ts";
-import { buildScriptBullets, DEMO_PERSONAS, storeView } from "./shared.ts";
+import type { RetailState } from "./shared.ts";
+import { buildScriptBullets, DEMO_PERSONAS, emptyRetailState, storeView } from "./shared.ts";
+import { seedStore } from "./store.ts";
 
 function makeState(authenticatedUserId: string | null): RetailState {
   return {
-    store: structuredClone(seedJson) as unknown as Store,
+    store: seedStore(),
     authenticatedUserId,
     callSeq: 3,
     activity: [{ seq: 3, tool: "get_order_details", summary: "read #W5866402", at: 0 }],
@@ -15,20 +16,21 @@ function makeState(authenticatedUserId: string | null): RetailState {
 
 describe("storeView", () => {
   test("projects nothing identifying before authentication", () => {
-    const view = storeView({ retail: makeState(null) });
+    const view = storeView(makeState(null));
     expect(view.customer).toBeNull();
     expect(view.orders).toEqual([]);
   });
 
-  test("an absent state slot degrades to an empty view", () => {
-    const view = storeView({});
+  test("an untouched session projects an empty view, not undefined", () => {
+    // The value `client.tsx` hoists as its pre-first-tool-call fallback.
+    const view = storeView(emptyRetailState());
     expect(view.customer).toBeNull();
     expect(view.orders).toEqual([]);
     expect(view.callSeq).toBe(0);
   });
 
   test("projects the authenticated customer and only their orders", () => {
-    const view = storeView({ retail: makeState("olivia_ito_3591") });
+    const view = storeView(makeState("olivia_ito_3591"));
     expect(view.customer?.name).toBe("Olivia Ito");
     expect(view.customer?.email).toBe("olivia.ito5204@example.com");
     expect(view.orders.map((o) => o.orderId).sort((a, b) => a.localeCompare(b))).toEqual(
@@ -40,13 +42,13 @@ describe("storeView", () => {
 
   test("projects live gift-card balances, since refunds move them", () => {
     const state = makeState("olivia_ito_3591");
-    const view = storeView({ retail: state });
+    const view = storeView(state);
     const card = view.customer?.paymentMethods.find((m) => m.id === "gift_card_7794233");
     expect(card?.balance).toBe(56);
   });
 
   test("no other customer's email, address, or payment method reaches the client", () => {
-    const view = storeView({ retail: makeState("olivia_ito_3591") });
+    const view = storeView(makeState("olivia_ito_3591"));
     const json = JSON.stringify(view);
     for (const leaked of [
       "aarav.anderson9752@example.com",
@@ -64,14 +66,14 @@ describe("storeView", () => {
   });
 
   test("carries callSeq, activity and focus through", () => {
-    const view = storeView({ retail: makeState("olivia_ito_3591") });
+    const view = storeView(makeState("olivia_ito_3591"));
     expect(view.callSeq).toBe(3);
     expect(view.activity).toHaveLength(1);
     expect(view.focus.orderId).toBe("#W5866402");
   });
 
   test("order totals sum the payments, not the items", () => {
-    const view = storeView({ retail: makeState("olivia_ito_3591") });
+    const view = storeView(makeState("olivia_ito_3591"));
     const delivered = view.orders.find((o) => o.orderId === "#W5866402");
     expect(delivered?.total).toBe(3203.78);
   });
@@ -83,7 +85,7 @@ describe("DEMO_PERSONAS", () => {
   });
 
   test("every persona's email, name and zip match its seed record", () => {
-    const users = Object.values((structuredClone(seedJson) as unknown as Store).users);
+    const users = Object.values(seedStore().users);
     for (const persona of DEMO_PERSONAS) {
       const user = users.find((u) => u.email === persona.email);
       expect.soft(user, `no seeded customer has email ${persona.email}`).toBeDefined();
@@ -105,12 +107,12 @@ describe("swapOptions", () => {
   test("empty when no order is focused", () => {
     const state = makeState("olivia_ito_3591");
     state.focus = {};
-    expect(storeView({ retail: state }).swapOptions).toEqual([]);
+    expect(storeView(state).swapOptions).toEqual([]);
   });
 
   test("lists available alternatives for the focused order's items", () => {
     // makeState focuses #W5866402 — Espresso Machine + Sneakers.
-    const view = storeView({ retail: makeState("olivia_ito_3591") });
+    const view = storeView(makeState("olivia_ito_3591"));
     expect(view.swapOptions).toHaveLength(2);
     const espresso = view.swapOptions.find((s) => s.itemId === "6242772310");
     expect(espresso?.itemName).toBe("Espresso Machine");
@@ -121,7 +123,7 @@ describe("swapOptions", () => {
   test("never offers an unavailable variant as a target", () => {
     const state = makeState("aarav_anderson_8794");
     state.focus = { orderId: "#W4316152" };
-    const view = storeView({ retail: state });
+    const view = storeView(state);
     const ids = view.swapOptions.flatMap((s) => s.alternatives.map((a) => a.itemId));
     // 6454334990 is a Tea Kettle variant with available: false.
     expect(ids).not.toContain("6454334990");
@@ -130,7 +132,7 @@ describe("swapOptions", () => {
   test("caps both axes so the payload stays bounded", () => {
     const state = makeState("aarav_anderson_8794");
     state.focus = { orderId: "#W9311069" }; // five items
-    const view = storeView({ retail: state });
+    const view = storeView(state);
     expect(view.swapOptions.length).toBeLessThanOrEqual(3);
     for (const option of view.swapOptions) {
       expect(option.alternatives.length).toBeLessThanOrEqual(4);
@@ -140,7 +142,7 @@ describe("swapOptions", () => {
   test("a focus on another customer's order projects nothing", () => {
     const state = makeState("olivia_ito_3591");
     state.focus = { orderId: "#W4316152" }; // aarav's
-    const view = storeView({ retail: state });
+    const view = storeView(state);
     expect(view.swapOptions).toEqual([]);
     expect(JSON.stringify(view)).not.toContain("#W4316152");
   });
@@ -153,8 +155,8 @@ describe("buildScriptBullets", () => {
     expect(bullets.join(" ")).toContain(DEMO_PERSONAS[0]?.zip ?? "");
   });
 
-  test("undefined state yields the pre-auth bullets", () => {
-    expect(buildScriptBullets(undefined).length).toBeGreaterThan(0);
+  test("an empty state yields the pre-auth bullets", () => {
+    expect(buildScriptBullets(emptyRetailState()).length).toBeGreaterThan(0);
   });
 
   test("a customer with pending orders is offered cancel and address change", () => {

package/dist/templates/retail/shared.ts

@@ -1,3 +1,5 @@
+import type { DeepReadonly } from "@alexkroman1/aai";
+
 // ─── Store types ─────────────────────────────────────────────────────────────
 // Field names are tau2's snake_case verbatim, because `seed.json` is tau2's
 // records unmodified. Renaming them here would mean transforming 107 KB of
@@ -129,7 +131,36 @@ export interface RetailState {
   focus: { orderId?: string; productId?: string };
 }
 
-export type StateSlot = { retail?: RetailState };
+/**
+ * The store as a READ hands it out: deep-frozen, and typed to say so.
+ *
+ * The projection and its helpers take this rather than {@link RetailState},
+ * which is the widening a deep-readonly slot forces and the reason it is worth
+ * doing: a mutable state still satisfies it, so `client.tsx` still projects
+ * `emptyRetailState()` and every `retailTool` body still passes its draft,
+ * while a projection helper that WOULD have mutated stops compiling instead of
+ * throwing at its first call.
+ */
+export type FrozenRetailState = DeepReadonly<RetailState>;
+
+/**
+ * A pristine, EMPTY store — no seed data.
+ *
+ * `store.ts`'s `createDefaultState` builds the real seeded state on top of
+ * this, so the shape is declared once. It lives here, apart from that, because
+ * `client.tsx` needs a `RetailState` for its pre-first-call fallback and must
+ * not import `store.ts`: that module pulls the 107 KB `seed.json`, which would
+ * then land in the browser bundle.
+ */
+export function emptyRetailState(): RetailState {
+  return {
+    store: { users: {}, orders: {}, products: {} },
+    authenticatedUserId: null,
+    callSeq: 0,
+    activity: [],
+    focus: {},
+  };
+}
 
 // ─── View types — exactly what crosses the wire ──────────────────────────────
 
@@ -249,13 +280,13 @@ export const DEMO_PERSONAS: readonly DemoPersona[] = [
 
 // ─── Projection ──────────────────────────────────────────────────────────────
 
-function paymentLabel(method: PaymentMethod): string {
+function paymentLabel(method: DeepReadonly<PaymentMethod>): string {
   if (method.source === "gift_card") return "Gift card";
   if (method.source === "paypal") return "PayPal";
   return `${method.brand} ending ${method.last_four}`;
 }
 
-function paymentMethodView(method: PaymentMethod): PaymentMethodView {
+function paymentMethodView(method: DeepReadonly<PaymentMethod>): PaymentMethodView {
   return {
     id: method.id,
     source: method.source,
@@ -267,7 +298,7 @@ function paymentMethodView(method: PaymentMethod): PaymentMethodView {
 /** Net of payments minus refunds — what the customer has actually paid. Items
  *  can't be summed instead: a modified order's items no longer match what was
  *  charged. */
-export function orderTotal(order: Order): number {
+export function orderTotal(order: DeepReadonly<Order>): number {
   const net = order.payment_history.reduce(
     (sum, p) => sum + (p.transaction_type === "payment" ? p.amount : -p.amount),
     0,
@@ -275,7 +306,7 @@ export function orderTotal(order: Order): number {
   return Math.round(net * 100) / 100;
 }
 
-function orderView(order: Order): OrderView {
+function orderView(order: DeepReadonly<Order>): OrderView {
   return {
     orderId: order.order_id,
     status: order.status,
@@ -295,7 +326,10 @@ function orderView(order: Order): OrderView {
  * an exchange sayable. Only available variants, only the focused order, and
  * capped on both axes so the payload stays bounded.
  */
-function swapOptionsFor(state: RetailState, order: Order | undefined): SwapOptionView[] {
+function swapOptionsFor(
+  state: FrozenRetailState,
+  order: DeepReadonly<Order> | undefined,
+): SwapOptionView[] {
   if (!order) return [];
   return order.items.slice(0, MAX_SWAP_ITEMS).map((item) => {
     const product = state.store.products[item.product_id];
@@ -321,16 +355,20 @@ function swapOptionsFor(state: RetailState, order: Order | undefined): SwapOptio
  *
  *  Only the authenticated customer is projected. The other five seeded
  *  customers' emails, addresses, and payment methods never leave the server,
- *  which is why `syncState` takes a projection rather than a boolean. */
-export function storeView(slot: StateSlot): StoreView {
-  const state = slot.retail;
-  const userId = state?.authenticatedUserId ?? null;
-  const user = userId ? state?.store.users[userId] : undefined;
-  const focusedOrderId = state?.focus.orderId;
+ *  which is why `syncState` takes a projection rather than a boolean.
+ *
+ *  Takes the state itself, not the slot: `retailSlot.projection` supplies a
+ *  real one even before the first tool call, so the optional chaining this
+ *  used to carry — which read as security gating and was not — is gone. The
+ *  gating that IS security is still here, on `user`. */
+export function storeView(state: FrozenRetailState): StoreView {
+  const userId = state.authenticatedUserId;
+  const user = userId ? state.store.users[userId] : undefined;
+  const focusedOrderId = state.focus.orderId;
   // Gated on `user`: an order is only ever projected for the customer on the
   // call, so a stale focus from before authentication cannot leak one.
   const focusedOrder =
-    state && user && focusedOrderId && user.orders.includes(focusedOrderId)
+    user && focusedOrderId && user.orders.includes(focusedOrderId)
       ? state.store.orders[focusedOrderId]
       : undefined;
 
@@ -346,7 +384,7 @@ export function storeView(slot: StateSlot): StoreView {
       : null,
     orders: user
       ? user.orders
-          .map((id) => state?.store.orders[id])
+          .map((id) => state.store.orders[id])
           .filter((o): o is Order => o !== undefined)
           .map(orderView)
       : [],
@@ -356,13 +394,13 @@ export function storeView(slot: StateSlot): StoreView {
     // though its details were already withheld from `orders`/`swapOptions`.
     focus: {
       ...(focusedOrder && focusedOrderId ? { orderId: focusedOrderId } : {}),
-      ...(state?.focus.productId ? { productId: state.focus.productId } : {}),
+      ...(state.focus.productId ? { productId: state.focus.productId } : {}),
     },
-    swapOptions: state ? swapOptionsFor(state, focusedOrder) : [],
-    callSeq: state?.callSeq ?? 0,
-    activity: state?.activity.slice(-MAX_ACTIVITY) ?? [],
+    swapOptions: swapOptionsFor(state, focusedOrder),
+    callSeq: state.callSeq,
+    activity: state.activity.slice(-MAX_ACTIVITY),
     scriptBullets: buildScriptBullets(state),
-    productCount: Object.keys(state?.store.products ?? {}).length,
+    productCount: Object.keys(state.store.products).length,
   };
 }
 
@@ -375,13 +413,13 @@ const MAX_BULLETS = 6;
  * that offers actions the data can't support — "return an item" to someone
  * with no delivered order — is worse than no list.
  */
-export function buildScriptBullets(state: RetailState | undefined): string[] {
-  const userId = state?.authenticatedUserId;
-  const user = userId ? state?.store.users[userId] : undefined;
+export function buildScriptBullets(state: FrozenRetailState): string[] {
+  const userId = state.authenticatedUserId;
+  const user = userId ? state.store.users[userId] : undefined;
 
   // Pre-auth: only the two ways in. The personas panel (a constant, rendered
   // straight from DEMO_PERSONAS) covers WHICH customer to be.
-  if (!(state && user)) {
+  if (!user) {
     const first = DEMO_PERSONAS[0];
     return [
       `"My email is ${first?.email ?? ""}"`,

package/dist/templates/retail/store.test.ts

@@ -1,4 +1,5 @@
-import type { ToolContext } from "@alexkroman1/aai";
+import { isToolFailure, type ToolContext } from "@alexkroman1/aai";
+import { createToolContext } from "@alexkroman1/aai/testing";
 import { describe, expect, test } from "vitest";
 import { z } from "zod";
 import {
@@ -10,31 +11,22 @@ import {
   findProduct,
   findUser,
   findVariant,
-  getState,
-  isError,
   isGiftCard,
   money,
   requireOwnOrder,
+  retailSlot,
   retailTool,
 } from "./store.ts";
 
-let sessionCounter = 0;
-
 function makeCtx(): ToolContext {
-  return {
-    sessionId: `test-session-${++sessionCounter}`,
-    send: () => {},
-    env: {},
-    state: {},
-    messages: [],
-  } as unknown as ToolContext;
+  return createToolContext();
 }
 
 describe("session state", () => {
-  test("getState seeds lazily and returns the same object on re-entry", () => {
+  test("the slot seeds lazily and returns the same object on re-entry", () => {
     const ctx = makeCtx();
-    const a = getState(ctx);
-    const b = getState(ctx);
+    const a = retailSlot.get(ctx);
+    const b = retailSlot.get(ctx);
     expect(a).toBe(b);
     expect(a.authenticatedUserId).toBeNull();
     expect(a.callSeq).toBe(0);
@@ -42,14 +34,15 @@ describe("session state", () => {
   });
 
   test("each session gets its own deep copy — a mutation cannot leak across sessions", () => {
-    const first = getState(makeCtx());
-    const order = first.store.orders["#W9300146"];
-    if (!order) throw new Error("fixture missing");
-    order.status = "cancelled";
-    const giftCard = first.store.users.aarav_anderson_8794?.payment_methods.gift_card_7245904;
-    if (giftCard?.source === "gift_card") giftCard.balance = 0;
-
-    const second = getState(makeCtx());
+    retailSlot.update(makeCtx(), (first) => {
+      const order = first.store.orders["#W9300146"];
+      if (!order) throw new Error("fixture missing");
+      order.status = "cancelled";
+      const giftCard = first.store.users.aarav_anderson_8794?.payment_methods.gift_card_7245904;
+      if (giftCard?.source === "gift_card") giftCard.balance = 0;
+    });
+
+    const second = retailSlot.get(makeCtx());
     expect(second.store.orders["#W9300146"]?.status).toBe("pending");
     const fresh = second.store.users.aarav_anderson_8794?.payment_methods.gift_card_7245904;
     expect(fresh?.source === "gift_card" && fresh.balance).toBe(17);
@@ -67,52 +60,52 @@ describe("money", () => {
 describe("lookups", () => {
   test("findUser resolves and reports a miss by id", () => {
     const state = createDefaultState();
-    expect(isError(findUser(state, "olivia_ito_3591"))).toBe(false);
+    expect(isToolFailure(findUser(state, "olivia_ito_3591"))).toBe(false);
     const miss = findUser(state, "nobody_1");
-    expect(isError(miss) && miss.error).toContain("nobody_1");
+    expect(isToolFailure(miss) && miss.error).toContain("nobody_1");
   });
 
   test("findOrder resolves and reports a miss", () => {
     const state = createDefaultState();
     const order = findOrder(state, "#W5866402");
-    expect(isError(order)).toBe(false);
-    expect(isError(order) ? null : order.status).toBe("delivered");
-    expect(isError(findOrder(state, "#W0000000"))).toBe(true);
+    expect(isToolFailure(order)).toBe(false);
+    expect(isToolFailure(order) ? null : order.status).toBe("delivered");
+    expect(isToolFailure(findOrder(state, "#W0000000"))).toBe(true);
   });
 
   test("findProduct and findVariant resolve within one product", () => {
     const state = createDefaultState();
     const product = findProduct(state, "9832717871");
-    if (isError(product)) throw new Error(product.error);
+    if (isToolFailure(product)) throw new Error(product.error);
     expect(product.name).toBe("Tea Kettle");
     const variant = findVariant(product, "3909406921");
-    expect(isError(variant) ? null : variant.price).toBe(98.25);
+    expect(isToolFailure(variant) ? null : variant.price).toBe(98.25);
     // A real item id, but of a different product.
-    expect(isError(findVariant(product, "4725166838"))).toBe(true);
+    expect(isToolFailure(findVariant(product, "4725166838"))).toBe(true);
   });
 
   test("findItem scans every product and returns both product and variant", () => {
     const state = createDefaultState();
     const found = findItem(state, "3909406921");
-    if (isError(found)) throw new Error(found.error);
+    if (isToolFailure(found)) throw new Error(found.error);
     expect(found.product.product_id).toBe("9832717871");
     expect(found.variant.price).toBe(98.25);
-    expect(isError(findItem(state, "0000000000"))).toBe(true);
+    expect(isToolFailure(findItem(state, "0000000000"))).toBe(true);
   });
 
   test("findPaymentMethod resolves on the owning user only", () => {
     const state = createDefaultState();
     const olivia = findUser(state, "olivia_ito_3591");
-    if (isError(olivia)) throw new Error(olivia.error);
-    expect(isError(findPaymentMethod(olivia, "gift_card_7794233"))).toBe(false);
+    if (isToolFailure(olivia)) throw new Error(olivia.error);
+    expect(isToolFailure(findPaymentMethod(olivia, "gift_card_7794233"))).toBe(false);
     // aarav's card is not olivia's.
-    expect(isError(findPaymentMethod(olivia, "gift_card_7245904"))).toBe(true);
+    expect(isToolFailure(findPaymentMethod(olivia, "gift_card_7245904"))).toBe(true);
   });
 
   test("isGiftCard narrows", () => {
     const state = createDefaultState();
     const olivia = findUser(state, "olivia_ito_3591");
-    if (isError(olivia)) throw new Error(olivia.error);
+    if (isToolFailure(olivia)) throw new Error(olivia.error);
     const card = olivia.payment_methods.gift_card_7794233;
     const paypal = olivia.payment_methods.paypal_8049766;
     expect(card && isGiftCard(card)).toBe(true);
@@ -124,15 +117,15 @@ describe("ownership and authentication guards", () => {
   test("authenticatedUser errors before authentication", () => {
     const state = createDefaultState();
     const result = authenticatedUser(state);
-    expect(isError(result) && result.error.toLowerCase()).toContain("find_user_id_by_email");
+    expect(isToolFailure(result) && result.error.toLowerCase()).toContain("find_user_id_by_email");
   });
 
   test("requireOwnOrder refuses another customer's order without revealing it", () => {
     const state = createDefaultState();
     state.authenticatedUserId = "olivia_ito_3591";
     const result = requireOwnOrder(state, "#W4316152"); // aarav's
-    expect(isError(result)).toBe(true);
-    if (!isError(result)) throw new Error("expected refusal");
+    expect(isToolFailure(result)).toBe(true);
+    if (!isToolFailure(result)) throw new Error("expected refusal");
     expect(result.error).not.toContain("aarav");
     expect(result.error).not.toContain("Tea Kettle");
   });
@@ -144,8 +137,8 @@ describe("ownership and authentication guards", () => {
     const missingId = "#W0000000";
     const foreign = requireOwnOrder(state, foreignId);
     const missing = requireOwnOrder(state, missingId);
-    expect(isError(foreign) && isError(missing)).toBe(true);
-    if (!(isError(foreign) && isError(missing))) throw new Error("expected refusals");
+    expect(isToolFailure(foreign) && isToolFailure(missing)).toBe(true);
+    if (!(isToolFailure(foreign) && isToolFailure(missing))) throw new Error("expected refusals");
     // Structural, not literal, equality: the messages legitimately differ by
     // the id the caller themselves passed in (that's not information about
     // the store — they already knew it), so comparing byte-for-byte would be
@@ -161,7 +154,7 @@ describe("ownership and authentication guards", () => {
     const state = createDefaultState();
     state.authenticatedUserId = "olivia_ito_3591";
     const result = requireOwnOrder(state, "#W5866402");
-    expect(isError(result) ? null : result.order_id).toBe("#W5866402");
+    expect(isToolFailure(result) ? null : result.order_id).toBe("#W5866402");
   });
 });
 
@@ -196,7 +189,7 @@ describe("retailTool", () => {
     const ctx = makeCtx();
     await echo.execute({ value: "a" }, ctx);
     await echo.execute({ value: "b" }, ctx);
-    const state = getState(ctx);
+    const state = retailSlot.get(ctx);
     expect(state.callSeq).toBe(2);
     expect(state.activity.map((a) => a.summary)).toEqual(["echoed a", "echoed b"]);
     expect(state.activity.map((a) => a.tool)).toEqual(["echo", "echo"]);
@@ -205,28 +198,30 @@ describe("retailTool", () => {
   test("a repeated identical call still changes the projection", async () => {
     const ctx = makeCtx();
     await echo.execute({ value: "same" }, ctx);
-    const first = getState(ctx).callSeq;
+    const first = retailSlot.get(ctx).callSeq;
     await echo.execute({ value: "same" }, ctx);
-    expect(getState(ctx).callSeq).toBeGreaterThan(first);
+    expect(retailSlot.get(ctx).callSeq).toBeGreaterThan(first);
   });
 
   test("defaults to requiring authentication and does not run execute when blocked", async () => {
     const ctx = makeCtx();
     const result = await gated.execute({}, ctx);
-    expect(isError(result) && result.error).toContain("find_user_id_by_email");
+    expect(isToolFailure(result) && result.error).toContain("find_user_id_by_email");
   });
 
   test("a blocked call is still logged and still bumps callSeq", async () => {
     const ctx = makeCtx();
     await gated.execute({}, ctx);
-    const state = getState(ctx);
+    const state = retailSlot.get(ctx);
     expect(state.callSeq).toBe(1);
     expect(state.activity[0]?.summary).toContain("blocked");
   });
 
   test("runs once authenticated", async () => {
     const ctx = makeCtx();
-    getState(ctx).authenticatedUserId = "olivia_ito_3591";
+    retailSlot.update(ctx, (state) => {
+      state.authenticatedUserId = "olivia_ito_3591";
+    });
     const result = await gated.execute({}, ctx);
     expect(result).toEqual({ ok: true });
   });
@@ -234,13 +229,13 @@ describe("retailTool", () => {
   test("an error result is logged as an error, not through summary()", async () => {
     const ctx = makeCtx();
     await failing.execute({}, ctx);
-    expect(getState(ctx).activity[0]?.summary).toBe("error: nope");
+    expect(retailSlot.get(ctx).activity[0]?.summary).toBe("error: nope");
   });
 
   test("activity is capped so a long call cannot grow the payload", async () => {
     const ctx = makeCtx();
     for (let i = 0; i < 15; i++) await echo.execute({ value: String(i) }, ctx);
-    const state = getState(ctx);
+    const state = retailSlot.get(ctx);
     expect(state.callSeq).toBe(15);
     expect(state.activity).toHaveLength(10);
     expect(state.activity[0]?.summary).toBe("echoed 5");
@@ -249,7 +244,7 @@ describe("retailTool", () => {
   test("concurrent calls serialize — no lost increments", async () => {
     const ctx = makeCtx();
     await Promise.all(Array.from({ length: 8 }, (_, i) => echo.execute({ value: String(i) }, ctx)));
-    const state = getState(ctx);
+    const state = retailSlot.get(ctx);
     expect(state.callSeq).toBe(8);
     expect(new Set(state.activity.map((a) => a.seq)).size).toBe(state.activity.length);
   });