@wix/himalaya-cli 0.1519.0 → 0.1521.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/himalaya-cli",
-  "version": "0.1519.0",
+  "version": "0.1521.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": [
@@ -71,5 +71,5 @@
       "artifactId": "himalaya-cli"
     }
   },
-  "falconPackageHash": "0e0482fc29a9f19e127d9936df6af318a0cae39cd83c8c6fa75fdaa5"
+  "falconPackageHash": "11acc374606758fb4e5bab3b978baa2f4a7cbd34e9fface50245e42d"
 }

package/templates/branded-lite/tier5-src/_shared/business-chat-history.ts

@@ -0,0 +1,48 @@
+/** Smart Chat resolves its conversation from the caller's Wix identity. Its history must not
+ * be replaced by a different conversation returned by the Members chat room list. */
+type Raw = Record<string, unknown>;
+const object = (value: unknown): Raw => value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Raw : {};
+const text = (value: unknown): string => typeof value === 'string' ? value : '';
+
+// Positive lists: navigation, cart events, owner notifications and training messages are not a transcript.
+const VISITOR_TYPES = new Set(['QUESTION', 'VISITOR_MESSAGE', 'VISITOR_OPTION_SELECTED', 'FAQ_QUESTION']);
+const ASSISTANT_TYPES = new Set(['ANSWER', 'INTRO', 'LEGAL', 'OFFLINE', 'OUT_OF_QUOTA', 'FAQ_ANSWER']);
+const STAFF_TYPES = new Set(['USER_ANSWER', 'WIX_USER_CARD', 'WIX_USER_MINIMAL_BODY', 'WIX_USER_MEDIA', 'WIX_USER_FORM']);
+
+/** Adapt the current identity-scoped Smart Chat conversation to the existing presentation pipeline.
+ * `inboxId` identifies an Inbox MESSAGE, never a room. Where that exact message exists in the
+ * member page, keep its rich content; otherwise use the persisted Smart Chat body. No text/id guesses. */
+export function smartChatHistory(aiMessages: unknown[], memberPage: unknown[], participantId: string): { conversationId: string; messages: Raw[] } | null {
+  const dated = aiMessages.map(object)
+    .filter(message => text(message.id) && text(message.conversationId) && Number.isFinite(Date.parse(text(message.createdDate))))
+    .sort((a, b) => Date.parse(text(a.createdDate)) - Date.parse(text(b.createdDate)));
+  const conversationId = text(dated.at(-1)?.conversationId);
+  if (!conversationId) return null;
+  const memberRows = new Map(memberPage.map(object).map(row => [text(row.id), row]));
+  const messages: Raw[] = [];
+  for (const message of dated) {
+    if (message.conversationId !== conversationId) continue;
+    const sender = text(message.sender);
+    const kind = text(message.messageType);
+    const mine = sender === 'SITE_VISITOR' && VISITOR_TYPES.has(kind);
+    if (!mine && !(sender === 'ASSISTANT' && ASSISTANT_TYPES.has(kind)) && !(sender === 'USER' && STAFF_TYPES.has(kind))) continue;
+    const body = object(message.body);
+    const bodyText = [text(body.mainText), text(body.footerText)].filter(Boolean).join('\n');
+    const rich = memberRows.get(text(message.inboxId));
+    // A quick-reply-only metadata answer is not an empty bubble (the options are shown by the composer).
+    if (!bodyText && !rich) continue;
+    messages.push({
+      ...rich,
+      id: `smart-chat:${message.id}`,
+      // Member-room sequence numbers cannot order a different Smart Chat conversation.
+      sequence: undefined,
+      createdDate: message.createdDate,
+      sender: { userId: mine ? participantId : `smart-chat:${sender}` },
+      aiSiteChatSender: sender,
+      messageType: rich?.messageType ?? 'message',
+      data: rich && (Array.isArray(rich.data) && rich.data.length || rich.templateData)
+        ? rich.data : [{ mimeType: 'text/plain', data: { text: bodyText } }],
+    });
+  }
+  return messages.length ? { conversationId, messages } : null;
+}

package/templates/branded-lite/tier5-src/_shared/business-chat-model.ts

@@ -6,7 +6,7 @@ import { mergeMessages, normalizeMessages, type MessageRow } from './business-ch
  *  new one is recognised by its text, among the messages after `afterId` (the newest stored message on screen when it
  *  was sent), or among all of them when the room was loaded and empty (`fromStart`); `priorCount` is how many earlier
  *  sends with the same text were still waiting for their stored copy. */
