@wix/himalaya-cli 0.971.0 → 0.972.0

package/templates/nonprofit-cause-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/owner-lite/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/podcast-creator-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/portfolio-creative-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/restaurant-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,