@alexkroman1/aai-cli 5.13.2 → 5.14.0

package/dist/templates/retail/agent.ts

@@ -1,7 +1,6 @@
 import { agent } from "@alexkroman1/aai";
-import type { StateSlot } from "./shared.ts";
 import { storeView } from "./shared.ts";
-import { createDefaultState } from "./store.ts";
+import { retailSlot, type StateSlot } from "./store.ts";
 import systemPrompt from "./system-prompt.md?raw";
 import { cancelPendingOrder } from "./tools/cancel_pending_order.ts";
 import { exchangeDeliveredOrderItems } from "./tools/exchange_delivered_order_items.ts";
@@ -27,18 +26,16 @@ export default agent({
   // overridden below; `llm` and `tts` take the defaults.
 
   // The store lives in ctx.state, one pristine copy per session — callers must
-  // not see each other's cancellations. Wrapped in the `StateSlot` shape
-  // `store.ts`'s `getState`/`shared.ts`'s `storeView` both key off — `agent()`
-  // infers its session-state type parameter from BOTH `state` and `syncState`,
-  // and `StateSlot`'s `retail` field is optional (a "weak type"), so handing
-  // it a bare `RetailState` with no properties in common fails that inference
-  // rather than an ordinary structural check.
-  state: (): StateSlot => ({ retail: createDefaultState() }),
+  // not see each other's cancellations. Declaring `state` (rather than letting
+  // the slot install itself on first access) means the session's store exists
+  // before the first tool call, so a resumed connection has something to
+  // project; the slot owns the shape either way.
+  state: (): StateSlot => ({ [retailSlot.key]: retailSlot.create() }),
 
   // One projection pushed after every tool call. It is a projection, not a
   // flag, because the state holds all six seeded customers and only the
   // authenticated one may reach the browser.
-  syncState: storeView,
+  syncState: retailSlot.projection(storeView),
 
   // Callers read order numbers and ten-digit item numbers in bursts with pauses
   // inside one utterance ("W seven six seven … eight oh seven two"). The default

package/dist/templates/retail/authenticate.ts

@@ -1,5 +1,5 @@
+import type { ToolFailure } from "@alexkroman1/aai";
 import type { RetailState, User } from "./shared.ts";
-import type { ErrorResult } from "./store.ts";
 
 export interface AuthResult {
   user_id: string;
@@ -16,7 +16,7 @@ export interface AuthResult {
  * order you want. Re-running a finder for the SAME customer succeeds, because a
  * caller repeating their email should not hit an error.
  */
-export function authenticateAs(state: RetailState, user: User): AuthResult | ErrorResult {
+export function authenticateAs(state: RetailState, user: User): AuthResult | ToolFailure {
   const current = state.authenticatedUserId;
   if (current && current !== user.user_id) {
     return {

package/dist/templates/retail/client.tsx

@@ -1,8 +1,7 @@
 import "@alexkroman1/aai-ui/styles.css";
 import type { ChatMessage } from "@alexkroman1/aai-ui";
-import { client, useAgentState, useSession } from "@alexkroman1/aai-ui";
+import { AutoScroll, client, useAgentState, useSession } from "@alexkroman1/aai-ui";
 import type { ReactNode } from "react";
-import { useEffect, useRef } from "react";
 import type {
   OrderStatus,
   OrderView,
@@ -10,7 +9,7 @@ import type {
   StoreView,
   SwapOptionView,
 } from "./shared.ts";
-import { DEMO_PERSONAS, storeView } from "./shared.ts";
+import { DEMO_PERSONAS, emptyRetailState, storeView } from "./shared.ts";
 
 const CSS = `
 @keyframes rt-pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.45; } }
@@ -38,8 +37,11 @@ const statusColors: Record<string, string> = {
 } satisfies Record<OrderStatus, string>;
 
 // The sidebar before the first tool call, derived from the projection itself so
-// a new StoreView field can't miss the pre-first-call render.
-const EMPTY_VIEW: StoreView = storeView({});
+// a new StoreView field can't miss the pre-first-call render. Built from
+// `emptyRetailState` rather than `retailSlot.projection(...)(undefined)`,
+// because the slot's factory lives in `store.ts` and pulls the 107 KB seed —
+// importing it here would ship the whole catalog to the browser.
+const EMPTY_VIEW: StoreView = storeView(emptyRetailState());
 
 function stateColor(state: string): string {
   if (state === "listening" || state === "ready") return "#16a34a";
@@ -193,13 +195,8 @@ function SwapOptions({ option }: { option: SwapOptionView }) {
 
 function App() {
   const session = useSession();
-  const messagesEndRef = useRef<HTMLDivElement>(null);
   // The agent's own store, projected by `syncState` after every tool call.
-  const view = useAgentState<StoreView>() ?? EMPTY_VIEW;
-
-  useEffect(() => {
-    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
-  }, [session.messages]);
+  const view = useAgentState<StoreView>(EMPTY_VIEW);
 
   const lastAction = view.activity.at(-1);
 
@@ -255,7 +252,10 @@ function App() {
             className="flex flex-col overflow-hidden"
             style={{ borderRight: "1px solid #e4e4e7" }}
           >
-            <div className="rt-scroll flex-1 overflow-y-auto p-4 flex flex-col gap-2">
+            <AutoScroll
+              scrollClassName="rt-scroll overflow-y-auto"
+              contentClassName="p-4 flex flex-col gap-2"
+            >
               {session.messages.length === 0 && (
                 <div className="text-center p-10 text-[13px]" style={{ color: "#a1a1aa" }}>
                   Press start, then read one of the emails from “Who to be” to the agent.
@@ -277,8 +277,7 @@ function App() {
                   {message.content}
                 </div>
               ))}
-              <div ref={messagesEndRef} />
-            </div>
+            </AutoScroll>
 
             {session.userTranscript !== null && (
               <div

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

@@ -1,7 +1,7 @@
-import type { ToolContext } from "@alexkroman1/aai";
+import { isToolFailure, type ToolContext } from "@alexkroman1/aai";
 import { describe, expect, test } from "vitest";
 import retailAgent from "./agent.ts";
-import { getState, isError } from "./store.ts";
+import { retailSlot } from "./store.ts";
 
 /** Tools that legitimately run before the caller is identified. Everything
  *  else must refuse. Listed here so ADDING an unauthenticated tool is a
@@ -126,9 +126,9 @@ describe("the UI-update invariant", () => {
   // retailTool(): it would work, and the sidebar would sit still through it.
   test.each(registry)("%s increments callSeq and logs activity", async (name, def) => {
     const ctx = makeCtx();
-    const before = getState(ctx).callSeq;
+    const before = retailSlot.get(ctx).callSeq;
     await def.execute(SAMPLE_ARGS[name] ?? {}, ctx);
-    const state = getState(ctx);
+    const state = retailSlot.get(ctx);
     expect(state.callSeq, `${name} did not bump callSeq`).toBe(before + 1);
     expect(state.activity.at(-1)?.tool, `${name} logged the wrong tool name`).toBe(name);
     expect(state.activity.at(-1)?.summary).toBeTruthy();
@@ -139,7 +139,7 @@ describe("the UI-update invariant", () => {
     // disagree — the activity feed would then attribute calls to the wrong tool.
     const ctx = makeCtx();
     await def.execute(SAMPLE_ARGS[name] ?? {}, ctx);
-    expect(getState(ctx).activity.at(-1)?.tool).toBe(name);
+    expect(retailSlot.get(ctx).activity.at(-1)?.tool).toBe(name);
   });
 });
 
@@ -148,8 +148,8 @@ describe("the authentication gate", () => {
     "%s refuses before the caller is identified",
     async (name, def) => {
       const result = await def.execute(SAMPLE_ARGS[name] ?? {}, makeCtx());
-      expect(isError(result), `${name} did not refuse`).toBe(true);
-      if (!isError(result)) return;
+      expect(isToolFailure(result), `${name} did not refuse`).toBe(true);
+      if (!isToolFailure(result)) return;
       expect(result.error, `${name} refused for the wrong reason`).toContain(
         "find_user_id_by_email",
       );
@@ -162,9 +162,9 @@ describe("the authentication gate", () => {
       const result = await def.execute(SAMPLE_ARGS[name] ?? {}, makeCtx());
       // A public tool may still fail on its own (deliberately bogus) arguments;
       // it must not fail on the GATE. Written as one unconditional assertion —
-      // an `if (isError(result))` wrapper would pass vacuously for the tools
+      // an `if (isToolFailure(result))` wrapper would pass vacuously for the tools
       // that succeed, which is precisely the set most at risk of regressing.
-      const blockedByGate = isError(result) && result.error.includes("find_user_id_by_email");
+      const blockedByGate = isToolFailure(result) && result.error.includes("find_user_id_by_email");
       expect(blockedByGate, `${name} was blocked by the auth gate`).toBe(false);
     },
   );

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

@@ -1,6 +1,7 @@
+import { isToolFailure } from "@alexkroman1/aai";
 import { describe, expect, test } from "vitest";
 import { normalizeItemId, normalizeOrderId, resolveOrder, resolveVariantId } from "./resolve.ts";
-import { createDefaultState, findProduct, isError } from "./store.ts";
+import { createDefaultState, findProduct } from "./store.ts";
 
 function stateFor(userId: string) {
   const state = createDefaultState();
@@ -39,13 +40,13 @@ describe("resolveOrder — canonical ids", () => {
     const state = stateFor("olivia_ito_3591");
     for (const spoken of ["#W5866402", "W 5866402", "5866402"]) {
       const order = resolveOrder(state, spoken);
-      expect.soft(isError(order) ? null : order.order_id, spoken).toBe("#W5866402");
+      expect.soft(isToolFailure(order) ? null : order.order_id, spoken).toBe("#W5866402");
     }
   });
 
   test("refuses another customer's order id", () => {
     const state = stateFor("olivia_ito_3591");
-    expect(isError(resolveOrder(state, "#W4316152"))).toBe(true);
+    expect(isToolFailure(resolveOrder(state, "#W4316152"))).toBe(true);
   });
 });
 
@@ -54,14 +55,14 @@ describe("resolveOrder — shorthand", () => {
     const state = stateFor("olivia_ito_3591");
     for (const spoken of ["the delivered one", "my delivered order", "delivered"]) {
       const order = resolveOrder(state, spoken);
-      expect.soft(isError(order) ? null : order.order_id, spoken).toBe("#W5866402");
+      expect.soft(isToolFailure(order) ? null : order.order_id, spoken).toBe("#W5866402");
     }
   });
 
   test("three pending orders make bare 'my pending order' ambiguous, and it lists them", () => {
     const state = stateFor("olivia_ito_3591");
     const result = resolveOrder(state, "my pending order");
-    if (!isError(result)) throw new Error("expected ambiguity");
+    if (!isToolFailure(result)) throw new Error("expected ambiguity");
     for (const id of ["#W5442520", "#W7941031", "#W3657213"]) {
       expect.soft(result.error, `ambiguity message omits ${id}`).toContain(id);
     }
@@ -71,38 +72,38 @@ describe("resolveOrder — shorthand", () => {
     const state = stateFor("olivia_ito_3591");
     const first = resolveOrder(state, "my first pending order");
     const second = resolveOrder(state, "the second pending order");
-    expect(isError(first) ? null : first.order_id).toBe("#W5442520");
-    expect(isError(second) ? null : second.order_id).toBe("#W7941031");
+    expect(isToolFailure(first) ? null : first.order_id).toBe("#W5442520");
+    expect(isToolFailure(second) ? null : second.order_id).toBe("#W7941031");
   });
 
   test("'last' picks the final one", () => {
     const state = stateFor("olivia_ito_3591");
     const result = resolveOrder(state, "my last pending order");
-    expect(isError(result) ? null : result.order_id).toBe("#W3657213");
+    expect(isToolFailure(result) ? null : result.order_id).toBe("#W3657213");
   });
 
   test("a bare ordinal with no status word indexes all of the caller's orders", () => {
     const state = stateFor("emma_smith_8564");
     const result = resolveOrder(state, "the first one");
-    expect(isError(result) ? null : result.order_id).toBe("#W2417020");
+    expect(isToolFailure(result) ? null : result.order_id).toBe("#W2417020");
   });
 
   test("a status the caller has none of says what they do have", () => {
     const state = stateFor("harper_brown_7363");
     const result = resolveOrder(state, "my cancelled order");
-    if (!isError(result)) throw new Error("expected refusal");
+    if (!isToolFailure(result)) throw new Error("expected refusal");
     expect(result.error).toContain("delivered");
     expect(result.error).toContain("pending");
   });
 
   test("an out-of-range ordinal is refused, not clamped", () => {
     const state = stateFor("emma_smith_8564");
-    expect(isError(resolveOrder(state, "the fourth pending order"))).toBe(true);
+    expect(isToolFailure(resolveOrder(state, "the fourth pending order"))).toBe(true);
   });
 
   test("unresolvable input is refused before authentication too", () => {
     const state = createDefaultState();
-    expect(isError(resolveOrder(state, "my pending order"))).toBe(true);
+    expect(isToolFailure(resolveOrder(state, "my pending order"))).toBe(true);
   });
 });
 
@@ -110,7 +111,7 @@ describe("resolveVariantId", () => {
   const state = createDefaultState();
   function teaKettle() {
     const product = findProduct(state, "9832717871");
-    if (isError(product)) throw new Error(product.error);
+    if (isToolFailure(product)) throw new Error(product.error);
     return product;
   }
 
@@ -120,7 +121,7 @@ describe("resolveVariantId", () => {
   });
 
   test("refuses an item id belonging to a different product", () => {
-    expect(isError(resolveVariantId(teaKettle(), "4725166838"))).toBe(true);
+    expect(isToolFailure(resolveVariantId(teaKettle(), "4725166838"))).toBe(true);
   });
 
   test("matches a spoken option phrase", () => {
@@ -135,13 +136,13 @@ describe("resolveVariantId", () => {
 
   test("an ambiguous phrase lists the candidates with their options", () => {
     const result = resolveVariantId(teaKettle(), "glass");
-    if (!isError(result)) throw new Error("expected ambiguity");
+    if (!isToolFailure(result)) throw new Error("expected ambiguity");
     expect(result.error).toContain("glass");
     expect(result.error.match(/\d{10}/g)?.length).toBeGreaterThan(1);
   });
 
   test("a phrase matching nothing is refused", () => {
-    expect(isError(resolveVariantId(teaKettle(), "titanium"))).toBe(true);
+    expect(isToolFailure(resolveVariantId(teaKettle(), "titanium"))).toBe(true);
   });
 
   test("availableOnly excludes unavailable variants from matching", () => {

package/dist/templates/retail/resolve.ts

@@ -1,5 +1,6 @@
+import { isToolFailure, type ToolFailure } from "@alexkroman1/aai";
 import type { Order, OrderStatus, Product, RetailState } from "./shared.ts";
-import { authenticatedUser, type ErrorResult, isError } from "./store.ts";
+import { authenticatedUser } from "./store.ts";
 
 /** `#W5866402` from anything STT plausibly produces for it. */
 export function normalizeOrderId(spoken: string): string {
@@ -53,9 +54,9 @@ function describeOrder(order: Order): string {
  * Ambiguity is always an error listing the candidates, never a guess — the
  * consequence of guessing here is cancelling the wrong order.
  */
-export function resolveOrder(state: RetailState, spoken: string): Order | ErrorResult {
+export function resolveOrder(state: RetailState, spoken: string): Order | ToolFailure {
   const user = authenticatedUser(state);
-  if (isError(user)) return user;
+  if (isToolFailure(user)) return user;
 
   const owned = user.orders
     .map((id) => state.store.orders[id])
@@ -110,7 +111,7 @@ export function resolveVariantId(
   product: Product,
   spoken: string,
   opts: { availableOnly?: boolean } = {},
-): string | ErrorResult {
+): string | ToolFailure {
   if (LOOKS_LIKE_ITEM_ID.test(spoken)) {
     const itemId = normalizeItemId(spoken);
     const variant = product.variants[itemId];

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

@@ -1,7 +1,7 @@
 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 { buildScriptBullets, DEMO_PERSONAS, emptyRetailState, storeView } from "./shared.ts";
 
 function makeState(authenticatedUserId: string | null): RetailState {
   return {
@@ -15,20 +15,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 +41,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 +65,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);
   });
@@ -105,12 +106,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 +122,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 +131,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 +141,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 +154,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

@@ -129,7 +129,24 @@ export interface RetailState {
   focus: { orderId?: string; productId?: string };
 }
 
-export type StateSlot = { retail?: 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 ──────────────────────────────
 
@@ -321,16 +338,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: RetailState): 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 +367,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 +377,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 +396,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: RetailState): 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 ?? ""}"`,