-export interface BusinessChatIntent { id:string; text:string; roomId:string; principal:string; createdDate:string; delivery:'sending'|'sent'|'unconfirmed'; senderName?:string; afterId?:string; fromStart?:boolean; priorCount?:number }
+export interface BusinessChatIntent { id:string; text:string; roomId:string; principal:string; createdDate:string; delivery:'sending'|'sent'|'unconfirmed'; senderName?:string; storedId?:string; afterId?:string; fromStart?:boolean; priorCount?:number }
 
 export function newBusinessChatIntent(text:string,roomId:string,principal:string,random=Math.random):BusinessChatIntent{
  return {id:'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g,c=>{const r=Math.floor(random()*16);return(c==='x'?r:(r&3)|8).toString(16);}),text,roomId,principal,createdDate:new Date().toISOString(),delivery:'sending'};
@@ -35,7 +35,7 @@ export function sendAnchor(messages:Row[],text:string,roomLoaded:boolean):{after
 export function pendingIntentWasObserved(messages:Row[],intent:BusinessChatIntent|null):boolean{
  if(!intent)return false;
  const stored=messages.filter(message=>!message.pending);
- if(stored.some(message=>message.id===intent.id))return true;
+ if(stored.some(message=>message.id===(intent.storedId||intent.id)))return true;
  let newer:Row[];
  if(intent.fromStart)newer=stored;
  else{

package/templates/branded-lite/tier5-src/_shared/business-chat-presenter.ts

@@ -161,7 +161,7 @@ export function businessVisitorOptionSuggestions(options: BusinessVisitorOptions
 }
 
 /** Wix Chat realtime currently sends `{type, timestamp, summary, message?}` events. */
-export function isBusinessMessageEvent(envelope: unknown, roomId: string): boolean {
+export function isBusinessMessageEvent(envelope: unknown, roomId: string, smartChat = false): boolean {
   const event = object(object(envelope).event);
   if (!roomId || typeof event.type !== "string" || !/^(message|messagesent)$/i.test(event.type)) return false;
   const message = object(event.message);
@@ -169,16 +169,19 @@ export function isBusinessMessageEvent(envelope: unknown, roomId: string): boole
   const nested = object(data.message);
   const eventRoomId = [event.chatroomId, event.chatRoomId, message.chatroomId, message.chatRoomId, data.chatroomId, nested.chatroomId]
     .find((value): value is string => typeof value === "string" && value.length > 0);
-  return !eventRoomId || eventRoomId === roomId;
+  // Smart Chat's room can differ from the Members room. The subsequent read is scoped by
+  // the current member/site identity, never by the event's untrusted room id.
+  return smartChat || !eventRoomId || eventRoomId === roomId;
 }
 
 export function shouldRefreshBusinessHistory(
   envelope: unknown,
   roomId: string,
   session: { member: boolean; principal: string; currentPrincipal: string; scope: string; currentScope: string },
+  smartChat = false,
 ): boolean {
   return !!session.member && !!roomId && !!session.principal && session.principal === session.currentPrincipal &&
-    session.scope === session.currentScope && isBusinessMessageEvent(envelope, roomId);
+    session.scope === session.currentScope && isBusinessMessageEvent(envelope, roomId, smartChat);
 }
 
 function safeAvatar(value: unknown): string {
@@ -468,8 +471,8 @@ export function presentBusinessMessages<T extends Pick<BusinessMessage, "id" | "
       : standardEventText || row.plainText;
     const senderAvatar = safeAvatar(image.url);
     const mine = participantId && typeof sender.userId === "string" ? sender.userId === participantId : row.mine;
-    const isAiGenerated = !!participantId && !mine && !!message.appId && typeof message.originMethod === "string" && /:AI_SITE_CHAT$/i.test(message.originMethod) &&
-      (message.messageType === "message" || message.messageType === "template/standard-event" || message.messageType === "template/card");
+    const isAiGenerated = message.aiSiteChatSender === "ASSISTANT" || (message.aiSiteChatSender !== "USER" && !!participantId && !mine && !!message.appId && typeof message.originMethod === "string" && /:AI_SITE_CHAT$/i.test(message.originMethod) &&
+      (message.messageType === "message" || message.messageType === "template/standard-event" || message.messageType === "template/card"));
     const rawSenderName = typeof display.name === "string" && display.name.trim()
       ? display.name.trim()
       : typeof display.displayName === "string" && display.displayName.trim() ? display.displayName.trim() : "";

package/templates/branded-lite/tier5-src/_shared/business-chat-transport.ts

@@ -78,12 +78,42 @@ function bridge(): Bridge {
 }
 /** A typed message goes through Smart Chat, exactly as the site's chat widget sends it. The Inbox then files it under
  *  Wix Smart Chat and the AI can answer it; a message posted straight into the room has no channel, so the AI never
- *  saw it and the owner's reply went out by email. It lands in the same room, under an id the server chooses.
+ *  saw it and the owner's reply went out by email. Smart Chat chooses the conversation and stored message id.
  *  The bridge resolves once the AI has finished answering, not when the message is stored. */
-export const sendMessage = (identity: ChatIdentity, text: string): Promise<void> => fenced(identity, async () => {
-  await bridge().call("POST", "/wix-assistant-widget/v1/messages/stream", {
+export const sendMessage = (identity: ChatIdentity, text: string): Promise<string | undefined> => fenced(identity, async () => {
+  const response = await bridge().call("POST", "/wix-assistant-widget/v1/messages/stream", {
     message: { sender: "SITE_VISITOR", messageType: "QUESTION", body: { mainText: text } },
   });
+  // The first stream frame names the persisted question. Keep its exact id so a send
+  // that moves from an old Members transcript to Smart Chat never relies on a text match.
+  let frames: unknown = response;
+  if (typeof frames === "string") {
+    const raw = frames;
+    try { frames = JSON.parse(raw); }
+    catch {
+      frames = [];
+      // The bridge buffers SSE verbatim. Ignore event/comment lines and decode the
+      // data of each frame; some hosts instead hand over NDJSON or parsed frames.
+      for (const block of raw.split(/\r?\n\r?\n/)) {
+        const lines = block.split(/\r?\n/);
+        const event = lines.find(line => line.startsWith('event:'))?.slice(6).trim();
+        const data = lines.filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n');
+        try {
+          const value = JSON.parse(data || block);
+          (frames as unknown[]).push(event === 'inputMessage' && !value?.inputMessage ? { inputMessage: value } : value);
+        } catch { /* Comments and other non-JSON frames carry no stored question id. */ }
+      }
+      // A buffered NDJSON response has no SSE separators.
+      if (!(frames as unknown[]).length) {
+        try { frames = [JSON.parse(raw.split('\n', 1)[0]!)]; } catch { return undefined; }
+      }
+    }
+  }
+  for (const frame of Array.isArray(frames) ? frames : [frames]) {
+    const input = (frame as { inputMessage?: { id?: unknown; sender?: unknown; messageType?: unknown } } | null)?.inputMessage;
+    if (input?.sender === "SITE_VISITOR" && input.messageType === "QUESTION" && typeof input.id === "string" && input.id) return `smart-chat:${input.id}`;
+  }
+  return undefined;
 });
 /** A tapped button is a silent, ephemeral message carrying the button's chat action. */
 export const sendButton = (identity: ChatIdentity, roomId: string, input: { id: string; text: string; appId: string; interactionId: string }): Promise<void> => fenced(identity, async () => {

package/templates/branded-lite/tier5-src/business-chat/index.ts

@@ -6,6 +6,7 @@ import { businessChatSendRejected, messageTimeLabel, sendAnchor, pendingIntentWa
 import { subscribeRealtime, unsubscribeRealtime, getRealtimeStatus, type RealtimeStatus, type RealtimeEventEnvelope } from '@himalaya/wix-chat';
 import { businessInAppRoute, type BusinessArticleAction, dispatchBusinessSuggestion, businessRealtimeStatusLabel, businessVisitorOptionSuggestions, presentBusinessMessages, selectExistingBusinessRoom, shouldRefreshBusinessHistory, type BusinessSuggestion, type BusinessVisitorOptions, businessVisitorOptionRequest, businessVisitorOptionsFromAiMessages, newBusinessSelectionId} from '../_shared/business-chat-presenter.js';
 import { listMessages, streamMessages } from '@himalaya/wix-ai-site-chat';
+import { smartChatHistory } from '../_shared/business-chat-history.js';
 import { hostSiteFromInput } from '../_shared/branded-lite-hosted.js';
 import { productImage, searchStoreProducts } from '../_shared/himi-store.js';
 import { queryServices } from '@himalaya/wix-bookings';
@@ -23,6 +24,7 @@ type BusinessMessageRow = Pick<MessageRow,'id'|'sender'|'when'|'createdDate'|'mi
 type State = {
   phase:'loading'|'ready'|'error'|'guest'; error:string; notice:string; member:boolean;
   roomId:string; principal:string; scope:string; messages:BusinessMessageRow[]; draft:string; busy:boolean;
+  historySource:'members'|'smart-chat';
   liveState:string; liveReason:string; realtimeEventCount:number; lastRealtimeEventType:string; pendingIntent:PendingIntent|null; scrollAnchor:string; scrollSend:number; usedSuggestionIds:string[]; visitorOptions:BusinessVisitorOptions|null; quickReplies:BusinessSuggestion[]; hasQuickReplies:boolean; noQuickReplies:boolean;
   liveLabel:string; hasActiveRoom:boolean; noActiveRoom:boolean; isGuest:boolean; notGuest:boolean; realtimeDiagnostic:string; noError:boolean; noNotice:boolean; noMessages:boolean; hasMessages:boolean; noEmpty:boolean; notLoading:boolean;
   hostedName:string; hasHostedName:boolean; noHostedName:boolean;
@@ -45,7 +47,7 @@ function initialsOf(name:string):string{
  const words=name.trim().split(/\s+/).filter(Boolean);
  return (words.length>1?`${first(words[0]!)}${first(words[words.length-1]!)}`:first(words[0]??'')).toUpperCase();
 }
-const initial:State={hostedName,businessName:hostedName,businessInitials:initialsOf(hostedName),hasHostedName:!!hostedName,noHostedName:!hostedName,phase:'loading',error:'',notice:'',member:false,roomId:'',principal:'',scope:'',messages:[],draft:'',busy:false,
+const initial:State={hostedName,businessName:hostedName,businessInitials:initialsOf(hostedName),hasHostedName:!!hostedName,noHostedName:!hostedName,phase:'loading',error:'',notice:'',member:false,roomId:'',principal:'',scope:'',messages:[],draft:'',busy:false,historySource:'members',
   liveState:'unavailable',liveReason:'',realtimeEventCount:0,lastRealtimeEventType:'',liveLabel:'',hasActiveRoom:false,noActiveRoom:true,isGuest:false,notGuest:true,realtimeDiagnostic:'',pendingIntent:null,scrollAnchor:'',scrollSend:0,usedSuggestionIds:[],visitorOptions:null,quickReplies:[],hasQuickReplies:false,noQuickReplies:true,noError:true,noNotice:true,noMessages:true,hasMessages:false,noEmpty:true,notLoading:false,sendDisabled:true,sendEnabled:false,noLive:true,loadingHidden:false,errorText:'',loadFailure:''};
 let currentIdentity:ChatIdentity|null=null;
 let subscriptionId='';
@@ -65,11 +67,34 @@ let businessParticipantId='';
 let loadStage:'room_selection'|'history_request'|'history_normalization'|'ai_enrichment'='room_selection';
 let readServiceState:()=>State=()=>shape(initial);
 
-/** The member-scoped AI conversation's current unanswered quick replies. */
-async function loadBusinessVisitorOptions():Promise<BusinessVisitorOptions|null>{
- const response=await chat.fence(me(),()=>listMessages({cursorPaging:{limit:20}}));
- return businessVisitorOptionsFromAiMessages(response.messages??[]);
+/** Follow the identity-scoped history cursor: the first page need not contain the latest reply.
+ * Refuse an incomplete transcript rather than silently returning another conversation. */
+async function loadSmartChatMessages():Promise<unknown[]>{
+ const messages:unknown[]=[];
+ const seen=new Set<string>();
+ let cursor:string|undefined;
+ const incomplete=()=>Object.assign(new Error('smart_chat_history_incomplete'),{code:'smart_chat_history_incomplete'});
+ for(let page=0;page<20;page++){
+  let response:Awaited<ReturnType<typeof listMessages>>;
+  try{response=await chat.fence(me(),()=>listMessages({cursorPaging:{limit:100,...(cursor?{cursor}:{})}}));}
+  catch(error){
+   if(/member_sign_in_required|MemberAccessChanged|\b401\b/i.test(String(error))||(page>0&&/\b403\b/.test(String(error))))throw Object.assign(new Error('member_sign_in_required'),{code:'smart_chat_history_incomplete'});
+   // Only an explicit unavailable feature permits the legacy fallback. A timeout or
+   // 5xx says nothing about whether a Smart Chat conversation exists.
+   if(!page&&/\b403\b|\b404\b/.test(String(error)))throw error;
+   throw incomplete();
+  }
+  if(!Array.isArray(response?.messages))throw incomplete();
+  messages.push(...response.messages);
+  const paging=response.pagingMetadata;
+  const next=paging?.cursors?.next;
+  if(paging?.hasNext===false||(!paging?.hasNext&&!next))return messages;
+  if(typeof next!=='string'||!next.trim()||seen.has(next))throw incomplete();
+  seen.add(next);cursor=next;
+ }
+ throw incomplete();
 }
+
 /** Submit a displayed quick reply through the AI endpoint; a label counts only while it is still a current option. */
 async function sendBusinessVisitorOption(options:BusinessVisitorOptions|null|undefined,label:string):Promise<boolean>{
  const request=businessVisitorOptionRequest(options,label,newBusinessSelectionId());
@@ -260,11 +285,22 @@ async function refreshHistory(s:State):Promise<State|undefined>{
  const stale=()=>startEpoch!==epoch||(currentIdentity?.userId||currentIdentity?.email)!==principal;
  try{
   loadStage='history_request';
-  // The room history and the AI's open options are independent reads: fetch them together.
-  const optionsRead:Promise<BusinessVisitorOptions|null>=currentIdentity?.authenticated?loadBusinessVisitorOptions().catch(()=>null/* Optional AI list failure must not hide Inbox history. */):Promise.resolve(null);
-  const page=await chat.messagesPage(me(),roomId);
-  const visitorOptions=await optionsRead;
+  // The Members room and Smart Chat may be different conversations. Read Smart Chat's
+  // persisted transcript, not only its quick replies; retain Members history for sites without it.
+  const [memberRead,aiRead]=await Promise.all([
+   chat.messagesPage(me(),roomId).then(page=>({page,error:null})).catch(error=>({page:[],error})),
+   loadSmartChatMessages().then(messages=>({messages,error:null})).catch(error=>({messages:[],error})),
+  ]);
   if(stale())return undefined;
+  // Once this screen has followed Smart Chat, an unavailable read must not switch it back
+  // to the unrelated Members thread.
+  if(aiRead.error&&(s.historySource==='smart-chat'||aiRead.error.code==='smart_chat_history_incomplete'))throw aiRead.error;
+  const smart=smartChatHistory(aiRead.messages,memberRead.page,businessParticipantId);
+  const useSmart=!!smart||s.historySource==='smart-chat';
+  if(!useSmart&&memberRead.error)throw memberRead.error;
+  const page=useSmart?smart?.messages??[]:memberRead.page;
+  const historySource=useSmart?'smart-chat' as const:'members' as const;
+  const visitorOptions=businessVisitorOptionsFromAiMessages(aiRead.messages);
   loadStage='history_normalization';
   // Presented from the page alone: a row kept from an earlier page would be re-presented without the
   // metadata that only the page carries (sender, avatar, AI badge, article buttons).
@@ -283,7 +319,7 @@ async function refreshHistory(s:State):Promise<State|undefined>{
   // An unconfirmed one (its request is over) no longer holds Send once its words show up; its notice stays.
   const shown=!intentObserved&&base.pendingIntent?[...messages,pendingRow(base.pendingIntent)]:messages;
   const pendingIntent=intentObserved&&base.pendingIntent?.delivery==='unconfirmed'?null:base.pendingIntent;
-  return shape({...base,messages:shown,pendingIntent,visitorOptions,quickReplies:businessVisitorOptionSuggestions(visitorOptions),draft,phase:'ready',error:'',loadFailure:''});
+  return shape({...base,historySource,messages:shown,pendingIntent,visitorOptions,quickReplies:businessVisitorOptionSuggestions(visitorOptions),draft,phase:'ready',error:'',loadFailure:''});
  }catch(error){
   const wrapped=error instanceof Error?error:new Error('load_failed');
   Object.assign(wrapped,{businessLoadFailure:safeLoadFailure(error)});
@@ -300,7 +336,7 @@ function withLiveFields(st:State,latest:State,draft:string):State{
   scrollSend:Math.max(st.scrollSend,latest.scrollSend)};
 }
 function withLiveDraft(st:State):State{const latest=readServiceState();return withLiveFields(st,latest,latest.draft);}
-type SendResult={id:string;outcome:'sent'|'rejected'|'unconfirmed'|'signed_out';draft:string;error?:unknown};
+type SendResult={id:string;outcome:'sent'|'rejected'|'unconfirmed'|'signed_out';draft:string;storedId?:string;error?:unknown};
 /** Posts one message and reports how it ended; never throws. The caller already showed the message. The call lasts
  *  until the AI has answered: history usually shows the stored copy first, which replaces the placeholder, while Send
  *  stays held until this settles (the site's widget also waits for the answer). */
@@ -309,7 +345,7 @@ async function deliver(pending:BusinessChatIntent,draft:string):Promise<void>{
  let result:SendResult={id:pending.id,outcome:'sent',draft};
  try{
   await Promise.resolve();// the action that started this has returned its state by now
-  await chat.sendMessage(me(),pending.text);
+  result.storedId=await chat.sendMessage(me(),pending.text);
  }catch(error){
   const lost=/member_sign_in_required|MemberAccessChanged|\b401\b|\b403\b/i.test(String(error));
   result={id:pending.id,draft,error,outcome:lost?'signed_out':businessChatSendRejected(error)?'rejected':'unconfirmed'};
@@ -408,7 +444,7 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
     const seen=pendingIntentWasObserved(s.messages,pending);
     return shape({...s,pendingIntent:seen?null:unconfirmed,messages:replaceRow(unconfirmed),error:safeError(result.error,'send'),notice:'No automatic retry was made. Reopen the conversation to check whether it arrived.'});
    }
-   const sent={...pending,delivery:'sent' as const};
+   const sent={...pending,storedId:result.storedId,delivery:'sent' as const};
    const accepted=shape({...s,pendingIntent:sent,messages:replaceRow(sent),error:'',notice:''});
    const sendEpoch=epoch;
    // The server accepted it, so Send is free again whatever history says; the row stays until history returns it.
@@ -416,11 +452,13 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
    // History that already holds the message under the server's id needs no placeholder for it. Only this send's intent
    // is cleared: a newer one the live state carried in is that send's to settle.
    const ownIntent=(st:State)=>st.pendingIntent&&st.pendingIntent.id!==sent.id?st.pendingIntent:null;
-   const settled=(st:State):State=>pendingIntentWasObserved(st.messages,sent)&&!st.messages.some(row=>row.id===sent.id)?shape({...st,pendingIntent:ownIntent(st),notice:''}):
+   const settled=(st:State):State=>pendingIntentWasObserved(st.messages,sent)?shape({...st,pendingIntent:ownIntent(st),notice:'',messages:st.messages.filter(row=>!(row.id===sent.id&&row.pending))}):
     shape({...st,pendingIntent:ownIntent(st),notice:'',messages:st.messages.some(row=>row.id===sent.id)?st.messages.map(row=>row.id===sent.id&&row.pending?pendingRow(sent):row):[...st.messages,pendingRow(sent)]});
-   // While live updates are connected the server's own event brings the message back through one refresh; a second
-   // one here would only queue behind it on the worker, delaying the member's next keystroke or send.
-   if(s.liveState==='connected')return settled(accepted);
+   // The stream finishes after the AI has persisted its answer. Reload even while connected:
+   // the Members-room subscription may never see the separate Smart Chat room's event.
+   // A refresh already running owns the next read. Queue one more pass without keeping Send
+   // locked behind that request (or allowing its old snapshot to restore this intent).
+   if(refreshFlight){refreshQueued=true;return settled(accepted);}
    try{const loaded=await loadLatest(accepted,true);return loaded?settled(loaded):undefined;}catch(error){
     // A session lost by an older operation says nothing about the member who is signed in now.
     if(sendEpoch!==epoch)return undefined;
@@ -461,7 +499,7 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
    const envelope=a as RealtimeEventEnvelope|undefined;
    const eventType=typeof envelope?.event?.type==='string'?envelope.event.type:'';
    s=shape({...s,realtimeEventCount:s.realtimeEventCount+1,lastRealtimeEventType:eventType});
-   if(!currentIdentity||!shouldRefreshBusinessHistory(envelope,s.roomId,{member:s.member,principal:s.principal,currentPrincipal:currentIdentity.userId||currentIdentity.email,scope:s.scope,currentScope:currentIdentity.scope}))return s;
+   if(!currentIdentity||!shouldRefreshBusinessHistory(envelope,s.roomId,{member:s.member,principal:s.principal,currentPrincipal:currentIdentity.userId||currentIdentity.email,scope:s.scope,currentScope:currentIdentity.scope},s.historySource==='smart-chat'))return s;
    if(refreshFlight){refreshQueued=true;return withLiveDraft(s);}
    try{return await loadLatest(s);}catch(error){
     if(startEpoch!==epoch)return undefined;