@agent-cards/commerce-sdk 0.15.0 → 0.17.0

package/dist/buy-tool.js

@@ -33,12 +33,13 @@
  */
 import { AgentcardApiError, AgentcardClient, cartBuildingOf, } from './client.js';
 import { buyToolDefinition, buyToolStandardSchema, openAIBuyTool, parseBuyToolInput, } from './definition.js';
-import { directCall } from './direct.js';
-import { forModel, forModelError, pickId, productPrice, productCardKey, replyAsWritten, shownProducts, shownStores, stripLinks } from './model-view.js';
-import { messageStream, paceOf, sleep, toMessages, typingHook } from './messages.js';
+import { directCall, isProductAsk } from './direct.js';
+import { forModel, forModelError, pickId, productPrice, productCardKey, shownProducts, shownStores, stripLinks } from './model-view.js';
+import { choiceLines, leadsIntoList, messageForShopper, messagesListChoice, replyAsWritten, textingStyle } from './texting.js';
+import { joinLeadIns, leadInJoiner, messageStream, paceOf, paragraphsOf, sleep, toMessages, typingHook } from './messages.js';
 import { isStale } from './shopper-message.js';
 import { actionLinkId, isActionLink } from './action-links.js';
-import { ACK_REACTION, ackAt, answersQuestion, instantAck as instantAckOf, isNewRequest, isPickText, keepsYes, namesStore, nextTemplate, slowStepLine, waitAt } from './ack.js';
+import { ACK_REACTION, ackAt, answersCheckout, answersQuestion, holdsBack, instantAck as instantAckOf, isNewRequest, isPickText, keepsYes, namesStore, nextTemplate, readsAsAckLine, slowStepLine } from './ack.js';
 /** The action a product of `merchant` takes (BuyToolProductAction). */
 export function productAction(merchant) {
     if (merchant === 'reservations')
@@ -109,8 +110,8 @@ const RESUME_SKEW_MS = 2 * 60_000;
 const STOPPED_ORDER = new Set(['failed', 'cancelled']);
 /** The refusals a confirm gets once the order took the cart, or while the placement still runs. */
 const AFTER_PLACEMENT = new Set(['nothing_to_confirm', 'conversation_closed', 'turn_in_progress']);
-/** How long Agentcard has to answer before the instant reply goes out. */
-const ACK_DELAY_MS = 1_500;
+/** How long a turn shows the shopper nothing before the line that says it is on it goes out. */
+const ACK_DELAY_MS = 1_000;
 /** A call that starts this soon after the last one ended belongs to the same model turn, which gets one instant reply. */
 const SAME_TURN_MS = 15_000;
 /** A product name shorter than this, such as `AA`, is too short to tell a pick from a search. */
@@ -145,6 +146,70 @@ const NOTHING_TO_CONFIRM = 'There is no cart to confirm yet. Ask the shopper wha
 const ADDRESS_CHANGED = 'The delivery address changed since this cart was built. Ask for the cart again, and Agentcard prices it for the new address.';
 const STORE_PICK_GONE = "The store the shopper picked is no longer among the stores Agentcard found, so no store was chosen. Call this tool again with the shopper's words and store_id null, and Agentcard searches again.";
 const PICK_GONE = "The product the shopper picked is no longer among the products Agentcard found, so nothing was added. Call this tool again with the shopper's words and product_id null, and Agentcard searches again.";
+/** One cart line as the order holds it: the product, its variant, its choices and its quantity. Prices are left out. */
+const lineKey = (line) => JSON.stringify([line.product_id ?? String(line.name ?? '').trim().toLowerCase(), line.variant ?? null, [...(line.options ?? [])].sort(), line.qty]);
+/**
+ * How two matched lines' prices stand: false when a price they both name moved, true when one they both name agrees, and
+ * null when they name none in common, so the lines say nothing about what they cost.
+ */
+function linePriceStands(a, b) {
+    const named = (x, y) => typeof x === 'number' && typeof y === 'number' ? x === y : null;
+    const read = [named(a.priceCents, b.priceCents), named(a.lineTotalCents, b.lineTotalCents)];
+    if (read.includes(false))
+        return false;
+    return read.includes(true) ? true : null;
+}
+/**
+ * True when two carts are the same order: the same store, the same items in the same quantities with the same choices,
+ * and the same price for those items. Only the total may differ, as when the store prices its fees, tax and delivery in
+ * once the shopper's account holds the cart (Mendocino Farms on DoorDash, 2026-10-27: about $15.90, then $17.89).
+ *
+ * What the items cost has to be shown to be the same: every matched line's prices agree, or both carts name a subtotal
+ * and it is equal. A line whose price moved, two lines whose prices swapped under one subtotal, and a cart nothing
+ * prices are each a different order, so the shopper is asked again (review of #11087).
+ */
+function sameOrder(a, b) {
+    if (a.merchant !== b.merchant || (a.store?.id ?? null) !== (b.store?.id ?? null))
+        return false;
+    if ((a.currency ?? null) !== (b.currency ?? null))
+        return false;
+    const subtotals = typeof a.subtotalCents === 'number' && typeof b.subtotalCents === 'number' ? a.subtotalCents === b.subtotalCents : null;
+    if (subtotals === false)
+        return false;
+    const lines = (cart) => [...(cart.items ?? [])].sort((p, q) => (lineKey(p) < lineKey(q) ? -1 : lineKey(p) > lineKey(q) ? 1 : 0));
+    const [x, y] = [lines(a), lines(b)];
+    if (x.length === 0 || x.length !== y.length || !x.every((line, i) => lineKey(line) === lineKey(y[i])))
+        return false;
+    const prices = x.map((line, i) => linePriceStands(line, y[i]));
+    if (prices.includes(false))
+        return false;
+    return subtotals === true || prices.every((stands) => stands === true);
+}
+/** True when `now` holds an item `before` did not: the call put something new in the cart. */
+function addsItem(now, before) {
+    if (!now || (now.items ?? []).length === 0)
+        return false;
+    const had = new Set((before && before.merchant === now.merchant ? before.items ?? [] : []).map((line) => lineKey({ ...line, qty: 0 })));
+    return (now.items ?? []).some((line) => !had.has(lineKey({ ...line, qty: 0 })));
+}
+/**
+ * The yes left standing when a confirm stopped for a step outside the chat, or null. The cart the confirm stopped on must
+ * be the same order as the one the yes covers; the total the shopper said yes to stays the one they saw.
+ */
+function yesAfter(result, yes) {
+    const stopped = result.cart ?? (result.carts.length === 1 ? result.carts[0] : null);
+    if ('carried' in yes) {
+        if (stopped && !sameOrder(stopped, yes.carried.cart))
+            return null;
+        return { ...yes.carried, cart: stopped ?? yes.carried.cart, conversationId: result.conversation_id ?? yes.carried.conversationId };
+    }
+    const seen = yes.shown ?? stopped;
+    if (!seen || (yes.shown && stopped && !sameOrder(yes.shown, stopped)))
+        return null;
+    return { conversationId: result.conversation_id, cart: stopped ?? seen, totalCents: seen.totalCents };
+}
+/** The words of the call a `nextStep` turn's `direct` makes. They never reach Agentcard: the turn's calls send no ask. */
+const NEXT_STEP_ASK = 'take the next step';
 /** What a call of a `nextStep` turn answers with when the shopper has not said yes to the cart on the table. */
 const ASK_FOR_YES = "The cart is ready, and the shopper has not said yes to it in the chat, so nothing was confirmed. Say the cart's total in one short line and ask for their yes.";
 const STEP_AFTER_DECLINE = 'The shopper declined the approval, so nothing was charged and no order was placed. The cart is still here. Say so in one short line and offer the way forward: their yes sends a new approval link, or they can change the order.';
@@ -264,6 +329,7 @@ function answerOf(turn) {
         store_pick: turn.store_pick,
         hashes: hashesOf(turn.cart, turn.carts),
         cart_building: turn.cart_building,
+        choice: turn.choice ?? null,
         envelope: turn.raw,
     };
 }
