@open-mercato/ui 0.6.3-develop.3901.1.ddad60693a → 0.6.3

package/src/ai/__tests__/AiChat.conversation.test.tsx

@@ -158,6 +158,103 @@ describe('<AiChat> conversationId threading (Step 5.15)', () => {
     expect(parsedBody.conversationId).toBe('conv-body-xyz')
   })
 
+  it('invokes onConversationNotFound and does not import local messages when server returns 404', async () => {
+    const originalFetch = globalThis.fetch
+    const fetchMock = jest.fn((input: string | URL | Request) => {
+      const url = typeof input === 'string' ? input : input.toString()
+      if (url.includes('/api/ai_assistant/ai/conversations/conv-stale')) {
+        return Promise.resolve({
+          ok: false,
+          status: 404,
+          json: async () => ({ error: 'not found' }),
+        } as unknown as Response)
+      }
+      // Any /import call would be a regression we must catch:
+      if (url.includes('/import')) {
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: async () => ({}),
+        } as unknown as Response)
+      }
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: async () => ({}),
+      } as unknown as Response)
+    }) as unknown as typeof fetch
+    globalThis.fetch = fetchMock
+
+    const onConversationNotFound = jest.fn()
+
+    try {
+      renderWithProviders(
+        <AiChat
+          agent="customers.account_assistant"
+          conversationId="conv-stale"
+          onConversationNotFound={onConversationNotFound}
+        />,
+        { dict },
+      )
+
+      // hydrate effect is async — wait one tick for the 404 to land
+      await act(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 0))
+      })
+
+      expect(onConversationNotFound).toHaveBeenCalledTimes(1)
+      // No /import call must happen on 404 — cross-tenant data write guard.
+      const importCalls = fetchMock.mock.calls.filter(([url]) => {
+        const u = typeof url === 'string' ? url : (url as { toString(): string }).toString()
+        return u.includes('/conversations/import')
+      })
+      expect(importCalls).toHaveLength(0)
+    } finally {
+      globalThis.fetch = originalFetch
+    }
+  })
+
+  it('does NOT invoke onConversationNotFound on transient transport failure (503)', async () => {
+    const originalFetch = globalThis.fetch
+    const fetchMock = jest.fn((input: string | URL | Request) => {
+      const url = typeof input === 'string' ? input : input.toString()
+      if (url.includes('/api/ai_assistant/ai/conversations/conv-503')) {
+        return Promise.resolve({
+          ok: false,
+          status: 503,
+          json: async () => ({ error: 'upstream' }),
+        } as unknown as Response)
+      }
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: async () => ({}),
+      } as unknown as Response)
+    }) as unknown as typeof fetch
+    globalThis.fetch = fetchMock
+
+    const onConversationNotFound = jest.fn()
+
+    try {
+      renderWithProviders(
+        <AiChat
+          agent="customers.account_assistant"
+          conversationId="conv-503"
+          onConversationNotFound={onConversationNotFound}
+        />,
+        { dict },
+      )
+
+      await act(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 0))
+      })
+
+      expect(onConversationNotFound).not.toHaveBeenCalled()
+    } finally {
+      globalThis.fetch = originalFetch
+    }
+  })
+
   it('hydrates the transcript from server storage for an existing conversation', async () => {
     const originalFetch = globalThis.fetch
     const fetchMock = jest.fn(async () => ({

package/src/ai/__tests__/AiChatSessions.test.tsx

@@ -0,0 +1,228 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import * as React from 'react'
+import { act, screen, waitFor } from '@testing-library/react'
+import { renderWithProviders } from '@open-mercato/shared/lib/testing/renderWithProviders'
+import {
+  emitOrganizationScopeChanged,
+} from '@open-mercato/shared/lib/frontend/organizationEvents'
+import {
+  AiChatSessionsProvider,
+  LEGACY_STORAGE_KEY,
+  useAiChatSessions,
+} from '../AiChatSessions'
+
+jest.mock('../conversation-store', () => {
+  const actual = jest.requireActual('../conversation-store') as Record<string, unknown>
+  return {
+    ...actual,
+    listAiServerConversations: jest.fn(async () => null),
+    createAiServerConversation: jest.fn(async () => null),
+    updateAiServerConversation: jest.fn(async () => null),
+  }
+})
+
+import {
+  listAiServerConversations,
+  createAiServerConversation,
+} from '../conversation-store'
+
+const listMock = listAiServerConversations as jest.MockedFunction<typeof listAiServerConversations>
+const createMock = createAiServerConversation as jest.MockedFunction<typeof createAiServerConversation>
+
+const KEY_PREFIX = 'om-ai-chat-sessions-v1'
+
+function scopedKey(tenantId: string | null, organizationId: string | null): string {
+  return `${KEY_PREFIX}:${tenantId ?? 'no-tenant'}:${organizationId ?? 'no-org'}`
+}
+
+function CreateSessionButton({ agentId }: { agentId: string }) {
+  const sessions = useAiChatSessions()
+  return (
+    <button type="button" onClick={() => sessions.createSession(agentId)}>
+      Create session
+    </button>
+  )
+}
+
+function SessionCount({ agentId }: { agentId: string }) {
+  const sessions = useAiChatSessions()
+  const open = sessions.getOpenSessions(agentId)
+  return <span data-testid="session-count">{open.length}</span>
+}
+
+function Harness({ agentId }: { agentId: string }) {
+  return (
+    <AiChatSessionsProvider>
+      <CreateSessionButton agentId={agentId} />
+      <SessionCount agentId={agentId} />
+    </AiChatSessionsProvider>
+  )
+}
+
+describe('<AiChatSessionsProvider> — tenant/org scope isolation', () => {
+  beforeEach(() => {
+    window.localStorage.clear()
+    listMock.mockReset()
+    listMock.mockResolvedValue(null)
+    createMock.mockReset()
+    createMock.mockResolvedValue(null)
+    // Reset scope to a known starting point. The module-level state in
+    // organizationEvents persists across tests in the same file.
+    act(() => {
+      emitOrganizationScopeChanged({ tenantId: 'T1', organizationId: 'O1' })
+    })
+  })
+
+  afterEach(() => {
+    window.localStorage.clear()
+  })
+
+  it('does not read or write the legacy unscoped key', async () => {
+    window.localStorage.setItem(
+      LEGACY_STORAGE_KEY,
+      JSON.stringify({
+        sessions: [
+          {
+            id: 'legacy-session',
+            agentId: 'assistant',
+            conversationId: 'legacy-conv',
+            createdAt: 1,
+            lastUsedAt: 1,
+            status: 'open',
+          },
+        ],
+        activeByAgent: { assistant: 'legacy-session' },
+      }),
+    )
+
+    renderWithProviders(<Harness agentId="assistant" />)
+
+    await waitFor(() => {
+      expect(screen.getByTestId('session-count').textContent).toBe('0')
+    })
+
+    expect(window.localStorage.getItem(LEGACY_STORAGE_KEY)).not.toBeNull()
+  })
+
+  it('writes new sessions to the tenant/org scoped key', async () => {
+    renderWithProviders(<Harness agentId="assistant" />)
+
+    act(() => {
+      screen.getByRole('button', { name: 'Create session' }).click()
+    })
+
+    await waitFor(() => {
+      expect(screen.getByTestId('session-count').textContent).toBe('1')
+    })
+
+    const scoped = window.localStorage.getItem(scopedKey('T1', 'O1'))
+    expect(scoped).not.toBeNull()
+    const parsed = JSON.parse(scoped!) as { sessions: Array<{ agentId: string }> }
+    expect(parsed.sessions).toHaveLength(1)
+    expect(parsed.sessions[0].agentId).toBe('assistant')
+
+    expect(window.localStorage.getItem(scopedKey('T2', 'O2'))).toBeNull()
+  })
+
+  it('rehydrates from the new scope on scope change (no flash of previous-scope data)', async () => {
+    // Seed BOTH scopes' buckets with distinct session counts so we can
+    // observe the swap.
+    window.localStorage.setItem(
+      scopedKey('T1', 'O1'),
+      JSON.stringify({
+        sessions: [
+          {
+            id: 's1',
+            agentId: 'assistant',
+            conversationId: 'c1',
+            createdAt: 1,
+            lastUsedAt: 1,
+            status: 'open',
+          },
+          {
+            id: 's2',
+            agentId: 'assistant',
+            conversationId: 'c2',
+            createdAt: 2,
+            lastUsedAt: 2,
+            status: 'open',
+          },
+        ],
+        activeByAgent: { assistant: 's1' },
+      }),
+    )
+    window.localStorage.setItem(
+      scopedKey('T2', 'O2'),
+      JSON.stringify({
+        sessions: [
+          {
+            id: 's3',
+            agentId: 'assistant',
+            conversationId: 'c3',
+            createdAt: 3,
+            lastUsedAt: 3,
+            status: 'open',
+          },
+        ],
+        activeByAgent: { assistant: 's3' },
+      }),
+    )
+
+    renderWithProviders(<Harness agentId="assistant" />)
+
+    await waitFor(() => {
+      expect(screen.getByTestId('session-count').textContent).toBe('2')
+    })
+
+    act(() => {
+      emitOrganizationScopeChanged({ tenantId: 'T2', organizationId: 'O2' })
+    })
+
+    await waitFor(() => {
+      expect(screen.getByTestId('session-count').textContent).toBe('1')
+    })
+
+    // T1/O1 bucket must remain untouched after the swap.
+    const t1Raw = window.localStorage.getItem(scopedKey('T1', 'O1'))
+    expect(t1Raw).not.toBeNull()
+    const t1Parsed = JSON.parse(t1Raw!) as { sessions: unknown[] }
+    expect(t1Parsed.sessions).toHaveLength(2)
+  })
+
+  it('refires the server conversation list on scope change', async () => {
+    renderWithProviders(<Harness agentId="assistant" />)
+
+    await waitFor(() => {
+      expect(listMock).toHaveBeenCalledTimes(1)
+    })
+
+    act(() => {
+      emitOrganizationScopeChanged({ tenantId: 'T2', organizationId: 'O2' })
+    })
+
+    await waitFor(() => {
+      expect(listMock).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  it('falls back to the no-tenant/no-org bucket when scope is unresolved', async () => {
+    act(() => {
+      emitOrganizationScopeChanged({ tenantId: null, organizationId: null })
+    })
+
+    renderWithProviders(<Harness agentId="assistant" />)
+
+    act(() => {
+      screen.getByRole('button', { name: 'Create session' }).click()
+    })
+
+    await waitFor(() => {
+      expect(screen.getByTestId('session-count').textContent).toBe('1')
+    })
+
+    expect(window.localStorage.getItem(scopedKey(null, null))).not.toBeNull()
+  })
+})

package/src/ai/__tests__/AiDock.test.tsx

@@ -11,11 +11,21 @@ import { AiDockProvider, useAiDock, type AiDockedAssistant } from '../AiDock'
 jest.mock('../AiChat', () => {
   const ReactModule = require('react') as typeof import('react')
   return {
-    AiChat: ({ agent, defaultCompactFooter }: { agent: string; defaultCompactFooter?: boolean }) =>
+    AiChat: ({
+      agent,
+      defaultCompactFooter,
+      onConversationNotFound,
+    }: {
+      agent: string
+      defaultCompactFooter?: boolean
+      onConversationNotFound?: () => void
+    }) =>
       ReactModule.createElement('div', {
         'data-testid': 'ai-chat',
         'data-agent': agent,
         'data-default-compact-footer': defaultCompactFooter ? 'true' : 'false',
+        'data-has-conversation-not-found-handler': typeof onConversationNotFound === 'function' ? 'true' : 'false',
+        onClick: () => onConversationNotFound?.(),
       }),
   }
 })
@@ -132,4 +142,24 @@ describe('<AiDockProvider>', () => {
       expect(screen.getByTestId('ai-chat')).toHaveAttribute('data-default-compact-footer', 'true')
     })
   })
+
+  it('wires onConversationNotFound so a stale session closes (no perpetual blank chat)', async () => {
+    renderWithProviders(<Harness />)
+
+    fireEvent.click(screen.getByRole('button', { name: 'Dock assistant' }))
+
+    const chat = await waitFor(() => screen.getByTestId('ai-chat'))
+    expect(chat).toHaveAttribute('data-has-conversation-not-found-handler', 'true')
+
+    // Fire the not-found callback via the mocked AiChat's onClick.
+    fireEvent.click(chat)
+
+    // After closeSession, the active session disappears; DockedChatBody
+    // schedules ensureSession in an effect, so for one tick the AiChat
+    // surface should be torn down before the new session mounts.
+    await waitFor(() => {
+      const next = screen.queryByTestId('ai-chat')
+      if (next === chat) throw new Error('stale chat surface should have unmounted')
+    })
+  })
 })

package/src/ai/__tests__/conversation-store.test.ts

@@ -1,4 +1,4 @@
-import { listAiServerConversations } from '../conversation-store'
+import { listAiServerConversations, loadAiServerTranscript } from '../conversation-store'
 
 describe('AI conversation store', () => {
   const originalFetch = global.fetch
@@ -26,4 +26,77 @@ describe('AI conversation store', () => {
       }),
     )
   })
+
+  describe('loadAiServerTranscript', () => {
+    it('returns ok=true with parsed data on 200', async () => {
+      const payload = {
+        conversation: {
+          conversationId: 'conv-1',
+          agentId: 'agent-1',
+          title: null,
+          status: 'open',
+          visibility: 'private',
+          pageContext: null,
+          createdAt: '2026-05-28T00:00:00Z',
+          updatedAt: '2026-05-28T00:00:00Z',
+          lastMessageAt: null,
+          importedFromLocalAt: null,
+          isOwner: true,
+        },
+        messages: [],
+        nextCursor: null,
+      }
+      global.fetch = jest.fn(async () => new Response(JSON.stringify(payload), { status: 200 })) as unknown as typeof fetch
+
+      const result = await loadAiServerTranscript('conv-1')
+
+      expect(result).toEqual({ ok: true, data: payload })
+    })
+
+    it('returns ok=false notFound=true on 404 (stale conversationId from previous scope)', async () => {
+      global.fetch = jest.fn(async () => new Response('{"error":"not found"}', { status: 404 })) as unknown as typeof fetch
+
+      const result = await loadAiServerTranscript('conv-from-old-scope')
+
+      expect(result).toEqual({ ok: false, notFound: true })
+    })
+
+    it('returns ok=false notFound=false on 503 (transient transport failure)', async () => {
+      global.fetch = jest.fn(async () => new Response('{"error":"upstream"}', { status: 503 })) as unknown as typeof fetch
+
+      const result = await loadAiServerTranscript('conv-1')
+
+      expect(result).toEqual({ ok: false, notFound: false })
+    })
+
+    it('returns ok=false notFound=false on 403 (no scope membership)', async () => {
+      global.fetch = jest.fn(async () => new Response('{"error":"forbidden"}', { status: 403 })) as unknown as typeof fetch
+
+      const result = await loadAiServerTranscript('conv-1')
+
+      expect(result).toEqual({ ok: false, notFound: false })
+    })
+
+    it('returns ok=false notFound=false when fetch throws', async () => {
+      global.fetch = jest.fn(async () => {
+        throw new TypeError('Failed to fetch')
+      }) as unknown as typeof fetch
+
+      const result = await loadAiServerTranscript('conv-1')
+
+      expect(result).toEqual({ ok: false, notFound: false })
+    })
+
+    it('forwards the limit option as a query string', async () => {
+      const fetchMock = jest.fn(async () => new Response('{}', { status: 404 }))
+      global.fetch = fetchMock as unknown as typeof fetch
+
+      await loadAiServerTranscript('conv-1', { limit: 25 })
+
+      expect(fetchMock).toHaveBeenCalledWith(
+        '/api/ai_assistant/ai/conversations/conv-1?limit=25',
+        expect.any(Object),
+      )
+    })
+  })
 })

package/src/ai/conversation-store.ts

@@ -15,6 +15,8 @@ export interface AiServerConversation {
   updatedAt: string
   lastMessageAt: string | null
   importedFromLocalAt: string | null
+  /** `true` when the authenticated caller created the conversation; `false` for shared participants; `null` when unknown. */
+  isOwner: boolean | null
 }
 
 export interface AiServerMessage {
@@ -28,6 +30,7 @@ export interface AiServerMessage {
   model: string | null
   metadata: Record<string, unknown> | null
   createdAt: string
+  senderUserId: string | null
 }
 
 export interface AiServerConversationListResponse {
@@ -47,6 +50,21 @@ export interface AiServerImportResponse {
   skippedMessageCount: number
 }
 
+/**
+ * Discriminated result of {@link loadAiServerTranscript}. Callers must
+ * distinguish 404 (the conversation does not exist for the current scope —
+ * e.g. it belonged to a previous tenant/org) from other failures (network
+ * down, server error) because the recovery strategies are opposite:
+ *  - `notFound: true`  → drop the local cache, optionally surface a
+ *                         not-found callback. NEVER import local messages
+ *                         onto the new scope.
+ *  - `notFound: false` → preserve local state and retry later.
+ */
+export type LoadTranscriptResult =
+  | { ok: true; data: AiServerTranscriptResponse }
+  | { ok: false; notFound: true }
+  | { ok: false; notFound: false }
+
 function readString(value: unknown): string | null {
   return typeof value === 'string' && value.length > 0 ? value : null
 }
@@ -144,13 +162,14 @@ export async function updateAiServerConversation(
 export async function loadAiServerTranscript(
   conversationId: string,
   options: { limit?: number } = {},
-): Promise<AiServerTranscriptResponse | null> {
+): Promise<LoadTranscriptResult> {
   const params = new URLSearchParams()
   params.set('limit', String(options.limit ?? 100))
   const result = await requestJson<AiServerTranscriptResponse>(
     `${CONVERSATIONS_ENDPOINT}/${encodeURIComponent(conversationId)}?${params.toString()}`,
   )
-  return result.ok ? result.data : null
+  if (result.ok) return { ok: true, data: result.data }
+  return { ok: false, notFound: result.status === 404 }
 }
 
 export async function importAiLocalConversation(input: {
@@ -242,5 +261,6 @@ export function serverMessageToChatMessage(message: AiServerMessage): AiChatMess
       })
       .filter((file): file is NonNullable<AiChatMessage['files']>[number] => file !== null),
     uiParts,
+    senderUserId: message.senderUserId ?? null,
   }
 }

package/src/ai/index.ts

@@ -126,6 +126,8 @@ export {
   type AiChatUploadFileStatus,
 } from './useAiChatUpload'
 export { LoopDisabledBanner } from './LoopDisabledBanner'
+export { ConversationShareButton } from './ConversationShareButton'
+export { ConversationShareDialog } from './ConversationShareDialog'
 export {
   LoopTracePanel,
   type LoopTracePanelProps,

package/src/ai/useAiChat.ts

@@ -69,6 +69,8 @@ export interface AiChatMessage {
   reasoning?: string
   reasoningStreaming?: boolean
   toolCalls?: AiChatToolCallSnapshot[]
+  /** User ID of the message author. Present for server-loaded messages; null for AI messages and locally-composed messages. */
+  senderUserId?: string | null
   /**
    * UI parts emitted by the agent during this message's lifecycle. Today
    * the only producer is `prepareMutation` (mutation approval flow):
@@ -116,6 +118,15 @@ export interface UseAiChatInput {
    * configured default (no override sent).
    */
   modelOverride?: string | null
+  /**
+   * Called when the server returns 404 for the active `conversationId`.
+   * Used by hosts to remove a stale session entry (e.g. the AI dock
+   * closes the session tab) when a conversation no longer exists for the
+   * current tenant/org scope. A 404 here distinguishes a missing
+   * conversation from a transient transport failure — the hook never
+   * imports local messages onto the new scope when this fires.
+   */
+  onConversationNotFound?: () => void
 }
 
 export interface AiChatErrorEnvelope {
@@ -145,6 +156,11 @@ export interface UseAiChatResult {
    * Phase 4 of spec `2026-04-28-ai-agents-agentic-loop-controls`.
    */
   lastLoopTrace: LoopTracePanelTrace | null
+  /**
+   * Whether the authenticated caller owns the loaded conversation. `true` for owners,
+   * `false` for shared participants (read-only view), `null` while unresolved.
+   */
+  isOwner: boolean | null
   sendMessage: (input: string, files?: AiChatMessageFile[]) => Promise<void>
   cancel: () => void
   reset: () => void
@@ -772,7 +788,7 @@ async function readErrorEnvelope(response: Response): Promise<AiChatErrorEnvelop
 }
 
 export function useAiChat(input: UseAiChatInput): UseAiChatResult {
-  const { agent, apiPath, pageContext, attachmentIds, debug, initialMessages, onError, conversationId: conversationIdInput, providerOverride, modelOverride } = input
+  const { agent, apiPath, pageContext, attachmentIds, debug, initialMessages, onError, conversationId: conversationIdInput, providerOverride, modelOverride, onConversationNotFound } = input
 
   // Minted once on mount when the caller does not supply a conversationId.
   // The ref keeps the id stable across re-renders and is reused for every
@@ -918,10 +934,14 @@ export function useAiChat(input: UseAiChatInput): UseAiChatResult {
     const localCandidate = readPersistedSession(agent, persistKey)
 
     async function hydrateFromServer(): Promise<void> {
-      const transcript = await loadAiServerTranscript(effectiveConversationId, { limit: 100 })
+      const transcriptResult = await loadAiServerTranscript(effectiveConversationId, { limit: 100 })
       if (cancelled || latestStatusRef.current !== 'idle') return
 
-      if (transcript) {
+      if (transcriptResult.ok) {
+        const transcript = transcriptResult.data
+        if (typeof transcript.conversation.isOwner === 'boolean') {
+          setIsOwner(transcript.conversation.isOwner)
+        }
         const serverMessages = transcript.messages
           .map(serverMessageToChatMessage)
           .filter((message): message is AiChatMessage => message !== null)
@@ -932,8 +952,25 @@ export function useAiChat(input: UseAiChatInput): UseAiChatResult {
         }
       }
 
+      // 404 — the conversation does not exist for the current tenant/org
+      // scope (e.g. the user switched scope and the stale conversationId
+      // came from the previous bucket's localStorage). Self-heal: drop
+      // the local cache, signal the host so it can prune its session
+      // registry, and NEVER fall through to importAiLocalConversation —
+      // that would silently write the previous scope's messages onto the
+      // new scope's server.
+      if (!transcriptResult.ok && transcriptResult.notFound) {
+        updateMessages([])
+        clearPersistedSession(agent, persistKey)
+        onConversationNotFoundRef.current?.()
+        return
+      }
+
       if (!localCandidate || localCandidate.messages.length === 0) {
-        if (!transcript) {
+        if (!transcriptResult.ok) {
+          // Transient transport failure (network down, 5xx, …). Mint a
+          // new server-side record optimistically; the next idle hydrate
+          // will reconcile.
           void createAiServerConversation({
             agentId: agent,
             conversationId: effectiveConversationId,
@@ -974,12 +1011,17 @@ export function useAiChat(input: UseAiChatInput): UseAiChatResult {
   >(null)
 
   const [lastLoopTrace, setLastLoopTrace] = React.useState<LoopTracePanelTrace | null>(null)
+  const [isOwner, setIsOwner] = React.useState<boolean | null>(null)
 
   const abortRef = React.useRef<AbortController | null>(null)
   const onErrorRef = React.useRef(onError)
   React.useEffect(() => {
     onErrorRef.current = onError
   }, [onError])
+  const onConversationNotFoundRef = React.useRef(onConversationNotFound)
+  React.useEffect(() => {
+    onConversationNotFoundRef.current = onConversationNotFound
+  }, [onConversationNotFound])
 
   const emitError = React.useCallback((envelope: AiChatErrorEnvelope) => {
     if (mountedRef.current) {
@@ -1319,6 +1361,7 @@ export function useAiChat(input: UseAiChatInput): UseAiChatResult {
     lastResponseDebug,
     conversationId: effectiveConversationId,
     lastLoopTrace,
+    isOwner,
     sendMessage,
     cancel,
     reset,