@wix/himalaya-cli 0.971.0 → 0.972.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/genie-chat/src/index.d.ts

@@ -34,11 +34,23 @@ export declare function isGenieChatError(e: unknown): e is GenieChatError;
 declare function wixCall<T>(method: string, path: string, body?: unknown): Promise<T>;
 export type MessageRole = "UNKNOWN" | "USER" | "ASSISTANT";
 export type CommunicationMode = "UNKNOWN" | "POLLING" | "REAL_TIME";
+/** Where the service is with one message. `STATUS_PENDING` on an ASSISTANT row
+ *  means the agent is still writing it: whatever `content` holds so far is a
+ *  draft, not the answer. Open-ended because the wire may grow values.
+ *
+ *  Taken from the service's published message entity (the generated
+ *  `genie-chat-service-v1` client in `wix-private/aria-native-apps`), where the
+ *  native Aria app ends a turn ONLY on a polled `STATUS_COMPLETED`, and resumes a
+ *  conversation whose newest assistant row is still pending. Not observed on
+ *  this repo's own captures, which is why it is optional and every consumer
+ *  must treat an absent status as "settled". */
+export type MessageStatus = "STATUS_UNSPECIFIED" | "STATUS_PENDING" | "STATUS_COMPLETED" | (string & {});
 export interface ConversationMessage {
     id?: string;
     content?: string;
     role?: MessageRole;
     createdDate?: string;
+    status?: MessageStatus;
 }
 /** Which assistant the conversation talks to. The real dashboard sends a
  *  `unifiedAssistantReference`; helper `ariaAssistantConfig()` builds it. */

package/dist/cli.mjs

