@alexkroman1/aai-cli 7.0.0 → 8.0.0

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

@@ -10,16 +10,33 @@ next. Read it — it is the shortest true statement of what you may do, and you
 not have to remember it between turns. A tool that is not available yet refuses
 outright and tells you what has to happen first.
 
-# Authenticate first
+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.
 
-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**. Until you have, every other tool will
-refuse.
+# Nothing changes until the customer says yes
 
-Prefer email. Fall back to name + zip only when they cannot recall the address
-on the account.
+**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
 
@@ -28,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
 
@@ -51,10 +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. The call is over
-for you at that point, and every tool will refuse — including that one.
+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
 
@@ -67,6 +94,9 @@ for you at that point, and every tool will refuse — including that one.
 - 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
@@ -80,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.
@@ -103,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,20 +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
@@ -22,54 +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) => `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}`,
+});

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

@@ -1,18 +1,21 @@
 import { isToolFailure } from "@alexkroman1/aai";
 import { z } from "zod";
-import { OrderIdField, resolveOrder } from "../resolve.ts";
-import { authenticatedUser, money, retailTool, setFocus } from "../store.ts";
-import { assertCanCoverDiff, planItemSwap } from "../swap.ts";
+import { stageAction } from "../pending.ts";
+import { OrderIdField } from "../resolve.ts";
+import { retailTool, setFocus } from "../store.ts";
+import { planExchange } from "../swap.ts";
 
 export default retailTool({
   name: "exchange_delivered_order_items",
   when: "serving",
+  send: { type: "STAGED" },
   description:
-    "Request an exchange of items in a delivered order for different options of the SAME products. " +
-    "Only a 'delivered' order can be exchanged, and only once. Remind the caller to name EVERY " +
-    "item they want exchanged before you call this, read the whole list and the price difference " +
-    "back, and get an explicit yes. No new order is needed — the customer gets an email explaining " +
-    "how to send the originals back.",
+    "STAGE an exchange of items in a delivered order for different options of the SAME products — " +
+    "this does NOT request anything. Only a 'delivered' order can be exchanged, and only once, so " +
+    "remind the caller to name EVERY item they want exchanged before you call this. The whole " +
+    "list and the price difference come back as a sentence to read to them; nothing happens until " +
+    "you hear an explicit yes and call confirm_change. No new order is needed — the customer gets " +
+    "an email explaining how to send the originals back.",
   inputSchema: z.object({
     order_id: OrderIdField,
     item_ids: z
@@ -29,64 +32,16 @@ export default retailTool({
       .describe("Method to charge or refund the price difference"),
   }),
   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 !== "delivered") {
-      return {
-        error: `Order ${order.order_id} is ${order.status}. Only a delivered order can be exchanged, and only once.`,
-      };
-    }
-
-    // requireDifferent is false: tau2 permits a same-item entry here, and a
-    // zero-difference exchange is harmless on a delivered order.
-    const plan = planItemSwap(state, order, args.item_ids, args.new_item_ids, {
-      requireDifferent: false,
-    });
+    const plan = planExchange(
+      state,
+      args.order_id,
+      args.item_ids,
+      args.new_item_ids,
+      args.payment_method_id,
+    );
     if (isToolFailure(plan)) return plan;
-
-    const blocked = assertCanCoverDiff(user, args.payment_method_id, plan.diff);
-    if (blocked) return blocked;
-
-    // No balance moves and no items change: this records a REQUEST. The money
-    // and the item swap settle when the originals come back.
-    order.status = "exchange requested";
-    // SORTED INDEPENDENTLY, verbatim from tau2 (`order.exchange_items =
-    // sorted(item_ids)` / `sorted(new_item_ids)`, the same shape
-    // `return_delivered_order_items` uses one list of) — kept because
-    // `seed.json` is tau2's data and these fields are what a tau2 task's
-    // expected end state is compared against. They are therefore two SETS of
-    // ids, not a pairing: sorting each list separately permutes the second
-    // against the first whenever the caller named more than one item.
-    //
-    // Which is why the ANSWER carries `exchanges` instead. `planItemSwap`
-    // priced this positionally, so returning the two sorted lists as if they
-    // lined up told the caller a pairing the quote was not for — the one thing
-    // this result must not do, since the model reads it back down a phone.
-    order.exchange_items = [...args.item_ids].sort();
-    order.exchange_new_items = [...args.new_item_ids].sort();
-    order.exchange_payment_method_id = args.payment_method_id;
-    order.exchange_price_difference = plan.diff;
-
-    return {
-      order_id: order.order_id,
-      status: order.status,
-      price_difference: plan.diff,
-      // The pairing AS PRICED, per line, in the order the caller gave it.
-      exchanges: plan.pairs.map((pair) => ({
-        item_id: pair.item.item_id,
-        new_item_id: pair.newVariant.item_id,
-        price_difference: money(pair.newVariant.price - pair.item.price),
-      })),
-      message:
-        plan.diff > 0
-          ? `Exchange requested on ${order.order_id}. $${plan.diff.toFixed(2)} will be charged to ${args.payment_method_id}. An email with return instructions is on its way.`
-          : `Exchange requested on ${order.order_id}. $${Math.abs(plan.diff).toFixed(2)} will be refunded to ${args.payment_method_id}. An email with return instructions is on its way.`,
-    };
+    setFocus(state, { orderId: plan.orderId });
+    return stageAction(state, { kind: "exchange_delivered_order_items", plan });
   },
-  summary: (_args, result) => `exchange requested on ${result.order_id}`,
+  summary: (_args, result) => `staged: ${result.read_back}`,
 });

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

