@alexkroman1/aai-cli 6.11.0 → 8.0.0

package/dist/templates/retail/swap.ts

@@ -1,6 +1,22 @@
+/**
+ * Swapping items for other options of the same product — the validation both
+ * item changes share, and the two actions built on it (modifying a pending
+ * order, exchanging a delivered one) as plan/apply pairs.
+ *
+ * See `cancel.ts` for why every mutating action is split that way.
+ */
+
 import { isToolFailure, type ToolFailure } from "@alexkroman1/aai";
+import { resolveOrder } from "./resolve.ts";
 import type { Order, OrderItem, RetailState, User, Variant } from "./shared.ts";
-import { findPaymentMethod, findProduct, findVariant, isGiftCard, money } from "./store.ts";
+import {
+  authenticatedUser,
+  findPaymentMethod,
+  findProduct,
+  findVariant,
+  isGiftCard,
+  money,
+} from "./store.ts";
 
 export interface SwapPair {
   /** Index into `order.items`. Matching by index rather than by "first item
@@ -17,12 +33,30 @@ export interface SwapPlan {
 }
 
 /**
- * Validate a proposed item swap and compute its price difference, without
- * mutating anything. Shared by `modify_pending_order_items` (pending, which
- * additionally forbids a no-op swap) and `exchange_delivered_order_items`
- * (delivered, which does not).
+ * One priced swap, flattened to primitives.
  *
- * Validation order matches tau2's so a bad call fails on the same check.
+ * A {@link SwapPair} holds live `OrderItem` and `Variant` references into the
+ * store, which is right for a plan computed and applied inside one tool call
+ * and wrong for one that waits in a session slot for the caller to say yes —
+ * see `CancelPlan` in `cancel.ts`. This is the storable form, and it carries enough that
+ * {@link applySwapLines} needs no lookup at all.
+ */
+export interface SwapLine {
+  index: number;
+  fromItemId: string;
+  fromName: string;
+  fromOptions: Record<string, string>;
+  fromPrice: number;
+  toItemId: string;
+  toName: string;
+  toOptions: Record<string, string>;
+  toPrice: number;
+}
+
+/**
+ * Validate a proposed item swap and compute its price difference, without
+ * mutating anything. Shared by the pending-order change (which additionally
+ * forbids a no-op swap) and the delivered-order exchange (which does not).
  */
 export function planItemSwap(
   state: RetailState,
@@ -103,6 +137,23 @@ export function planItemSwap(
   return { pairs, diff: money(diff) };
 }
 
+/** Flatten a freshly-computed plan into the form a staged action can hold. */
+export function toSwapLines(plan: SwapPlan): SwapLine[] {
+  return plan.pairs.map((pair) => ({
+    index: pair.index,
+    fromItemId: pair.item.item_id,
+    fromName: pair.item.name,
+    fromOptions: { ...pair.item.options },
+    fromPrice: pair.item.price,
+    toItemId: pair.newVariant.item_id,
+    // Same product by construction — a swap can only reach another option of
+    // it — so the name is the item's own and the OPTIONS are what differ.
+    toName: pair.item.name,
+    toOptions: { ...pair.newVariant.options },
+    toPrice: pair.newVariant.price,
+  }));
+}
+
 /**
  * Gate the price difference on the chosen payment method. Only a gift card has
  * a balance to run out of; a negative difference is a refund and never gated.
@@ -118,14 +169,196 @@ export function assertCanCoverDiff(user: User, methodId: string, diff: number):
   return null;
 }
 
-/** Apply a validated plan. Each line takes its OWN new variant's price, options
- *  and name — see the module note on tau2's leaked loop variable. */
-export function applySwap(order: Order, plan: SwapPlan): void {
-  for (const pair of plan.pairs) {
-    const line = order.items[pair.index];
-    if (!line) continue;
-    line.item_id = pair.newVariant.item_id;
-    line.price = pair.newVariant.price;
-    line.options = pair.newVariant.options;
+/** Apply validated lines. Each takes its OWN new option's price and options —
+ *  see the module note on tau2's leaked loop variable. */
+export function applySwapLines(order: Order, lines: readonly SwapLine[]): void {
+  for (const line of lines) {
+    const item = order.items[line.index];
+    if (!item) continue;
+    item.item_id = line.toItemId;
+    item.price = line.toPrice;
+    item.options = { ...line.toOptions };
+  }
+}
+
+/** "the glass 2 litre one for the stainless steel 1 litre one" — how a swap is
+ *  said out loud. Item numbers are never in it; the prompt forbids reading one. */
+function describeLine(line: SwapLine): string {
+  const from = Object.values(line.fromOptions).join(" ");
+  const to = Object.values(line.toOptions).join(" ");
+  return `the ${from} ${line.fromName} for the ${to} one`;
+}
+
+function describeDiff(diff: number, methodId: string): string {
+  if (diff > 0) return `$${diff.toFixed(2)} charged to ${methodId}`;
+  if (diff < 0) return `$${Math.abs(diff).toFixed(2)} refunded to ${methodId}`;
+  return "no price difference";
+}
+
+// ─── Changing the items in a pending order ───────────────────────────────────
+
+export interface ModifyItemsPlan {
+  readBack: string;
+  orderId: string;
+  lines: SwapLine[];
+  diff: number;
+  paymentMethodId: string;
+}
+
+export function planModifyItems(
+  state: RetailState,
+  spokenOrderId: string,
+  itemIds: string[],
+  newItemIds: string[],
+  paymentMethodId: string,
+): ModifyItemsPlan | ToolFailure {
+  const user = authenticatedUser(state);
+  if (isToolFailure(user)) return user;
+
+  const order = resolveOrder(state, spokenOrderId);
+  if (isToolFailure(order)) return order;
+
+  // Exactly 'pending'. A 'pending (item modified)' order has already used its
+  // one modification, which is what makes this action terminal.
+  if (order.status !== "pending") {
+    return {
+      error: `Order ${order.order_id} is ${order.status}. Items can only be changed while an order is exactly 'pending', and only once.`,
+    };
+  }
+
+  const plan = planItemSwap(state, order, itemIds, newItemIds, { requireDifferent: true });
+  if (isToolFailure(plan)) return plan;
+
+  const blocked = assertCanCoverDiff(user, paymentMethodId, plan.diff);
+  if (blocked) return blocked;
+
+  const lines = toSwapLines(plan);
+  return {
+    readBack:
+      `swap ${lines.map(describeLine).join(", and ")} on order ${order.order_id}, ` +
+      `with ${describeDiff(plan.diff, paymentMethodId)} — and this is the ONE change that order ` +
+      "allows: after it, it can no longer be cancelled or modified by anyone",
+    orderId: order.order_id,
+    lines,
+    diff: plan.diff,
+    paymentMethodId,
+  };
+}
+
+export function applyModifyItems(state: RetailState, plan: ModifyItemsPlan) {
+  const order = state.store.orders[plan.orderId];
+  const user = order ? state.store.users[order.user_id] : undefined;
+
+  if (order && user) {
+    const method = user.payment_methods[plan.paymentMethodId];
+    if (method && isGiftCard(method)) {
+      method.balance = money(method.balance - plan.diff);
+    }
+    order.payment_history.push({
+      transaction_type: plan.diff > 0 ? "payment" : "refund",
+      amount: money(Math.abs(plan.diff)),
+      payment_method_id: plan.paymentMethodId,
+    });
+    applySwapLines(order, plan.lines);
+    order.status = "pending (item modified)";
   }
+
+  return {
+    order_id: plan.orderId,
+    status: "pending (item modified)" as const,
+    price_difference: plan.diff,
+    items: (order?.items ?? []).map((item) => ({
+      name: item.name,
+      item_id: item.item_id,
+      options: item.options,
+      price: item.price,
+    })),
+    message:
+      plan.diff > 0
+        ? `Done. $${plan.diff.toFixed(2)} was charged to ${plan.paymentMethodId}. This order can no longer be modified or cancelled.`
+        : `Done. $${Math.abs(plan.diff).toFixed(2)} is being refunded to ${plan.paymentMethodId}. This order can no longer be modified or cancelled.`,
+  };
+}
+
+// ─── Exchanging a delivered order ────────────────────────────────────────────
+
+export interface ExchangePlan {
+  readBack: string;
+  orderId: string;
+  lines: SwapLine[];
+  diff: number;
+  paymentMethodId: string;
+}
+
+export function planExchange(
+  state: RetailState,
+  spokenOrderId: string,
+  itemIds: string[],
+  newItemIds: string[],
+  paymentMethodId: string,
+): ExchangePlan | ToolFailure {
+  const user = authenticatedUser(state);
+  if (isToolFailure(user)) return user;
+
+  const order = resolveOrder(state, spokenOrderId);
+  if (isToolFailure(order)) return order;
+
+  if (order.status !== "delivered") {
+    return {
+      error: `Order ${order.order_id} is ${order.status}. Only a delivered order can be exchanged, and only once.`,
+    };
+  }
+
+  // requireDifferent is false: a zero-difference line is harmless on a
+  // delivered order, and refusing one would reject a caller who listed every
+  // item and changed their mind about only some.
+  const plan = planItemSwap(state, order, itemIds, newItemIds, { requireDifferent: false });
+  if (isToolFailure(plan)) return plan;
+
+  const blocked = assertCanCoverDiff(user, paymentMethodId, plan.diff);
+  if (blocked) return blocked;
+
+  const lines = toSwapLines(plan);
+  return {
+    readBack:
+      `exchange ${lines.map(describeLine).join(", and ")} on order ${order.order_id}, ` +
+      `with ${describeDiff(plan.diff, paymentMethodId)}`,
+    orderId: order.order_id,
+    lines,
+    diff: plan.diff,
+    paymentMethodId,
+  };
+}
+
+export function applyExchange(state: RetailState, plan: ExchangePlan) {
+  const order = state.store.orders[plan.orderId];
+
+  // The pairing AS PRICED, in the order the caller gave it. tau2 stored these
+  // as two INDEPENDENTLY SORTED lists, which permuted the second against the
+  // first whenever more than one item was named — two sets, not a pairing, and
+  // the result had to carry the real pairing separately to avoid telling the
+  // caller a quote that was not the one they got. Nothing here is compared
+  // against a tau2 end state any more, so the fields hold the pairing itself.
+  if (order) {
+    order.status = "exchange requested";
+    order.exchange_items = plan.lines.map((line) => line.fromItemId);
+    order.exchange_new_items = plan.lines.map((line) => line.toItemId);
+    order.exchange_payment_method_id = plan.paymentMethodId;
+    order.exchange_price_difference = plan.diff;
+  }
+
+  return {
+    order_id: plan.orderId,
+    status: "exchange requested" as const,
+    price_difference: plan.diff,
+    exchanges: plan.lines.map((line) => ({
+      item_id: line.fromItemId,
+      new_item_id: line.toItemId,
+      price_difference: money(line.toPrice - line.fromPrice),
+    })),
+    message:
+      plan.diff > 0
+        ? `Exchange requested on ${plan.orderId}. $${plan.diff.toFixed(2)} will be charged to ${plan.paymentMethodId}. An email with return instructions is on its way.`
+        : `Exchange requested on ${plan.orderId}. $${Math.abs(plan.diff).toFixed(2)} will be refunded to ${plan.paymentMethodId}. An email with return instructions is on its way.`,
+  };
 }

package/dist/templates/retail/system-prompt.md

@@ -3,15 +3,40 @@ customer on the phone. You can help them cancel or modify pending orders,
 return or exchange delivered orders, update their default address, and answer
 questions about their own profile, orders and our products.
 
-# Authenticate first
+# Where the call is
 
-Before anything else, identify who you are talking to by finding their user id
-— by email (`find_user_id_by_email`), or by first name, last name and zip code
-(`find_user_id_by_name_zip`) if they cannot remember the email. Do this **even
-if the caller volunteers their user id**.
+Every tool answers with the stage this call is in and what that stage expects
+next. Read it — it is the shortest true statement of what you may do, and you do
+not have to remember it between turns. A tool that is not available yet refuses
+outright and tells you what has to happen first.
 
-Prefer email. Fall back to name + zip only when they cannot recall the address
-on the account.
+Three of the rules below are that machine rather than prose, and they are the
+three you cannot get wrong by forgetting: you cannot act before you know who is
+calling, you cannot act after the call has gone to a human, and you cannot
+change anything the customer has not said yes to.
+
+# Nothing changes until the customer says yes
+
+**No tool here changes anything.** Cancelling, modifying, returning and
+exchanging all do the same thing: they check the request, price it, and hand
+you one sentence describing exactly what would happen. Nothing has happened at
+that point.
+
+So every change is three steps, and they are three separate turns:
+
+1. Call the tool for the change. It answers with a sentence.
+2. **Say that sentence to the customer** — the order, the items, the amounts,
+   where the money is going — and stop. Ask them plainly: is that right?
+3. On an explicit "yes", call `confirm_change`. On anything else — "no",
+   hesitation, "wait", a correction, a new subject — call `cancel_change` and
+   start again from what they actually want.
+
+Never treat silence, a "mm-hm" in the middle of your sentence, or the fact that
+they asked for it a minute ago as a yes. If you are not sure they agreed, ask
+again; nothing is lost by asking, because nothing has happened yet.
+
+Only one change can be waiting at a time. If you need to stage a different one,
+settle the first with `confirm_change` or `cancel_change`.
 
 # One customer per call
 
@@ -20,12 +45,9 @@ requests from that person, but you must refuse anything to do with anybody
 else's account, and you cannot switch to a different customer mid-call — ask
 them to call back.
 
-# Confirm every change out loud
-
-Before any action that changes something — cancel, modify, return, exchange —
-say what you are about to do, including the order, the items, the amounts and
-where money is going, and wait for an explicit "yes". Never act on an implied
-yes.
+Identify them by email (`find_user_id_by_email`), or by first name, last name
+and zip code (`find_user_id_by_name_zip`) if they cannot remember the email.
+Prefer email. Do this **even if the caller volunteers their user id**.
 
 # Never invent anything
 
@@ -43,9 +65,23 @@ speak; when you speak, do not also make a tool call.
 # Handing off to a human
 
 Transfer only if the caller explicitly asks for a human, or their request
-cannot be handled with your tools and this policy. Call
-`transfer_to_human_agents` first, then say exactly: "You are being transferred
-to a human agent. Please hold on." Say nothing else after that.
+cannot be handled with your tools and this policy.
+
+**The handoff is a tool call, not a sentence.** Every turn in which the customer
+asks for a person — "a real person", "an agent", "a supervisor", "put me
+through", "this isn't working" — begins with a call to
+`transfer_to_human_agents`. Not a question back, not an offer to try once more,
+and not the sentence below. Do not ask what the problem is first, and do not try
+to talk them out of it.
+
+**Never say "You are being transferred" unless `transfer_to_human_agents` has
+already answered in this turn.** Saying it without the call leaves the customer
+holding a line nobody is coming to: nothing has been handed anywhere, and the
+call is still yours. That is the one mistake here you cannot take back.
+
+Once the tool has answered, say exactly: "You are being transferred to a human
+agent. Please hold on." Say nothing else after that. The call is over for you at
+that point, and every tool will refuse — including that one.
 
 # Speaking on the phone
 
@@ -58,6 +94,9 @@ to a human agent. Please hold on." Say nothing else after that.
 - When a customer gives you a number, read it back before you use it.
 - Prices: "three hundred and twenty dollars and fifty cents", not "320.50".
 - Keep replies to one or two sentences. This is a phone call, not an email.
+  The one place to be longer is the readback in step 2 above — that sentence
+  earns its length, and rushing it is the whole failure mode it exists to
+  prevent.
 - Do not spell out tool names, statuses in snake_case, or user ids.
 
 # What the tools accept
@@ -71,22 +110,25 @@ product's options.
 
 # The rules that bite
 
+Every rule here is checked when you stage a change, so a request that breaks one
+is refused before the customer is ever asked to agree to it. They are written
+out so you can steer the conversation, not because you have to enforce them.
+
 **All times in the store's records are EST, 24-hour.** "02:30:00" is 2:30 in
 the morning.
 
 **Cancelling a pending order.** Only an order whose status is exactly
-"pending". Check the status first. The reason must be either "no longer needed"
-or "ordered by mistake" — if the customer gives another reason, tell them those
-are the only two we can record and ask which fits. A gift-card refund lands
-immediately; everything else takes 5 to 7 business days.
+"pending". The reason must be either "no longer needed" or "ordered by mistake"
+— if the customer gives another reason, tell them those are the only two we can
+record and ask which fits. A gift-card refund lands immediately; everything else
+takes 5 to 7 business days.
 
 **Changing the items in a pending order is once-only and irreversible.** After
 it, the order cannot be cancelled or modified again — not by you, not by
-anyone. So before you call it: get the customer to confirm they have named
-**every** item they want changed, then read the complete list and the price
-difference back. Ask "is that everything you want to change?" explicitly. An
-item can only become a different option of the same product — a shirt cannot
-become shoes.
+anyone. So before you stage it: get the customer to confirm they have named
+**every** item they want changed. Ask "is that everything you want to change?"
+explicitly, and only then stage the whole list in one call. An item can only
+become a different option of the same product — a shirt cannot become shoes.
 
 **Changing a pending order's payment method.** One method only, and it must be
 different from the current one. A gift card must cover the whole order total.
@@ -94,11 +136,10 @@ The old method is refunded.
 
 **Returning a delivered order.** Only "delivered", only once. The refund goes
 to the original payment method or to one of their gift cards — nothing else.
-Confirm the exact item list. The customer gets an email about sending things
-back.
+The customer gets an email about sending things back.
 
 **Exchanging a delivered order.** Only "delivered", only once. Same-product
-options only. Remind them to name every item first, exactly as with modifying a
+options only. Ask them to name every item first, exactly as with modifying a
 pending order. The price difference is charged to or refunded from a payment
 method they choose; a gift card must cover a positive difference. No new order
 is needed.

package/dist/templates/retail/tools/cancel_change.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { retailTool } from "../store.ts";
+
+/**
+ * Drop the staged change and go back to helping.
+ *
+ * Clears `pending` UNCONDITIONALLY and always sends `SETTLED`, so this is the
+ * way out of `awaitingConfirmation` from any state the store could be in — a
+ * caller who says no, changes their mind about one item, or wants to talk about
+ * something else entirely must never leave the call wedged on a change nobody
+ * is going to make.
+ */
+export default retailTool({
+  name: "cancel_change",
+  when: "serving.awaitingConfirmation",
+  send: { type: "SETTLED" },
+  description:
+    "Drop the change that is waiting, without applying it. Use this when the caller says no, " +
+    "hesitates, wants any part of it different, or moves on to something else. Nothing was " +
+    "changed, so there is nothing to undo — stage the corrected change afterwards if they want one.",
+  inputSchema: z.object({}),
+  execute: (_args, state) => {
+    const dropped = state.pending;
+    state.pending = null;
+    return {
+      dropped: dropped?.kind ?? null,
+      message: dropped
+        ? `Dropped — nothing was changed. The caller did not agree to: ${dropped.plan.readBack}.`
+        : "Nothing was staged, so nothing was dropped.",
+    };
+  },
+  summary: (_args, result) => `dropped ${result.dropped ?? "nothing"}`,
+});

package/dist/templates/retail/tools/cancel_pending_order.ts

@@ -1,19 +1,20 @@
 import { isToolFailure } from "@alexkroman1/aai";
 import { z } from "zod";
-import { creditRefund, REFUND_DELAY_NOTE, REFUND_IMMEDIATE_NOTE } from "../refund.ts";
-import { OrderIdField, resolveOrder } from "../resolve.ts";
-import { authenticatedUser, retailTool, setFocus } from "../store.ts";
-
-/** tau2 accepts exactly these two. Anything else is refused. */
-const CANCEL_REASONS = ["no longer needed", "ordered by mistake"] as const;
+import { CANCEL_REASONS, planCancel } from "../cancel.ts";
+import { stageAction } from "../pending.ts";
+import { OrderIdField } from "../resolve.ts";
+import { retailTool, setFocus } from "../store.ts";
 
 export default retailTool({
   name: "cancel_pending_order",
+  when: "serving",
+  send: { type: "STAGED" },
   description:
-    "Cancel a pending order. Only an order whose status is exactly 'pending' can be cancelled — " +
-    "check the status first. The reason must be either 'no longer needed' or 'ordered by mistake'. " +
-    "State the order, its total and the refund destination to the caller and get an explicit yes " +
-    "before calling this.",
+    "STAGE a cancellation of a pending order — this does NOT cancel anything. Only an order whose " +
+    "status is exactly 'pending' can be cancelled, and the reason must be either 'no longer " +
+    "needed' or 'ordered by mistake'. The order, its total and where the refund goes come back as " +
+    "a sentence to read to the caller; nothing happens until you hear an explicit yes and call " +
+    "confirm_change.",
   inputSchema: z.object({
     order_id: OrderIdField,
     reason: z
@@ -21,55 +22,10 @@ export default retailTool({
       .describe("Either 'no longer needed' or 'ordered by mistake' — no other reason is accepted"),
   }),
   execute: (args, state) => {
-    const user = authenticatedUser(state);
-    if (isToolFailure(user)) return user;
-
-    const order = resolveOrder(state, args.order_id);
-    if (isToolFailure(order)) return order;
-    setFocus(state, { orderId: order.order_id });
-
-    if (order.status !== "pending") {
-      return {
-        error: `Order ${order.order_id} is ${order.status}, and only a pending order can be cancelled.`,
-      };
-    }
-    // The enum makes this unreachable from a well-formed call; it stays because
-    // the reason is the one field a caller supplies in free speech.
-    if (!CANCEL_REASONS.includes(args.reason)) {
-      return {
-        error: `'${args.reason}' is not an accepted cancellation reason. It must be 'no longer needed' or 'ordered by mistake'.`,
-      };
-    }
-
-    let immediate = false;
-    const refunds = order.payment_history
-      .filter((payment) => payment.transaction_type === "payment")
-      .map((payment) => {
-        const credited = creditRefund(user, payment.payment_method_id, payment.amount);
-        immediate = immediate || credited.immediate;
-        return {
-          transaction_type: "refund" as const,
-          amount: payment.amount,
-          payment_method_id: payment.payment_method_id,
-        };
-      });
-
-    order.status = "cancelled";
-    order.cancel_reason = args.reason;
-    order.payment_history.push(...refunds);
-
-    const total = refunds.reduce((sum, refund) => sum + refund.amount, 0);
-    return {
-      order_id: order.order_id,
-      status: order.status,
-      cancel_reason: order.cancel_reason,
-      refunded: total,
-      refund_immediate: immediate,
-      message: `Order ${order.order_id} is cancelled and $${total.toFixed(2)} is being refunded. ${
-        immediate ? REFUND_IMMEDIATE_NOTE : REFUND_DELAY_NOTE
-      }`,
-    };
+    const plan = planCancel(state, args.order_id, args.reason);
+    if (isToolFailure(plan)) return plan;
+    setFocus(state, { orderId: plan.orderId });
+    return stageAction(state, { kind: "cancel_pending_order", plan });
   },
-  summary: (_args, result) =>
-    isToolFailure(result) ? "cancel failed" : `cancelled ${result.order_id}`,
+  summary: (_args, result) => `staged: ${result.read_back}`,
 });

package/dist/templates/retail/tools/confirm_change.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { applyAction } from "../pending.ts";
+import { retailTool } from "../store.ts";
+
+/**
+ * The only tool in this template that writes to the store.
+ *
+ * Gated on `serving.awaitingConfirmation`, which is reachable only by staging a
+ * change — so "confirm what nobody staged" is refused by the SDK before this
+ * body runs, and the refusal quotes the state's own instruction. See
+ * `pending.ts`.
+ */
+export default retailTool({
+  name: "confirm_change",
+  when: "serving.awaitingConfirmation",
+  send: { type: "SETTLED" },
+  description:
+    "Apply the change that is waiting, after you have read it back to the caller and heard an " +
+    "explicit yes. Never call this on an implied yes, on silence, or before you have said what " +
+    "the change is. If they say no, or want any part of it different, call cancel_change instead.",
+  inputSchema: z.object({}),
+  execute: (_args, state) => {
+    const action = state.pending;
+    // Unreachable while the gate holds: `awaitingConfirmation` is entered only
+    // by a staging tool, which writes `pending` in the same synchronous window
+    // it sends `STAGED` in. Kept and reported rather than thrown for the reason
+    // `authenticatedUser` keeps its own — this runs mid-call, and a sentence
+    // the model can act on beats an exception. `cancel_change` is the way out
+    // if it ever did fire, which is why that tool clears unconditionally.
+    if (!action) {
+      return {
+        error:
+          "Nothing is staged, so there is nothing to confirm. Stage the change again with the " +
+          "tool for it, read it back, and confirm once the caller says yes.",
+      };
+    }
+    const result = applyAction(state, action);
+    state.pending = null;
+    return { confirmed: action.kind, ...result };
+  },
+  summary: (_args, result) => `confirmed ${result.confirmed}`,
+});