@@ -304,7 +370,8 @@ function onlyNextStepLinks(result, next) {
  */
 function withMessages(result, turn) {
     const sent = turn && result.reply === turn.reply && turn.messages.length > 0 ? turn.messages : [result.reply];
-    return { ...result, messages: sent.flatMap(toMessages) };
+    // One joiner across every message, so a message that is only a lead-in goes with the next one rather than out of the list.
+    return { ...result, messages: joinLeadIns(sent.flatMap(paragraphsOf)) };
 }
 /** True when the app showed every message of an answer that has one, each as written and in order. */
 function readEvery(told, messages) {
@@ -484,6 +551,8 @@ function senderOf(t) {
  */
 function itemFeed(pauseOf, typing) {
     const items = [];
+    // How many items joined the feed, sent or still going out: one means the shopper has something to read.
+    let pushed = 0;
     // The item going out now, or null when none is: an item pushed while none is goes out at once.
     let tail = null;
     let lastAt = null;
@@ -518,6 +587,7 @@ function itemFeed(pauseOf, typing) {
      * unlisted, with no pause, as for the rest of a reply whose earlier message failed.
      */
     const push = (item, send, skip = () => false) => {
+        pushed += 1;
         // Each message's pause is chosen once, when it joins the feed, so a pace that varies never makes it wait twice.
         const pause = item.kind === 'text' && pauseOf ? pauseOf(item.text) : 0;
         const waitFor = () => (pause > 0 && lastAt !== null ? lastAt + pause - Date.now() : 0);
@@ -545,7 +615,7 @@ function itemFeed(pauseOf, typing) {
         tail = settled;
         return run;
     };
-    return { items, push };
+    return { items, push, pushed: () => pushed };
 }
 /**
  * One reply's messages in a turn's feed: each one takes its place in the feed the moment it is cut,
@@ -682,6 +752,8 @@ export function buyTool(options) {
         throw new TypeError('Pass earlyCards as true or false.');
     // A search's cards go out the moment it answers, unless the app waits for the answer that names them.
     const earlyCards = o.earlyCards !== false;
+    // Every call streams unless the app waits for whole answers (`stream: false`).
+    const streamCalls = o.stream !== false;
     if (o.onResult !== undefined && typeof o.onResult !== 'function') {
         throw new TypeError('Pass onResult as a function that takes each answer.');
     }
@@ -689,6 +761,9 @@ export function buyTool(options) {
     if (o.replyAsWritten !== undefined && typeof o.replyAsWritten !== 'boolean')
         throw new TypeError('Pass replyAsWritten as true or false.');
     const writtenByDefault = o.replyAsWritten === true;
+    if (o.textingStyle !== undefined && typeof o.textingStyle !== 'boolean')
+        throw new TypeError('Pass textingStyle as true or false.');
+    const textingByDefault = o.textingStyle === true;
     if (o.direct !== undefined && typeof o.direct !== 'boolean')
         throw new TypeError('Pass direct as true or false.');
     const directOn = o.direct === true;
@@ -749,6 +824,7 @@ export function buyTool(options) {
         onAvailability: o.onAvailability,
         onProducts: o.onProducts,
         onText: o.onText,
+        texting: textingByDefault,
         onCart: o.onCart,
         links: null,
         results: null,
@@ -781,14 +857,25 @@ export function buyTool(options) {
     /** The conversation and the carts of the last answer, for a `nextStep` call that cannot read the conversation. */
     let lastConversationId = null;
     let lastCarts = [];
-    /** The hash of the cart the last answer showed: the cart a confirm sent now confirms. */
-    let lastShownHash = null;
+    /** The cart the last answer showed: the cart a confirm sent now confirms. */
+    let lastShownCart = null;
     /**
-     * The yes the shopper gave in the chat to one cart, by its hash, when the confirm it sent stopped for a
-     * step outside the chat: a card to add or a store to sign in to. A `nextStep` turn confirms that cart
-     * once the step is done. Any shopper message that is not a plain go-ahead, `ok` or `done` takes it back.
+     * The yes the shopper gave in the chat to one cart, when the confirm it sent stopped for a step outside the chat: a card
+     * to add or a store to sign in to. A `nextStep` turn confirms the cart once the step is done, as long as it holds the
+     * same items at the same store (`sameOrder`): a total that moved because the store priced its fees and tax in keeps the
+     * yes, and the turn says the new total. Any shopper message that is not a plain go-ahead, `ok` or `done` takes it back,
+     * and so does a declined approval.
      */
     let carriedYes = null;
+    /**
+     * The go-ahead of the shopper's pick, when they picked what is in the cart and answered only the checkout's questions
+     * since (address, phone, name, email, a yes to an address read back). A `nextStep` turn after a saved card or a store
+     * sign-in confirms that cart as it stands, when it is the same order (`sameOrder`), whatever the Vault does: the approval
+     * link is the shopper's approval. Any other shopper message takes it back, and so do a cart that changed and a declined approval.
+     */
+    let pickedOrder = null;
+    /** How many shopper messages took a pick's go-ahead back: a call that started before one leaves no pick behind. */
+    let pickWithdrawals = 0;
     /** The add-card link an answer carried while it asked for the store sign-in first: the card is the step after it. */
     let cardAfterSignIn = null;
     /** The shopper's words that never ran because they were not connected yet: they run once their card is saved. */
@@ -809,6 +896,8 @@ export function buyTool(options) {
     };
     /** What the last answer showed, products and stores with the ids a pick sends, and the turn the shopper opened last. */
     let lastAnswerProducts = [];
+    /** Every product card of the last answer's call the shopper can tap by name, each once (the answer's and the streamed). */
+    let lastTappable = [];
     let lastAnswerStores = [];
     let previousTurn = null;
     /** The names of the stores the last answer that listed stores showed: a message that names one, as a tap on its card does, picks it. */
@@ -834,7 +923,17 @@ export function buyTool(options) {
      * way a shopper message reaches the tool runs it: `turn`, `instantAck` and `instantReaction` (review of #9220).
      */
     const withdrawUnlessGoAhead = (shopperText) => {
-        if (keepsYes(String(shopperText ?? '')))
+        const text = String(shopperText ?? '');
+        const goAhead = keepsYes(text);
+        // A pick's go-ahead also stands through the answers the checkout asks for, and through the answer that lets the store
+        // cart the pick, such as a size, while no cart holds it yet.
+        // Counted with no pick standing too, so a pick still running when the shopper says "no wait" leaves none behind.
+        // A short `cancel`, `wait` or `no` answers the question's shape, so it never counts as the answer the pick waits on.
+        if (!goAhead && !answersCheckout(text, { nextAction: lastNextAction, asked: lastReply }) && !(pickedOrder?.cart === null && answersQuestion(text, lastReply) && !holdsBack(text))) {
+            pickedOrder = null;
+            pickWithdrawals++;
+        }
+        if (goAhead)
             return;
         carriedYes = null;
         unconnectedAsk = null;
@@ -873,8 +972,42 @@ export function buyTool(options) {
     const holdAck = (ask, t, step = null) => {
         const onWorking = t.onWorking;
         const reacting = t.onReaction;
-        if ((!onWorking && !reacting) || t.acked)
+        // A turn the app ended (`turn.end()`) holds no acknowledgement for a call it still runs.
+        if ((!onWorking && !reacting) || t.acked || t.ended)
             return null;
+        const model = t.modelTurn;
+        if (model && onWorking && model.writesThrough()) {
+            // The app's model called the tool. When it wrote its own line first, that line is the turn's acknowledgement; when
+            // its first output is this call, the shopper hears the wait line, no sooner than ackDelayMs after the turn opened.
+            model.callStarted = true;
+            if (model.spoke || model.shown())
+                return null;
+            t.acked = true;
+            const line = slowStepLine(step === 'confirm' ? 'confirm' : step ?? t.picked ?? 'wait');
+            let waiting = true;
+            const waitTimer = setTimeout(() => {
+                waiting = false;
+                // The model may have written its own line while this call ran: that line is the turn's acknowledgement, so the
+                // wait line is dropped and the turn's reply is free for a later call.
+                if (model.spoke || model.shown() || t.ended) {
+                    t.acked = false;
+                    return;
+                }
+                t.waitLineOut = true;
+                t.ackOut = Promise.resolve()
+                    .then(() => onWorking(line))
+                    .then(() => { t.ackDelivered = true; }, () => { });
+            }, Math.max(0, model.openedAt + ackDelayMs - Date.now()));
+            return {
+                cancel: () => {
+                    if (!waiting)
+                        return;
+                    waiting = false;
+                    clearTimeout(waitTimer);
+                    t.acked = false;
+                },
+            };
+        }
         // A confirm, or a pick of what the shopper saw, gets fixed words that never say `looking for`.
         const slow = step ?? t.picked ?? (!t.neutral && (namesShown(ask) || isPickText(ask)) ? 'pick' : null);
         // A short answer to the question the last reply asked, such as `medium` after `what size?`, is no
@@ -883,10 +1016,19 @@ export function buyTool(options) {
         // A slow call of any message may get the 👀, which reads nothing back; only a text reply needs one of these.
         if (!reacting && !slow && !neutral && !isNewRequest(ask))
             return null;
+        // A streamed search's line is Agentcard's (onAck), written from the conversation while it searches: the tool adds no
+        // template of its own, unless the app writes the words.
+        if (!reacting && !slow && !neutral && streamCalls && !writeAck)
+            return null;
         t.acked = true;
         let held = true;
         const timer = setTimeout(() => {
             held = false;
+            // The app ended the turn while this call ran, as after its model failed: no 👀 and no line follow its error.
+            if (t.ended) {
+                t.acked = false;
+                return;
+            }
             // With reactions, a slow call puts the message's one 👀 on it, and never adds a line of text.
             if (reacting) {
                 react(t, reacting);
@@ -911,7 +1053,7 @@ export function buyTool(options) {
                 lastTemplate = nextTemplate(lastTemplate);
                 // A neutral turn's message, such as `yes` or `ok lets checkout`, is no search: its reply says the
                 // tool is working, and never that it is looking for anything.
-                text = neutral ? waitAt(lastTemplate) : ackAt(lastTemplate, ask);
+                text = neutral ? slowStepLine('wait') : ackAt(lastTemplate, ask);
             }
             if (typeof text !== 'string' || text.trim() === '') {
                 t.acked = false;
@@ -1322,7 +1464,7 @@ export function buyTool(options) {
             return;
         const outside = result.status === 'needs_card' || result.next_action === 'add_card' || result.next_action === 'store_login';
         if (call.confirm)
-            carriedYes = outside && call.yesHash ? { hash: call.yesHash } : null;
+            carriedYes = outside ? yesAfter(result, call.yes) : null;
         if (result.next_action === 'store_login' && turn?.add_card_url)
             cardAfterSignIn = { url: turn.add_card_url, expiresAt: turn.add_card_expires_at };
         else if (result.next_action !== 'store_login')
@@ -1330,6 +1472,45 @@ export function buyTool(options) {
         if (!call.confirm && call.ask !== '')
             unconnectedAsk = result.error_code === 'user_not_connected' ? call.ask : null;
     };
+    /**
+     * What a shopper's own call leaves of a pick's go-ahead (`pickedOrder`). A pick, a tap on a product's card or a request
+     * to buy it, that leaves one cart and no list of products to choose from starts one, with that cart; one whose store still
+     * asks a question before it carts the pick starts one with no cart yet. A later answer keeps it while the cart stays the
+     * same order, and notes the cart as the chat shows it now; an answer whose cart changed, another purchase, more than one
+     * cart, or a confirm of the shopper's own ends it. `heard` is false for a call whose shopper message no turn read
+     * (`withdrawUnlessGoAhead`): its words must then answer the checkout too.
+     */
+    const notePick = (result, call) => {
+        if (call.pickWithdrawalsAtStart !== pickWithdrawals)
+            return;
+        const now = result.cart ?? (result.carts.length === 1 ? result.carts[0] : null);
+        if (call.picking) {
+            // A search that listed products beside a cart already there picked nothing in it; one that carted what it names did.
+            const listed = shownProducts(result.products).length > 0;
+            pickedOrder = result.carts.length > 1
+                ? null
+                : now && (!listed || call.added)
+                    ? { conversationId: result.conversation_id, cart: now }
+                    : !now && !listed && result.error_code === null
+                        ? { conversationId: result.conversation_id, cart: null }
+                        : null;
+            return;
+        }
+        const picked = pickedOrder;
+        if (!picked)
+            return;
+        if (call.confirm || result.carts.length > 1 || (picked.conversationId && result.conversation_id && result.conversation_id !== picked.conversationId)) {
+            pickedOrder = null;
+            return;
+        }
+        if (!call.heard && !keepsYes(call.ask) && !answersCheckout(call.ask, { nextAction: call.asked.nextAction, asked: call.asked.reply })) {
+            pickedOrder = null;
+            return;
+        }
+        if (!now)
+            return;
+        pickedOrder = picked.cart === null || sameOrder(now, picked.cart) ? { conversationId: picked.conversationId ?? result.conversation_id, cart: now } : null;
+    };
     /** An answer the tool writes itself, from where the purchase stands, with nothing sent to Agentcard. */
     const stepResult = (fields) => ({
         messages: [],
@@ -1371,6 +1552,7 @@ export function buyTool(options) {
         const standing = { cart: one ?? carts.at(-1) ?? null, carts, hashes: carts.map((c) => c.hash), conversation_id: conversationId };
         if (event.kind === 'approval_declined') {
             carriedYes = null;
+            pickedOrder = null;
             return { local: stepResult({ ...standing, status: 'needs_input', reply: carts.length > 0 ? STEP_AFTER_DECLINE : NO_CART_WAITING }) };
         }
         if (event.kind === 'card_added' && unconnectedAsk) {
@@ -1384,9 +1566,28 @@ export function buyTool(options) {
             cardAfterSignIn = null;
             return { local: stepResult({ ...standing, status: 'needs_card', reply: CARD_AFTER_SIGN_IN, links: [{ kind: 'vault', url: link.url, expiresAt: link.expiresAt }], next_action: 'add_card' }) };
         }
-        if (carriedYes && one && conversationId && one.hash === carriedYes.hash) {
+        // The shopper's yes goes on past the step they just finished: the same items at the same store, in the same purchase,
+        // confirmed by the cart's hash as it stands now. A total that moved because the store priced its fees and tax in keeps
+        // the yes, and the answer says the new total beside the next ask; the approval link is still the shopper's consent to
+        // the payment (Karen, 2026-10-27).
+        const yes = carriedYes;
+        const inPurchase = (at) => at === null || at === conversationId;
+        if (yes && one && conversationId && inPurchase(yes.conversationId) && sameOrder(one, yes.cart)) {
             carriedYes = null;
-            return { body: { confirm: one.hash, conversation_id: conversationId, payment_source: 'vault', ...who } };
+            return { body: { confirm: one.hash, conversation_id: conversationId, payment_source: 'vault', ...who }, yes: { ...yes, cart: one, conversationId } };
+        }
+        // The shopper picked what is in the cart and finished the step outside the chat: finishing it is their go-ahead for the
+        // same order, confirmed by the cart's hash as it stands now, and the approval link stays their consent to the payment
+        // (Karen, 2026-10-27: "we are again asking for confirmation after user adds a card. we should assume they want to move
+        // forward"). That holds whatever the shopper's Vault does: the approval link is the approval (Karen, 2026-10-27: "That
+        // is the goal of the approval link. You shouldn't be asking again. Take the approval from the approval link as the
+        // approval.").
+        const picked = pickedOrder;
+        if (picked?.cart && one && conversationId && inPurchase(picked.conversationId) && (event.kind === 'card_added' || event.kind === 'store_connected')) {
+            pickedOrder = null;
+            if (sameOrder(one, picked.cart)) {
+                return { body: { confirm: one.hash, conversation_id: conversationId, payment_source: 'vault', ...who }, yes: { conversationId, cart: one, totalCents: picked.cart.totalCents, picked: true } };
+            }
         }
         // A checkout the shopper already moved past their yes (an approval link waiting, or the order going through) is reported as
         // it stands: the cart stays while it waits, and asking for another yes would contradict the link they have (review of #9220).
@@ -1443,13 +1644,22 @@ export function buyTool(options) {
             ...(client.company ? { external_user_id: externalUserId } : {}),
         };
         // The cart a confirm sent now confirms, for the yes it carries past a step outside the chat.
-        const yesHash = confirm ? lastShownHash : null;
+        const yesShown = confirm ? lastShownCart : null;
+        // A pick of what the shopper saw, by a product's id or its name, or a request to buy something: when its answer carts
+        // it, the shopper's go-ahead for that cart (`notePick`). Read before the answer replaces what the shopper saw.
+        const picksShown = !confirm && (!!pick?.product_id || pickOf(ask) !== null || isProductAsk(ask));
+        const cartBefore = lastShownCart;
+        const pickWithdrawalsAtStart = pickWithdrawals;
+        const askedBefore = { nextAction: lastNextAction, reply: lastReply };
         // The first call after `instantAck` opens the turn of the message it answered, whose reply is the
         // app's. Any other call that starts while another runs, or right after one ended, is the model
         // working through the same turn. A call made through `buy.turn` belongs to that turn alone.
+        // Whether a turn read the shopper's message (`withdrawUnlessGoAhead`): `buy.turn`, or the app's instant reply.
+        let heard = !!explicit;
         if (!explicit) {
             const opened = appAck && Date.now() - appAck.at < APP_TURN_MS ? appAck : null;
             appAck = null;
+            heard = !!opened;
             if (opened) {
                 // Only a reply the app sent quiets onWorking. A message such as `yes` that starts a slow search
                 // still gets a reply that names nothing, and a slow pick gets one that says it is on it.
@@ -1464,20 +1674,31 @@ export function buyTool(options) {
         // A turn the tool took on its own sends no ask: it reads where the purchase stands, and only the
         // shopper's own yes to this exact cart goes in, for that cart's hash.
         const plan = t.event ? await stepPlan(t.event) : null;
-        const sent = plan && 'body' in plan ? plan.body : body;
-        const confirmSent = plan ? 'body' in plan && sent.confirm !== undefined : confirm;
+        const planned = plan && 'body' in plan ? plan.body : body;
+        const confirmSent = plan ? 'body' in plan && planned.confirm !== undefined : confirm;
+        // Agentcard writes the line that says what it is looking for (onAck) only where the shopper can read it before the
+        // cards and has read nothing yet: a streamed ask, with somewhere to show it, that no reaction, reply or model's words
+        // acknowledged already, in an app that asked for no acknowledgement of its own (`ack: 'none'` or `ack: false` gets
+        // none, there as here) and acknowledges in text: an app that reacts (`ack: 'reaction'`, or an `onReaction` the turn
+        // routes to) reads no line of text, even through `onText`. Every other ask says so, and Agentcard spends no model call on it.
+        const agentcardAcks = streamCalls && ackMode !== 'none' && ackMode !== 'reaction' && !t.onReaction && !t.event && !confirmSent && !pick && !t.acked && (!!t.onWorking || !!t.onText) && (t.agentcardAcks?.(ask) ?? false);
+        /** What goes to Agentcard: the planned request, with `ack: false` when the shopper reads no line of Agentcard's. */
+        let sent = planned;
         const callTurn = t.number;
         const send = senderOf(t);
         const progressOf = t.onProgress;
         // Every call streams unless the app waits for whole answers, so each part reaches the app as Agentcard produces it. A
         // confirm streams as a search does, and only a search's products go out early. A call with no callback to hear any part
         // has no handler, and the client asks for the whole answer.
-        const streams = o.stream !== false;
+        const streams = streamCalls;
         const early = earlyCards && !!send && !confirmSent;
         running += 1;
+        t.called = true;
         // A confirm or a pick of what the shopper saw never hears "looking for": once the call is slow, it hears a
         // fixed line that names nothing they said (slowStepLine), so a 20-second checkout or menu read is never silent.
         const ack = t.event ? null : holdAck(ask, t, confirm ? 'confirm' : pick?.product_id ? 'product' : pick ? 'pick' : null);
+        if (ack)
+            (t.holds ??= new Set()).add(ack.cancel);
         /** Says `unknown` of every card the call left `checking`; it runs once the answer's cards went out, or when the call fails. */
         let settleLeft = null;
         try {
@@ -1490,10 +1711,53 @@ export function buyTool(options) {
              * and every message after it, so the shopper reads them in the order Agentcard wrote them.
              */
             const waiting = [];
+            /** True when the last message the shopper read ended in a colon or a question mark, so choices that open the next one are its list. */
+            let leadIn = false;
+            /** A message that leads in with a colon waits for the one after it (leadInJoiner), and `heldTexts` keeps it as Agentcard wrote it. */
+            let leads = leadInJoiner();
+            let heldTexts = [];
+            /** Shows a message through onText, its lists as bullets (messageForShopper); `told` keeps each of Agentcard's messages in it as written. */
+            const showMessage = async (message, texts, conversationId) => {
+                await t.onText(messageForShopper(message, leadIn, t.texting), { conversationId });
+                leadIn = leadsIntoList(message);
+                told.push(...texts);
+            };
+            /**
+             * Shows one of Agentcard's messages through onText. One that ends on a colon, such as `two options came in under $20:`,
+             * goes out with the message after it, so the shopper never reads a bubble ending on a colon.
+             */
+            const showText = async (text, conversationId) => {
+                const message = leads.add(text);
+                heldTexts.push({ text, conversationId });
+                if (message === null)
+                    return;
+                const texts = heldTexts.map((held) => held.text);
+                heldTexts = [];
+                await showMessage(message, texts, conversationId);
+            };
+            /**
+             * A lead-in no message followed, once the answer is in: its list went (the cards show it), so it goes out less its colon
+             * sentence, and not at all when that was all of it. It counts as read when anything was, so the model never words again
+             * what the shopper read.
+             */
+            const showLeftLead = async () => {
+                if (heldTexts.length === 0)
+                    return;
+                const rest = leads.end();
+                const texts = heldTexts.map((held) => held.text);
+                const conversationId = heldTexts[0].conversationId;
+                heldTexts = [];
+                if (rest)
+                    await showMessage(rest, texts, conversationId);
+                else if (told.length > 0)
+                    told.push(...texts);
+            };
             /** The products past the cards of the catalog this call heard last, for the count that follows it. */
             let moreFound = null;
             /** Whether this call's cards went out, and a count that came before them. */
             let cardsOut = false;
+            /** The product cards this call's searches sent out as they answered, which the shopper can tap whatever the answer lists. */
+            const streamedCards = [];
             let heldCount = null;
             /** The card each catalog id of this call went out as (its `productId`), and the cards still `checking`, by conversation. */
             const cardOfId = new Map();
@@ -1602,6 +1866,7 @@ export function buyTool(options) {
                                 await deliverPagesInTurn(earlyPages(update.conversationId, update.asOf, withAnswers(productsOfCatalog(update.catalog))), { turn: callTurn, presented: true, owner: t }, send);
                                 // A place shown `checking`, on a card or behind "show more", waits for the live search's word on it.
                                 noteCards([...productsOfCatalog(update.catalog), ...productsOfCatalog({ ...update.catalog, items: update.more })], update.conversationId);
+                                streamedCards.push(...productsOfCatalog(update.catalog));
                                 keepMore();
                                 cardsOut = true;
                                 // A count held for these cards goes out now, unless the catalog carries its own, which follows it.
@@ -1631,8 +1896,7 @@ export function buyTool(options) {
                                     return;
                                 }
                                 try {
-                                    await t.onText(text, { conversationId });
-                                    told.push(text);
+                                    await showText(text, conversationId);
                                 }
                                 catch {
                                     // A message the app failed to show was never read, so the model words the answer.
@@ -1640,6 +1904,24 @@ export function buyTool(options) {
                             },
                         }
                         : {}),
+                    ...(agentcardAcks
+                        ? {
+                            // Agentcard's line for the search, such as `one sec, checking target for la croix`: it goes out as the turn's
+                            // instant reply, through onWorking, else as Agentcard's message, and only while the shopper has read nothing
+                            // else of the turn. The model then reads `shopper_already_told_looking`.
+                            onAck: async ({ text, conversationId }) => {
+                                if (t.acked || cardsOut || told.length > 0 || waiting.length > 0)
+                                    return;
+                                ack?.cancel();
+                                t.acked = true;
+                                const line = text.trim();
+                                t.ackOut = Promise.resolve()
+                                    .then(() => (t.onWorking ? t.onWorking(line) : t.onText?.(line, { conversationId })))
+                                    .then(() => { t.ackDelivered = true; }, () => { });
+                                await t.ackOut;
+                            },
+                        }
+                        : {}),
                     ...(t.onCart
                         ? {
                             onCart: async ({ cart, carts, conversationId }) => {
@@ -1654,6 +1936,9 @@ export function buyTool(options) {
                         : {}),
                 }
                 : undefined;
+            // A streamed ask for something new that the tool shows no line of Agentcard's for says so. A pick never gets one.
+            const streamed = !!handlers && Object.values(handlers).some((handler) => typeof handler === 'function');
+            sent = planned.ask !== undefined && !planned.pick && streamed && !agentcardAcks ? { ...planned, ack: false } : planned;
             if (plan && 'local' in plan) {
                 // Nothing went to Agentcard: the answer is where the purchase stands.
             }
@@ -1671,6 +1956,8 @@ export function buyTool(options) {
                 // Only the answer of the request sent again counts toward what the shopper read.
                 told.length = 0;
                 waiting.length = 0;
+                leads = leadInJoiner();
+                heldTexts = [];
                 try {
                     turn = await client.buy(sent, handlers);
                     refusal = undefined;
@@ -1688,15 +1975,15 @@ export function buyTool(options) {
             let replaced = false;
             if (waiting.length > 0 && t.onText) {
                 const rewritten = !!turn && settled.reply !== turn.reply;
-                const kept = new Set((rewritten ? toMessages(settled.reply) : []).map((message) => message.trim()));
+                // Paragraph for paragraph, as `told` keeps Agentcard's messages, before any lead-in joins the one after it.
+                const kept = new Set((rewritten ? paragraphsOf(settled.reply) : []).map((message) => message.trim()));
                 for (const message of waiting.splice(0)) {
                     if (rewritten && waitsForAnswer(message.text) && !kept.has(message.text.trim())) {
                         replaced = true;
                         continue;
                     }
                     try {
-                        await t.onText(message.text, { conversationId: message.conversationId });
-                        told.push(message.text);
+                        await showText(message.text, message.conversationId);
                     }
                     catch {
                         // A message the app failed to show was never read, so the model words the answer.
@@ -1705,17 +1992,37 @@ export function buyTool(options) {
                 const stepAsk = turn?.next_action ? CHAT_STEP_ASKS[turn.next_action] : undefined;
                 if (replaced && stepAsk && settled.reply.endsWith(stepAsk)) {
                     try {
-                        await t.onText(stepAsk, { conversationId: settled.conversation_id });
-                        told.push(stepAsk);
+                        await showText(stepAsk, settled.conversation_id);
                     }
                     catch {
                         // Not shown, so the model asks for the step.
                     }
                 }
             }
+            if (t.onText) {
+                try {
+                    await showLeftLead();
+                }
+                catch {
+                    // A message the app failed to show was never read, so the model words the answer.
+                }
+            }
             // Every message of Agentcard's own answer reached the shopper through onText, so the model adds nothing to it. An answer
             // whose card ask gave way to the named step was read the same way once every message of it, that ask last, went out.
-            const read = !!turn && (settled.reply === turn.reply ? readEvery(told, turn.messages) : replaced && readEvery(told, toMessages(settled.reply)));
+            // A reply the shopper read that asks them to choose, with the values named inside a sentence or not at all, is followed
+            // by one more message that lists every value on its own line (choiceLines), so no choice is read buried in prose.
+            let choiceShown = true;
+            if (t.onText && turn?.choice && told.length > 0 && !messagesListChoice(told, turn.choice)) {
+                const lines = choiceLines(turn.choice);
+                try {
+                    await t.onText(t.texting ? textingStyle(lines) : lines, { conversationId: turn.conversation_id || null });
+                }
+                catch {
+                    // Not shown, so the shopper has not read the whole answer: the model words it, with the choice it reads.
+                    choiceShown = false;
+                }
+            }
+            const read = choiceShown && !!turn && (settled.reply === turn.reply ? readEvery(told, turn.messages) : replaced && readEvery(told, paragraphsOf(settled.reply)));
             const answer = withMessages(settled, turn);
             const delivered = await deliver(answered.size > 0 ? { ...answer, products: withAnswers(answer.products) } : answer, { turn: callTurn, presented: turn?.catalog?.presented === true, owner: t }, send);
             // A count that came before any card (find mode puts its cards in the answer) goes out once the answer's cards did.
@@ -1733,10 +2040,19 @@ export function buyTool(options) {
             // The call waits for it, and one that fails to send fails the call, as a step link the turn does not hold does.
             if (read)
                 await t.releaseNow?.();
+            // A confirm the turn sent on the shopper's earlier yes names the total they said yes to beside the cart's total now. A
+            // confirm Agentcard refused, or one whose answer holds another order or asks for a yes, carried nothing: the model asks.
+            const carried = plan && 'body' in plan && plan.yes && turn && delivered.next_action !== 'confirm' ? plan.yes : null;
+            const nowCart = !carried ? null : !delivered.cart ? carried.cart : sameOrder(delivered.cart, carried.cart) ? delivered.cart : null;
+            const yesCarried = carried && nowCart
+                ? { said_yes_to_cents: carried.totalCents, total_cents: nowCart.totalCents, currency: nowCart.currency ?? null, ...(carried.picked ? { picked: true } : {}) }
+                : null;
             const result = {
                 ...delivered,
                 ...(t.ackDelivered ? { shopper_already_told_looking: true } : {}),
                 ...(read ? { shopper_already_read_reply: true } : {}),
+                ...(confirmSent ? { confirm_sent: true } : {}),
+                ...(yesCarried ? { yes_carried: yesCarried } : {}),
             };
             lastNextAction = result.next_action;
             lastReply = result.reply;
@@ -1749,12 +2065,19 @@ export function buyTool(options) {
             if (result.conversation_id)
                 lastConversationId = result.conversation_id;
             if (result.cart?.hash)
-                lastShownHash = result.cart.hash;
+                lastShownCart = result.cart;
             // A shopper's own call, or the shopper's yes or words a turn taken on its own sent, leaves what the next step needs.
             if (!t.event)
-                noteShopperStep(result, turn, { confirm: !!confirm, yesHash, ask, withdrawalsAtStart });
+                noteShopperStep(result, turn, { confirm: !!confirm, yes: { shown: yesShown }, ask, withdrawalsAtStart });
             else if (plan && 'body' in plan)
-                noteShopperStep(result, turn, { confirm: confirmSent, yesHash: typeof sent.confirm === 'string' ? sent.confirm : null, ask: sent.ask ?? '', withdrawalsAtStart });
+                noteShopperStep(result, turn, { confirm: confirmSent && !!plan.yes, yes: plan.yes ? { carried: plan.yes } : { shown: null }, ask: sent.ask ?? '', withdrawalsAtStart });
+            if (!t.event && turn) {
+                // Words that name something to buy and put a new item in the cart picked it too, as `the chicken pesto caprese from
+                // mendocino farms` carts the dish it names.
+                const added = result.pick?.in_cart === true || addsItem(result.cart, cartBefore);
+                const picking = !confirm && (picksShown || result.pick?.in_cart === true || (isNewRequest(ask) && added));
+                notePick(result, { picking, added, confirm: !!confirm, ask, heard, asked: askedBefore, pickWithdrawalsAtStart });
+            }
             // An answer that lists products replaces the names, even when every one is too short to keep.
             const shown = shownProducts(result.products);
             if (shown.length > 0)
@@ -1763,7 +2086,23 @@ export function buyTool(options) {
             const storesShown = shownStores(result.stores);
             if (storesShown.length > 0)
                 shownStoreNames = storesShown.map((store) => store.name);
+            // The cards the shopper can tap by name are the answer's and the ones this call's searches already sent: a restaurant turn that
+            // read the Burrito's options answered with the Burrito alone, beside the eight menu cards it sent first, and a tap on the
+            // Burrito Bowl then found no card of its name. A place ("the last one") reads the answer's own list, in its order, and never
+            // this one, so it picks the product shown in that place (Greptile on #11163).
+            // Each card once, by its id: a call that sends one search's products again (a refreshed catalog) would otherwise hold the
+            // same card twice, and a tap on it would read as two cards named alike (Greptile on #11163).
+            const tappable = [];
+            const held = new Set();
+            for (const product of [...shown, ...shownProducts(streamedCards)]) {
+                const id = pickId(product) ?? `name:${product.name}`;
+                if (held.has(id))
+                    continue;
+                held.add(id);
+                tappable.push(product);
+            }
             lastAnswerProducts = shown.map((product) => ({ productId: pickId(product), name: product.name }));
+            lastTappable = tappable.map((product) => ({ productId: pickId(product), name: product.name }));
             lastAnswerStores = storesShown.map((store) => ({ storeId: store.id, name: store.name }));
             t.results?.push(result);
             if (t.onResult) {
@@ -1780,6 +2119,9 @@ export function buyTool(options) {
             // A call that fails, Agentcard's error or a thrown handler, still settles the cards it left `checking`.
             await settleLeft?.().catch(() => { });
             ack?.cancel();
+            if (ack)
+                t.holds?.delete(ack.cancel);
+            t.dropWaitLine?.();
             running -= 1;
             lastEndedAt = Date.now();
         }
@@ -1867,6 +2209,9 @@ export function buyTool(options) {
         if (own.replyAsWritten !== undefined && typeof own.replyAsWritten !== 'boolean')
             throw new TypeError('Pass replyAsWritten to the turn as true or false, or leave it out.');
         const written = own.replyAsWritten ?? writtenByDefault;
+        if (own.textingStyle !== undefined && typeof own.textingStyle !== 'boolean')
+            throw new TypeError('Pass textingStyle to the turn as true or false, or leave it out.');
+        const texting = own.textingStyle ?? textingByDefault;
         const hearText = own.onText ?? o.onText;
         // Messages are spaced only for an app that hears each one as it goes out.
         const pauseOf = paceOf(own.pace);
@@ -1936,6 +2281,7 @@ export function buyTool(options) {
             // Agentcard's message takes its place in the turn's sequence, after the items before it, and goes to onText alone, so
             // an app that passes onItem too hears it once.
             onText: hearText ? (text, info) => feed.push({ kind: 'text', text }, () => hearText(text, info)) : undefined,
+            texting,
             onCart: own.onCart ?? o.onCart,
             tell: onItem || baseOnWorking ? (text) => feed.push({ kind: 'text', text }, () => (onItem ? onItem({ kind: 'text', text }) : baseOnWorking?.(text))) : undefined,
             links: [],
@@ -1955,7 +2301,29 @@ export function buyTool(options) {
             return Promise.resolve();
         };
         /** A message the app's model wrote: it goes to onItem, else onMessage, after every item before it, and the turn lists it. */
-        const text = (message, skip) => feed.push({ kind: 'text', text: message }, () => (onItem ? onItem({ kind: 'text', text: message }) : onMessage?.(message)), skip);
+        let modelWrote = false;
+        /** Whether the model's first words came before any call of the turn: set by its first delta or `say`, since a paragraph is cut later. */
+        let wordsBeforeCall = null;
+        const firstWords = (words) => {
+            if (wordsBeforeCall === null && /\S/.test(String(words ?? '')))
+                wordsBeforeCall = !state.called;
+        };
+        const text = (message, skip) => {
+            const first = !modelWrote;
+            modelWrote = true;
+            const show = (left) => feed.push({ kind: 'text', text: message }, () => (onItem ? onItem({ kind: 'text', text: message }) : onMessage?.(message)), left);
+            // The wait line already told the shopper the turn is on it: the model's own acknowledgement, its first message
+            // written before any call, such as `on it, looking for a dryer under $20`, would be a second line, so it stays in
+            // the model's own history and never reaches the shopper. A first message that asks, answers or says what a search
+            // came to still goes out, and so does every message after it. (2026-10-27: "dryer under 20" read `one moment`,
+            // then `on it, looking for a dryer under $20`.)
+            // A wait line the app failed to send reached nobody (`ackDelivered`), so the model's own line goes out in its
+            // place, in the feed's order: a failed send costs that line alone, never both.
+            if (first && state.waitLineOut && (wordsBeforeCall ?? !state.called) && readsAsAckLine(message)) {
+                return show(() => state.ackDelivered || (skip?.() ?? false));
+            }
+            return show(skip);
+        };
         let ack = null;
         const working = state.onWorking;
         const reacting = state.onReaction;
@@ -1985,7 +2353,9 @@ export function buyTool(options) {
                 // A search gets its 👀 the moment the turn opens, and no text: the reaction reads nothing back.
                 react(state, reacting);
             }
-            else if (text !== null && working) {
+            else if (text !== null && working && (writeAck || !streamCalls)) {
+                // A streamed search's line is Agentcard's to write (onAck), from the conversation, while it searches; the
+                // tool's template goes out at once only for an answer the app waits for whole, or in the app's own words.
                 ack = text;
                 state.acked = true;
                 let sent;
@@ -2004,9 +2374,65 @@ export function buyTool(options) {
         const results = state.results;
         // A pick or an answer goes straight only after a turn that ended on Agentcard's answer, and never while a call still runs.
         const answered = previousTurn !== null && (previousTurn.results?.length ?? 0) > 0;
-        const direct = directOn && !event && running === 0
-            ? directCall(String(shopperText ?? ''), { answered, nextAction: lastNextAction, asked: lastReply, products: lastAnswerProducts, stores: lastAnswerStores })
-            : null;
+        // A `nextStep` turn's call is the same whatever the model writes (`stepPlan` reads where the purchase stands), so it goes
+        // straight too: with `replyAsWritten`, a step whose answer is a link, such as the approval after a saved card, needs no model.
+        const direct = !directOn || running > 0
+            ? null
+            : event
+                ? { input: { ask: NEXT_STEP_ASK, confirm: false, new_order: false, product_id: null, store_id: null }, reason: 'next_step' }
+                : directCall(String(shopperText ?? ''), { answered, nextAction: lastNextAction, asked: lastReply, products: lastAnswerProducts, tappable: lastTappable, stores: lastAnswerStores });
+        // Agentcard writes the line for a search the turn sends straight. A turn the app's model runs gets the model's own line,
+        // or the wait line below.
+        state.agentcardAcks = (ask) => direct !== null && direct.reason === 'product_ask' && ask.trim() === direct.input.ask.trim();
+        /** Says the turn is on it, once, in fixed words that name nothing the shopper said, unless something went out first. */
+        const sayWaiting = (line) => {
+            if (state.acked || state.ended || feed.pushed() > 0 || !writesThroughTurn)
+                return;
+            state.acked = true;
+            state.waitLineOut = true;
+            state.ackOut = Promise.resolve()
+                .then(() => working(line))
+                .then(() => { state.ackDelivered = true; }, () => { });
+        };
+        // Only where the tool sees what the shopper read: the app writes the model's words through the turn.
+        if (!event && working && !reacting && direct !== null && direct.reason !== 'product_ask') {
+            // A pick, a confirm or an answer the turn sends straight that has shown nothing after ackDelayMs says it is on it. A
+            // product ask hears Agentcard's line (onAck).
+            const waitTimer = setTimeout(() => sayWaiting(slowStepLine(direct.reason === 'confirm' ? 'confirm' : state.picked ?? 'wait')), ackDelayMs);
+            waitTimer.unref?.();
+            // A call that ended, by its answer or by its error, leaves the turn to its reply: no wait line follows a failed pick.
+            state.dropWaitLine = () => clearTimeout(waitTimer);
+        }
+        else if (!event && working && !reacting && direct !== null) {
+            // A search the turn sends straight hears Agentcard's line (onAck). When that line never comes, as when Agentcard's
+            // model writes none or its line is dropped, and the shopper has seen nothing, no line and no card, by twice
+            // ackDelayMs, the wait line goes out then, the same rule as a model that has written nothing and called nothing.
+            // Once it went out, a line of Agentcard's that comes later is dropped (onAck reads `acked`), so the shopper reads one
+            // line. A call that already answered leaves the turn to its reply. (2026-10-27: "i want one called ardor" showed
+            // nothing for 9.1 s.)
+            const waitTimer = setTimeout(() => {
+                if (results.length === 0)
+                    sayWaiting(slowStepLine('wait'));
+            }, 2 * ackDelayMs);
+            waitTimer.unref?.();
+            // A call that ended, by its answer or by its error, leaves the turn to its reply: no wait line follows a failed search.
+            state.dropWaitLine = () => clearTimeout(waitTimer);
+        }
+        else if (!event && working && !reacting && direct === null) {
+            // The app's model runs this turn, and its first output decides: its own line first means no wait line; a call first
+            // gets the wait line from that call (holdAck); and a model that has written nothing and called nothing after twice
+            // ackDelayMs gets it then.
+            const model = { openedAt: Date.now(), spoke: false, callStarted: false, writesThrough: () => writesThroughTurn, shown: () => feed.pushed() > 0 };
+            state.modelTurn = model;
+            const waitTimer = setTimeout(() => {
+                if (!model.spoke && !model.callStarted)
+                    sayWaiting(slowStepLine(state.picked ?? 'wait'));
+            }, 2 * ackDelayMs);
+            waitTimer.unref?.();
+            // `turn.end()`, as when the app's model failed before it wrote or called anything, stops it: no `one moment` follows
+            // the app's own error. A call that ends stops it too, since a call started means the timer would send nothing.
+            state.dropWaitLine = () => clearTimeout(waitTimer);
+        }
         if (!event)
             previousTurn = state;
         // What Agentcard told the shopper that no history the model ran with holds yet.
@@ -2061,26 +2487,50 @@ export function buyTool(options) {
                 },
                 enumerable: false,
             },
+            end: {
+                value: () => {
+                    state.ended = true;
+                    state.dropWaitLine?.();
+                    // The acknowledgement a call still running holds, a 👀 or a line for a slow pick, confirm or answer, is cancelled too.
+                    for (const cancel of state.holds ?? [])
+                        cancel();
+                    state.holds?.clear();
+                },
+                enumerable: false,
+            },
             messages: { value: messagesFor, enumerable: false },
             ack: { value: ack, enumerable: false },
             reaction: { get: () => state.reaction, enumerable: false },
             links: { get: () => [...links], enumerable: false },
             results: { get: () => [...results], enumerable: false },
             direct: { value: direct, enumerable: false },
-            replyAsWritten: { get: () => (written && results.length > 0 ? replyAsWritten(results[results.length - 1]) : null), enumerable: false },
+            replyAsWritten: { get: () => (written && results.length > 0 ? replyAsWritten(results[results.length - 1], { textingStyle: texting }) : null), enumerable: false },
             items: { get: () => feed.items.map((item) => (item.kind === 'link' ? { kind: 'link', link: { ...item.link } } : { ...item })), enumerable: false },
             // Each message joins the feed the moment it is cut, so a link the tool hands over during a pause never overtakes text already written.
             // A step link held for this message goes out right after its last paragraph, once the stream ends.
             messageStream: {
                 value: () => {
                     writesThroughTurn = true;
-                    return feedStream(text, releaseForReply);
+                    const stream = feedStream(text, releaseForReply);
+                    return {
+                        push: (delta) => {
+                            firstWords(delta);
+                            // The model's first words: its own line is the turn's acknowledgement, so no wait line follows.
+                            if (state.modelTurn && /\S/.test(String(delta ?? '')))
+                                state.modelTurn.spoke = true;
+                            stream.push(delta);
+                        },
+                        end: () => stream.end(),
+                    };
                 },
                 enumerable: false,
             },
             say: {
                 value: (whole) => {
                     writesThroughTurn = true;
+                    firstWords(whole);
+                    if (state.modelTurn && /\S/.test(String(whole ?? '')))
+                        state.modelTurn.spoke = true;
                     const reply = feedReply(text);
                     for (const message of toMessages(whole))
                         reply.add(message);