@@ -1,39 +1,27 @@
 import { isToolFailure } from "@alexkroman1/aai";
 import { z } from "zod";
-import { AddressFields, formatAddress, toAddress } from "../address.ts";
-import { OrderIdField, resolveOrder } from "../resolve.ts";
+import { AddressFields, planOrderAddress } from "../address.ts";
+import { stageAction } from "../pending.ts";
+import { OrderIdField } from "../resolve.ts";
 import { retailTool, setFocus } from "../store.ts";
 
 export default retailTool({
   name: "modify_pending_order_address",
   when: "serving",
+  send: { type: "STAGED" },
   description:
-    "Change the shipping address of a pending order. Read the new address back to the caller and " +
-    "get an explicit yes before calling this. This does not change the customer's default address.",
+    "STAGE a change to a pending order's shipping address — this does NOT change it. The new " +
+    "address comes back as a sentence to read to the caller; nothing happens until you hear an " +
+    "explicit yes and call confirm_change. This does not touch the customer's default address.",
   inputSchema: z.object({
     order_id: OrderIdField,
     ...AddressFields,
   }),
   execute: (args, state) => {
-    const order = resolveOrder(state, args.order_id);
-    if (isToolFailure(order)) return order;
-    setFocus(state, { orderId: order.order_id });
-
-    // Any pending variant is fine here — unlike cancel and modify-items, which
-    // require exactly 'pending'. Re-addressing a modified order is harmless.
-    if (!order.status.startsWith("pending")) {
-      return {
-        error: `Order ${order.order_id} is ${order.status}, and only a pending order's address can be changed.`,
-      };
-    }
-
-    order.address = toAddress(args);
-    return {
-      order_id: order.order_id,
-      status: order.status,
-      address: order.address,
-      message: `Order ${order.order_id} now ships to ${formatAddress(order.address)}.`,
-    };
+    const plan = planOrderAddress(state, args.order_id, args);
+    if (isToolFailure(plan)) return plan;
+    setFocus(state, { orderId: plan.orderId });
+    return stageAction(state, { kind: "modify_pending_order_address", plan });
   },
-  summary: (_args, result) => `re-addressed ${result.order_id}`,
+  summary: (_args, result) => `staged: ${result.read_back}`,
 });

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

@@ -1,18 +1,22 @@
 import { isToolFailure } from "@alexkroman1/aai";
 import { z } from "zod";
-import { OrderIdField, resolveOrder } from "../resolve.ts";
-import { authenticatedUser, isGiftCard, money, retailTool, setFocus } from "../store.ts";
-import { applySwap, assertCanCoverDiff, planItemSwap } from "../swap.ts";
+import { stageAction } from "../pending.ts";
+import { OrderIdField } from "../resolve.ts";
+import { retailTool, setFocus } from "../store.ts";
+import { planModifyItems } from "../swap.ts";
 
 export default retailTool({
   name: "modify_pending_order_items",
   when: "serving",
+  send: { type: "STAGED" },
   description:
-    "Change items in a pending order to different options of the SAME products. This can be done " +
-    "ONCE per order and is irreversible — afterwards the order can no longer be cancelled or " +
-    "modified at all. Collect EVERY item the caller wants changed into one call, read the whole " +
-    "list and the price difference back, and get an explicit yes first. The item and replacement " +
-    "lists are positional and must be the same length.",
+    "STAGE a change of items in a pending order to different options of the SAME products — this " +
+    "does NOT change anything. It can only ever be done ONCE per order and is irreversible: " +
+    "afterwards the order can no longer be cancelled or modified at all. So collect EVERY item " +
+    "the caller wants changed into one call — ask them 'is that everything you want to change?' " +
+    "explicitly first. The whole list and the price difference come back as a sentence to read " +
+    "to them; nothing happens until you hear an explicit yes and call confirm_change. The item " +
+    "and replacement lists are positional and must be the same length.",
   inputSchema: z.object({
     order_id: OrderIdField,
     item_ids: z
@@ -29,58 +33,16 @@ export default retailTool({
       .describe("Method to charge or refund the price difference, e.g. 'gift_card_0000000'"),
   }),
   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 });
-
-    // 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, args.item_ids, args.new_item_ids, {
-      requireDifferent: true,
-    });
+    const plan = planModifyItems(
+      state,
+      args.order_id,
+      args.item_ids,
+      args.new_item_ids,
+      args.payment_method_id,
+    );
     if (isToolFailure(plan)) return plan;
-
-    const blocked = assertCanCoverDiff(user, args.payment_method_id, plan.diff);
-    if (blocked) return blocked;
-
-    const method = user.payment_methods[args.payment_method_id];
-    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: args.payment_method_id,
-    });
-
-    applySwap(order, plan);
-    order.status = "pending (item modified)";
-
-    return {
-      order_id: order.order_id,
-      status: order.status,
-      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 ${args.payment_method_id}. This order can no longer be modified or cancelled.`
-          : `Done. $${Math.abs(plan.diff).toFixed(2)} is being refunded to ${args.payment_method_id}. This order can no longer be modified or cancelled.`,
-    };
+    setFocus(state, { orderId: plan.orderId });
+    return stageAction(state, { kind: "modify_pending_order_items", plan });
   },
-  summary: (_args, result) =>
-    `modified ${result.order_id} (${result.price_difference >= 0 ? "+" : ""}${result.price_difference})`,
+  summary: (_args, result) => `staged: ${result.read_back}`,
 });