@@ -5290,7 +5290,6 @@ function resolveTranslation(value, catalog, sourceCatalog) {
 var BINDING_SIGILS, BINDING_SIGIL_RE, TRANSLATION_PREFIX, TRANSLATION_KEY_RE;
 var init_bindings = __esm({
   "../../core/ts/src/bindings.ts"() {
-    "use strict";
     BINDING_SIGILS = ["service", "flag", "item", "t"];
     BINDING_SIGIL_RE = new RegExp(
       `^\\$(?:${BINDING_SIGILS.filter((s) => s !== "t").join("|")})\\b|^\\$t:`

package/guides/sdk-reference.json

@@ -16696,11 +16696,17 @@
         "jsdoc": "",
         "decl": "export type CommunicationMode = \"UNKNOWN\" | \"POLLING\" | \"REAL_TIME\";"
       },
+      {
+        "name": "MessageStatus",
+        "kind": "type",
+        "jsdoc": "/** Where the service is with one message. `STATUS_PENDING` on an ASSISTANT row\n *  means the agent is still writing it: whatever `content` holds so far is a\n *  draft, not the answer. Open-ended because the wire may grow values.\n *\n *  Taken from the service's published message entity (the generated\n *  `genie-chat-service-v1` client in `wix-private/aria-native-apps`), where the\n *  native Aria app ends a turn ONLY on a polled `STATUS_COMPLETED`, and resumes a\n *  conversation whose newest assistant row is still pending. Not observed on\n *  this repo's own captures, which is why it is optional and every consumer\n *  must treat an absent status as \"settled\". */",
+        "decl": "export type MessageStatus = \"STATUS_UNSPECIFIED\" | \"STATUS_PENDING\" | \"STATUS_COMPLETED\" | (string & {});"
+      },
       {
         "name": "ConversationMessage",
         "kind": "interface",
         "jsdoc": "",
-        "decl": "export interface ConversationMessage {\n  id?: string;\n  content?: string;\n  role?: MessageRole;\n  createdDate?: string;\n}"
+        "decl": "export interface ConversationMessage {\n  id?: string;\n  content?: string;\n  role?: MessageRole;\n  createdDate?: string;\n  status?: MessageStatus;\n}"
       },
       {
         "name": "AssistantConfig",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/himalaya-cli",
-  "version": "0.971.0",
+  "version": "0.972.0",
   "type": "module",
   "description": "himi — the Himalaya authoring CLI. Build a Tier-5 content package on your own machine, push it to the production serve as a draft, preview it on web + Himi Player, and read worker logs back — the remote dev loop. Wraps @himalaya/serve-cli for transport.",
   "keywords": [
@@ -64,5 +64,5 @@
       "artifactId": "himalaya-cli"
     }
   },
-  "falconPackageHash": "dc35d80213a50f83892eb491d6ec9afd8cf09def367013281612b0aa"
+  "falconPackageHash": "9d8d2a86205140b8694ab07b45d09c35b40bfb375a3baf1f123ffacf"
 }

package/templates/beauty-salon-owner/tier5-src/_shared/aria-chat.ts

@@ -585,7 +585,10 @@ export function toBubbles(msgs: ConversationMessage[], assistantName: string, yo
       // way, and an aborted turn consists of nothing else. Then envelopes, then
       // the markdown stripper — each stage handing on only what a reader should
       // actually see.
-      const prose = role === "USER" ? raw : proseOfParts(scanEnvelopes(stripHidden(raw), 0, true).parts);
+      // A row the service is still writing is scanned as STREAMING: an
+      // envelope whose `>>` has not arrived yet is held back rather than
+      // painted as raw JSON until the row finishes.
+      const prose = role === "USER" ? raw : proseOfParts(scanEnvelopes(stripHidden(raw), 0, !stillWriting(m)).parts);
       return {
         id: m.id || `m${i}`,
         role,
@@ -689,6 +692,29 @@ function answerText(m: ConversationMessage): string {
   return stripHidden(messageText(m)).trim();
 }
 
+/** Is the service still WRITING this assistant row?
+ *
+ *  The chat-service stamps every message with a status, and an ASSISTANT row
+ *  that is `STATUS_PENDING` holds a draft: the agent has started the reply and
+ *  not finished it. Whatever text it carries is worth PAINTING — it is the only
+ *  view of a reply in progress a worker has, since the words themselves stream
+ *  over a socket no host exposes (see the genie-chat client's header) — but it
+ *  is not the answer, and ending the turn on it is the bug this exists for: the
+ *  typing line clears, Stop disappears while the agent is still writing, and the
+ *  ladder drops to its idle rung, so the rest of the reply sits unseen for a
+ *  whole idle interval. The native Aria app ends a turn only on
+ *  `STATUS_COMPLETED`, for the same reason.
+ *
+ *  Only an explicit PENDING counts. An absent or unrecognised status is
+ *  "settled": no capture in this repo has ever shown the field, and a gate that
+ *  demanded `STATUS_COMPLETED` would hang every turn on a service that simply
+ *  does not send it. Callers apply it to ASSISTANT rows only: a USER row is
+ *  counted to retire the optimistic bubble, and holding one back would paint
+ *  the owner's words twice. */
+function stillWriting(m: ConversationMessage): boolean {
+  return m.status === "STATUS_PENDING";
+}
+
 export function repliedTo(msgs: ConversationMessage[], turnId: string): boolean | null {
   if (!turnId) return null;
   const at = msgs.findIndex((m) => m.id === turnId);
@@ -701,7 +727,9 @@ export function repliedTo(msgs: ConversationMessage[], turnId: string): boolean
   for (let i = at + 1; i < msgs.length; i++) {
     const m = msgs[i];
     if ((m.role || "ASSISTANT") !== "ASSISTANT") continue;
-    if (answerText(m)) return true;
+    // A row still being written is not the answer yet — keep looking, since
+    // the finished answer can land in a later row of the same turn.
+    if (answerText(m) && !stillWriting(m)) return true;
   }
   return false;
 }
@@ -736,6 +764,26 @@ export function countTurns(msgs: ConversationMessage[], role: string): number {
   return n;
 }
 
+/** How many FINISHED assistant answers the transcript holds — `countTurns`
+ *  minus the rows the service is still writing (`stillWriting`).
+ *
+ *  The counted path compares THIS against a mark taken with `countTurns`, and
+ *  the asymmetry is the point. The mark includes drafts, so a follow-up sent
+ *  while an earlier reply is still being written is marked AFTER that reply;
+ *  the earlier reply finishing then leaves this count equal to the mark rather
+ *  than past it, and cannot end the new turn. Were the mark taken without
+ *  drafts too, that finish would read as the new turn's answer. And a draft
+ *  of the turn's OWN answer is not counted here, so it does not end the turn
+ *  either — the same rule `repliedTo` applies on the exact path. */
+export function countSettledAnswers(msgs: ConversationMessage[]): number {
+  let n = 0;
+  for (const m of msgs) {
+    if ((m.role || "ASSISTANT") !== "ASSISTANT") continue;
+    if (answerText(m) && !stillWriting(m)) n++;
+  }
+  return n;
+}
+
 /** Has the turn stored under `userMessageId` already been answered?
  *
  *  Per-TURN, and that is the entire point. A COUNT of assistant replies says
@@ -785,6 +833,12 @@ export function turnAnswered(msgs: ConversationMessage[], userMessageId: string)
     // exactly these two, and the two scanners read the same transcript: if they
     // disagree, one of them ends the turn while the other leaves the ladder
     // running at the fast cadence.
+    //
+    // They DO part on one case, deliberately: a row the service is still
+    // writing (`stillWriting`). That does not end a turn, but it IS proof the
+    // trigger landed — the agent is answering — so re-triggering the stored id
+    // here would have it answer the same turn twice. The ladder never reads
+    // this scanner, so the split cannot pin it fast.
     if (role === "ASSISTANT" && answerText(m)) return true;
   }
   return false;
@@ -1155,7 +1209,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     // both; the widget path did neither.
     widget: carrySelection(
       activeWidgetOf(
-        msgs.map((m) => ({ role: m.role, content: stripHidden(messageText(m)) })),
+        // A draft offers no controls: the agent has not finished asking, and
+        // an answer tapped now would start a second turn on top of this one.
+        // An empty newest row is NO_WIDGET — the placeholder rule.
+        msgs.map((m) => ({ role: m.role, content: stillWriting(m) ? "" : stripHidden(messageText(m)) })),
         disclosedLabel,
         o.subtree,
         (url) => isWixMediaHost(hostOf(url)),
@@ -1220,7 +1277,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       // widget-only reply is, even though it leaves no bubble to inspect. Asking
       // the last BUBBLE stalled this loop on exactly that reply, the same way it
       // stalled `tick`.
-      if (repliedTo(raw, s._turnId) ?? countTurns(raw, "ASSISTANT") > s._replyAfter) {
+      if (repliedTo(raw, s._turnId) ?? countSettledAnswers(raw) > s._replyAfter) {
         return { ...s, status: "ready", _convId: convId, messages: bubbles, prompts: [], input: "", statusText: "", error: "", _pending: "", ...observed(raw, s.widget), ok: false };
       }
     }
@@ -1804,7 +1861,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         // Counted over RAW messages, so a widget-only answer still ends the turn
         // instead of pinning the ladder to its fast rung forever (`countTurns`).
         // Exact when the service named the turn, counted when it did not.
-        const replied = repliedTo(raw, s._turnId) ?? countTurns(raw, "ASSISTANT") > s._replyAfter;
+        const replied = repliedTo(raw, s._turnId) ?? countSettledAnswers(raw) > s._replyAfter;
         const next: AriaChatState = {
           ...s,
           status: replied ? "ready" : s.status,

package/templates/community-club-owner/tier5-src/_shared/aria-chat.ts

@@ -585,7 +585,10 @@ export function toBubbles(msgs: ConversationMessage[], assistantName: string, yo
       // way, and an aborted turn consists of nothing else. Then envelopes, then
       // the markdown stripper — each stage handing on only what a reader should
       // actually see.
-      const prose = role === "USER" ? raw : proseOfParts(scanEnvelopes(stripHidden(raw), 0, true).parts);
+      // A row the service is still writing is scanned as STREAMING: an
+      // envelope whose `>>` has not arrived yet is held back rather than
+      // painted as raw JSON until the row finishes.
+      const prose = role === "USER" ? raw : proseOfParts(scanEnvelopes(stripHidden(raw), 0, !stillWriting(m)).parts);
       return {
         id: m.id || `m${i}`,
         role,
@@ -689,6 +692,29 @@ function answerText(m: ConversationMessage): string {
   return stripHidden(messageText(m)).trim();
 }
 
+/** Is the service still WRITING this assistant row?
+ *
+ *  The chat-service stamps every message with a status, and an ASSISTANT row
+ *  that is `STATUS_PENDING` holds a draft: the agent has started the reply and
+ *  not finished it. Whatever text it carries is worth PAINTING — it is the only
+ *  view of a reply in progress a worker has, since the words themselves stream
+ *  over a socket no host exposes (see the genie-chat client's header) — but it
+ *  is not the answer, and ending the turn on it is the bug this exists for: the
+ *  typing line clears, Stop disappears while the agent is still writing, and the
+ *  ladder drops to its idle rung, so the rest of the reply sits unseen for a
+ *  whole idle interval. The native Aria app ends a turn only on
+ *  `STATUS_COMPLETED`, for the same reason.
+ *
+ *  Only an explicit PENDING counts. An absent or unrecognised status is
+ *  "settled": no capture in this repo has ever shown the field, and a gate that
+ *  demanded `STATUS_COMPLETED` would hang every turn on a service that simply
+ *  does not send it. Callers apply it to ASSISTANT rows only: a USER row is
+ *  counted to retire the optimistic bubble, and holding one back would paint
+ *  the owner's words twice. */
+function stillWriting(m: ConversationMessage): boolean {
+  return m.status === "STATUS_PENDING";
+}
+
 export function repliedTo(msgs: ConversationMessage[], turnId: string): boolean | null {
   if (!turnId) return null;
   const at = msgs.findIndex((m) => m.id === turnId);
@@ -701,7 +727,9 @@ export function repliedTo(msgs: ConversationMessage[], turnId: string): boolean
   for (let i = at + 1; i < msgs.length; i++) {
     const m = msgs[i];
     if ((m.role || "ASSISTANT") !== "ASSISTANT") continue;
-    if (answerText(m)) return true;
+    // A row still being written is not the answer yet — keep looking, since
+    // the finished answer can land in a later row of the same turn.
+    if (answerText(m) && !stillWriting(m)) return true;
   }
   return false;
 }
@@ -736,6 +764,26 @@ export function countTurns(msgs: ConversationMessage[], role: string): number {
   return n;
 }
 
+/** How many FINISHED assistant answers the transcript holds — `countTurns`
+ *  minus the rows the service is still writing (`stillWriting`).
+ *
+ *  The counted path compares THIS against a mark taken with `countTurns`, and
+ *  the asymmetry is the point. The mark includes drafts, so a follow-up sent
+ *  while an earlier reply is still being written is marked AFTER that reply;
+ *  the earlier reply finishing then leaves this count equal to the mark rather
+ *  than past it, and cannot end the new turn. Were the mark taken without
+ *  drafts too, that finish would read as the new turn's answer. And a draft
+ *  of the turn's OWN answer is not counted here, so it does not end the turn
+ *  either — the same rule `repliedTo` applies on the exact path. */
+export function countSettledAnswers(msgs: ConversationMessage[]): number {
+  let n = 0;
+  for (const m of msgs) {
+    if ((m.role || "ASSISTANT") !== "ASSISTANT") continue;
+    if (answerText(m) && !stillWriting(m)) n++;
+  }
+  return n;
+}
+
 /** Has the turn stored under `userMessageId` already been answered?
  *
  *  Per-TURN, and that is the entire point. A COUNT of assistant replies says
@@ -785,6 +833,12 @@ export function turnAnswered(msgs: ConversationMessage[], userMessageId: string)
     // exactly these two, and the two scanners read the same transcript: if they
     // disagree, one of them ends the turn while the other leaves the ladder
     // running at the fast cadence.
+    //
+    // They DO part on one case, deliberately: a row the service is still
+    // writing (`stillWriting`). That does not end a turn, but it IS proof the
+    // trigger landed — the agent is answering — so re-triggering the stored id
+    // here would have it answer the same turn twice. The ladder never reads
+    // this scanner, so the split cannot pin it fast.
     if (role === "ASSISTANT" && answerText(m)) return true;
   }
   return false;
@@ -1155,7 +1209,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     // both; the widget path did neither.
     widget: carrySelection(
       activeWidgetOf(
-        msgs.map((m) => ({ role: m.role, content: stripHidden(messageText(m)) })),
+        // A draft offers no controls: the agent has not finished asking, and
+        // an answer tapped now would start a second turn on top of this one.
+        // An empty newest row is NO_WIDGET — the placeholder rule.
+        msgs.map((m) => ({ role: m.role, content: stillWriting(m) ? "" : stripHidden(messageText(m)) })),
         disclosedLabel,
         o.subtree,
         (url) => isWixMediaHost(hostOf(url)),
@@ -1220,7 +1277,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       // widget-only reply is, even though it leaves no bubble to inspect. Asking
       // the last BUBBLE stalled this loop on exactly that reply, the same way it
       // stalled `tick`.
-      if (repliedTo(raw, s._turnId) ?? countTurns(raw, "ASSISTANT") > s._replyAfter) {
+      if (repliedTo(raw, s._turnId) ?? countSettledAnswers(raw) > s._replyAfter) {
         return { ...s, status: "ready", _convId: convId, messages: bubbles, prompts: [], input: "", statusText: "", error: "", _pending: "", ...observed(raw, s.widget), ok: false };
       }
     }
@@ -1804,7 +1861,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         // Counted over RAW messages, so a widget-only answer still ends the turn
         // instead of pinning the ladder to its fast rung forever (`countTurns`).
         // Exact when the service named the turn, counted when it did not.
-        const replied = repliedTo(raw, s._turnId) ?? countTurns(raw, "ASSISTANT") > s._replyAfter;
+        const replied = repliedTo(raw, s._turnId) ?? countSettledAnswers(raw) > s._replyAfter;
         const next: AriaChatState = {
           ...s,
           status: replied ? "ready" : s.status,

package/templates/events-meetups-owner/tier5-src/_shared/aria-chat.ts

@@ -585,7 +585,10 @@ export function toBubbles(msgs: ConversationMessage[], assistantName: string, yo
       // way, and an aborted turn consists of nothing else. Then envelopes, then
       // the markdown stripper — each stage handing on only what a reader should
       // actually see.
-      const prose = role === "USER" ? raw : proseOfParts(scanEnvelopes(stripHidden(raw), 0, true).parts);
+      // A row the service is still writing is scanned as STREAMING: an
+      // envelope whose `>>` has not arrived yet is held back rather than
+      // painted as raw JSON until the row finishes.
+      const prose = role === "USER" ? raw : proseOfParts(scanEnvelopes(stripHidden(raw), 0, !stillWriting(m)).parts);
       return {
         id: m.id || `m${i}`,
         role,
@@ -689,6 +692,29 @@ function answerText(m: ConversationMessage): string {
   return stripHidden(messageText(m)).trim();
 }
 
+/** Is the service still WRITING this assistant row?
+ *
+ *  The chat-service stamps every message with a status, and an ASSISTANT row
+ *  that is `STATUS_PENDING` holds a draft: the agent has started the reply and
+ *  not finished it. Whatever text it carries is worth PAINTING — it is the only
+ *  view of a reply in progress a worker has, since the words themselves stream
+ *  over a socket no host exposes (see the genie-chat client's header) — but it
+ *  is not the answer, and ending the turn on it is the bug this exists for: the
+ *  typing line clears, Stop disappears while the agent is still writing, and the
+ *  ladder drops to its idle rung, so the rest of the reply sits unseen for a
+ *  whole idle interval. The native Aria app ends a turn only on
+ *  `STATUS_COMPLETED`, for the same reason.
+ *
+ *  Only an explicit PENDING counts. An absent or unrecognised status is
+ *  "settled": no capture in this repo has ever shown the field, and a gate that
+ *  demanded `STATUS_COMPLETED` would hang every turn on a service that simply
+ *  does not send it. Callers apply it to ASSISTANT rows only: a USER row is
+ *  counted to retire the optimistic bubble, and holding one back would paint
+ *  the owner's words twice. */
+function stillWriting(m: ConversationMessage): boolean {
+  return m.status === "STATUS_PENDING";
+}
+
 export function repliedTo(msgs: ConversationMessage[], turnId: string): boolean | null {
   if (!turnId) return null;
   const at = msgs.findIndex((m) => m.id === turnId);
@@ -701,7 +727,9 @@ export function repliedTo(msgs: ConversationMessage[], turnId: string): boolean
   for (let i = at + 1; i < msgs.length; i++) {
     const m = msgs[i];
     if ((m.role || "ASSISTANT") !== "ASSISTANT") continue;
-    if (answerText(m)) return true;
+    // A row still being written is not the answer yet — keep looking, since
+    // the finished answer can land in a later row of the same turn.
+    if (answerText(m) && !stillWriting(m)) return true;
   }
   return false;
 }
@@ -736,6 +764,26 @@ export function countTurns(msgs: ConversationMessage[], role: string): number {
   return n;
 }
 
+/** How many FINISHED assistant answers the transcript holds — `countTurns`
+ *  minus the rows the service is still writing (`stillWriting`).
+ *
+ *  The counted path compares THIS against a mark taken with `countTurns`, and
+ *  the asymmetry is the point. The mark includes drafts, so a follow-up sent
+ *  while an earlier reply is still being written is marked AFTER that reply;
+ *  the earlier reply finishing then leaves this count equal to the mark rather
+ *  than past it, and cannot end the new turn. Were the mark taken without
+ *  drafts too, that finish would read as the new turn's answer. And a draft
+ *  of the turn's OWN answer is not counted here, so it does not end the turn
+ *  either — the same rule `repliedTo` applies on the exact path. */
+export function countSettledAnswers(msgs: ConversationMessage[]): number {
+  let n = 0;
+  for (const m of msgs) {
+    if ((m.role || "ASSISTANT") !== "ASSISTANT") continue;
+    if (answerText(m) && !stillWriting(m)) n++;
+  }
+  return n;
+}
+
 /** Has the turn stored under `userMessageId` already been answered?
  *
  *  Per-TURN, and that is the entire point. A COUNT of assistant replies says
@@ -785,6 +833,12 @@ export function turnAnswered(msgs: ConversationMessage[], userMessageId: string)
     // exactly these two, and the two scanners read the same transcript: if they
     // disagree, one of them ends the turn while the other leaves the ladder
     // running at the fast cadence.
+    //
+    // They DO part on one case, deliberately: a row the service is still
+    // writing (`stillWriting`). That does not end a turn, but it IS proof the
+    // trigger landed — the agent is answering — so re-triggering the stored id
+    // here would have it answer the same turn twice. The ladder never reads
+    // this scanner, so the split cannot pin it fast.
     if (role === "ASSISTANT" && answerText(m)) return true;
   }
   return false;
@@ -1155,7 +1209,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     // both; the widget path did neither.
     widget: carrySelection(
       activeWidgetOf(
-        msgs.map((m) => ({ role: m.role, content: stripHidden(messageText(m)) })),
+        // A draft offers no controls: the agent has not finished asking, and
+        // an answer tapped now would start a second turn on top of this one.
+        // An empty newest row is NO_WIDGET — the placeholder rule.
+        msgs.map((m) => ({ role: m.role, content: stillWriting(m) ? "" : stripHidden(messageText(m)) })),
         disclosedLabel,
         o.subtree,
         (url) => isWixMediaHost(hostOf(url)),
@@ -1220,7 +1277,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       // widget-only reply is, even though it leaves no bubble to inspect. Asking
       // the last BUBBLE stalled this loop on exactly that reply, the same way it
       // stalled `tick`.
-      if (repliedTo(raw, s._turnId) ?? countTurns(raw, "ASSISTANT") > s._replyAfter) {
+      if (repliedTo(raw, s._turnId) ?? countSettledAnswers(raw) > s._replyAfter) {
         return { ...s, status: "ready", _convId: convId, messages: bubbles, prompts: [], input: "", statusText: "", error: "", _pending: "", ...observed(raw, s.widget), ok: false };
       }
     }
@@ -1804,7 +1861,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         // Counted over RAW messages, so a widget-only answer still ends the turn
         // instead of pinning the ladder to its fast rung forever (`countTurns`).
         // Exact when the service named the turn, counted when it did not.
-        const replied = repliedTo(raw, s._turnId) ?? countTurns(raw, "ASSISTANT") > s._replyAfter;
+        const replied = repliedTo(raw, s._turnId) ?? countSettledAnswers(raw) > s._replyAfter;
         const next: AriaChatState = {
           ...s,
           status: replied ? "ready" : s.status,

package/templates/gym-fitness-owner/tier5-src/_shared/aria-chat.ts

@@ -585,7 +585,10 @@ export function toBubbles(msgs: ConversationMessage[], assistantName: string, yo
       // way, and an aborted turn consists of nothing else. Then envelopes, then
       // the markdown stripper — each stage handing on only what a reader should
       // actually see.
-      const prose = role === "USER" ? raw : proseOfParts(scanEnvelopes(stripHidden(raw), 0, true).parts);
+      // A row the service is still writing is scanned as STREAMING: an
+      // envelope whose `>>` has not arrived yet is held back rather than
+      // painted as raw JSON until the row finishes.
+      const prose = role === "USER" ? raw : proseOfParts(scanEnvelopes(stripHidden(raw), 0, !stillWriting(m)).parts);
       return {
         id: m.id || `m${i}`,
         role,
@@ -689,6 +692,29 @@ function answerText(m: ConversationMessage): string {
   return stripHidden(messageText(m)).trim();
 }
 
+/** Is the service still WRITING this assistant row?
+ *
+ *  The chat-service stamps every message with a status, and an ASSISTANT row
+ *  that is `STATUS_PENDING` holds a draft: the agent has started the reply and
+ *  not finished it. Whatever text it carries is worth PAINTING — it is the only
+ *  view of a reply in progress a worker has, since the words themselves stream
+ *  over a socket no host exposes (see the genie-chat client's header) — but it
+ *  is not the answer, and ending the turn on it is the bug this exists for: the
+ *  typing line clears, Stop disappears while the agent is still writing, and the
+ *  ladder drops to its idle rung, so the rest of the reply sits unseen for a
+ *  whole idle interval. The native Aria app ends a turn only on
+ *  `STATUS_COMPLETED`, for the same reason.
+ *
+ *  Only an explicit PENDING counts. An absent or unrecognised status is
+ *  "settled": no capture in this repo has ever shown the field, and a gate that
+ *  demanded `STATUS_COMPLETED` would hang every turn on a service that simply
+ *  does not send it. Callers apply it to ASSISTANT rows only: a USER row is
+ *  counted to retire the optimistic bubble, and holding one back would paint
+ *  the owner's words twice. */
+function stillWriting(m: ConversationMessage): boolean {
+  return m.status === "STATUS_PENDING";
+}
+
 export function repliedTo(msgs: ConversationMessage[], turnId: string): boolean | null {
   if (!turnId) return null;
   const at = msgs.findIndex((m) => m.id === turnId);
@@ -701,7 +727,9 @@ export function repliedTo(msgs: ConversationMessage[], turnId: string): boolean
   for (let i = at + 1; i < msgs.length; i++) {
     const m = msgs[i];
     if ((m.role || "ASSISTANT") !== "ASSISTANT") continue;
-    if (answerText(m)) return true;
+    // A row still being written is not the answer yet — keep looking, since
+    // the finished answer can land in a later row of the same turn.
+    if (answerText(m) && !stillWriting(m)) return true;
   }
   return false;
 }
@@ -736,6 +764,26 @@ export function countTurns(msgs: ConversationMessage[], role: string): number {
   return n;
 }
 
+/** How many FINISHED assistant answers the transcript holds — `countTurns`
+ *  minus the rows the service is still writing (`stillWriting`).
+ *
+ *  The counted path compares THIS against a mark taken with `countTurns`, and
+ *  the asymmetry is the point. The mark includes drafts, so a follow-up sent
+ *  while an earlier reply is still being written is marked AFTER that reply;
+ *  the earlier reply finishing then leaves this count equal to the mark rather
+ *  than past it, and cannot end the new turn. Were the mark taken without
+ *  drafts too, that finish would read as the new turn's answer. And a draft
+ *  of the turn's OWN answer is not counted here, so it does not end the turn
+ *  either — the same rule `repliedTo` applies on the exact path. */
+export function countSettledAnswers(msgs: ConversationMessage[]): number {
+  let n = 0;
+  for (const m of msgs) {
+    if ((m.role || "ASSISTANT") !== "ASSISTANT") continue;
+    if (answerText(m) && !stillWriting(m)) n++;
+  }
+  return n;
+}
+
 /** Has the turn stored under `userMessageId` already been answered?
  *
  *  Per-TURN, and that is the entire point. A COUNT of assistant replies says
@@ -785,6 +833,12 @@ export function turnAnswered(msgs: ConversationMessage[], userMessageId: string)
     // exactly these two, and the two scanners read the same transcript: if they
     // disagree, one of them ends the turn while the other leaves the ladder
     // running at the fast cadence.
+    //
+    // They DO part on one case, deliberately: a row the service is still
+    // writing (`stillWriting`). That does not end a turn, but it IS proof the
+    // trigger landed — the agent is answering — so re-triggering the stored id
+    // here would have it answer the same turn twice. The ladder never reads
+    // this scanner, so the split cannot pin it fast.
     if (role === "ASSISTANT" && answerText(m)) return true;
   }
   return false;
@@ -1155,7 +1209,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     // both; the widget path did neither.
     widget: carrySelection(
       activeWidgetOf(
-        msgs.map((m) => ({ role: m.role, content: stripHidden(messageText(m)) })),
+        // A draft offers no controls: the agent has not finished asking, and
+        // an answer tapped now would start a second turn on top of this one.
+        // An empty newest row is NO_WIDGET — the placeholder rule.
+        msgs.map((m) => ({ role: m.role, content: stillWriting(m) ? "" : stripHidden(messageText(m)) })),
         disclosedLabel,
         o.subtree,
         (url) => isWixMediaHost(hostOf(url)),
@@ -1220,7 +1277,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       // widget-only reply is, even though it leaves no bubble to inspect. Asking
       // the last BUBBLE stalled this loop on exactly that reply, the same way it
       // stalled `tick`.
-      if (repliedTo(raw, s._turnId) ?? countTurns(raw, "ASSISTANT") > s._replyAfter) {
+      if (repliedTo(raw, s._turnId) ?? countSettledAnswers(raw) > s._replyAfter) {
         return { ...s, status: "ready", _convId: convId, messages: bubbles, prompts: [], input: "", statusText: "", error: "", _pending: "", ...observed(raw, s.widget), ok: false };
       }
     }
@@ -1804,7 +1861,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         // Counted over RAW messages, so a widget-only answer still ends the turn
         // instead of pinning the ladder to its fast rung forever (`countTurns`).
         // Exact when the service named the turn, counted when it did not.
-        const replied = repliedTo(raw, s._turnId) ?? countTurns(raw, "ASSISTANT") > s._replyAfter;
+        const replied = repliedTo(raw, s._turnId) ?? countSettledAnswers(raw) > s._replyAfter;
         const next: AriaChatState = {
           ...s,
           status: replied ? "ready" : s.status,