@open-mercato/ui 0.6.4-develop.3949.1.adc3d0b3b1 → 0.6.4-develop.3962.1.70f30e284c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/ui",
-  "version": "0.6.4-develop.3949.1.adc3d0b3b1",
+  "version": "0.6.4-develop.3962.1.70f30e284c",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
@@ -141,13 +141,13 @@
     "remark-gfm": "^4.0.1"
   },
   "peerDependencies": {
-    "@open-mercato/shared": "0.6.4-develop.3949.1.adc3d0b3b1",
+    "@open-mercato/shared": "0.6.4-develop.3962.1.70f30e284c",
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0",
     "react-is": ">=18.0.0"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.6.4-develop.3949.1.adc3d0b3b1",
+    "@open-mercato/shared": "0.6.4-develop.3962.1.70f30e284c",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.1",

package/src/ai/AiChat.tsx

@@ -309,6 +309,14 @@ export interface AiChatProps {
   headerActions?: React.ReactNode
   /** Called once on mount (and on reset) with the effective conversation id. */
   onConversationIdChange?: (conversationId: string) => void
+  /**
+   * Called when the server returns 404 for the active `conversationId`,
+   * e.g. when the id was carried over from a previous tenant/org scope
+   * and no longer exists. The host (typically the AI dock) should remove
+   * the corresponding session entry so the stale tab disappears instead
+   * of staying empty.
+   */
+  onConversationNotFound?: () => void
 }
 
 interface ServerEmittedUiPartRef {
@@ -1147,6 +1155,7 @@ export function AiChat({
   defaultCompactFooter = false,
   headerActions,
   onConversationIdChange,
+  onConversationNotFound,
 }: AiChatProps) {
   const t = useT()
   const onConversationIdChangeRef = React.useRef(onConversationIdChange)
@@ -1277,6 +1286,7 @@ export function AiChat({
     conversationId,
     providerOverride: effectiveModelPickerValue?.providerId ?? null,
     modelOverride: effectiveModelPickerValue?.modelId ?? null,
+    onConversationNotFound,
   })
 
   const isStreaming = chat.status === 'streaming'

package/src/ai/AiChatSessions.tsx

@@ -20,6 +20,10 @@
  */
 
 import * as React from 'react'
+import {
+  getCurrentOrganizationScope,
+  subscribeOrganizationScopeChanged,
+} from '@open-mercato/shared/lib/frontend/organizationEvents'
 import {
   createAiServerConversation,
   listAiServerConversations,
@@ -27,9 +31,27 @@ import {
   type AiServerConversation,
 } from './conversation-store'
 
-const STORAGE_KEY = 'om-ai-chat-sessions-v1'
+/**
+ * Legacy app-global storage key used before tenant/org scoping.
+ *
+ * Kept only as a documented constant for grep / debugging. No code path
+ * reads or writes it any more — the legacy entry is intentionally
+ * abandoned (not migrated) because the origin scope of any data stored
+ * under this key is unknown; silently importing it into the wrong scope
+ * is worse than empty state. `listAiServerConversations` repopulates
+ * sessions from the authoritative server source on first load.
+ */
+export const LEGACY_STORAGE_KEY = 'om-ai-chat-sessions-v1'
+const STORAGE_KEY_PREFIX = 'om-ai-chat-sessions-v1'
 const HISTORY_LIMIT = 50
 
+function getScopedStorageKey(
+  tenantId: string | null | undefined,
+  organizationId: string | null | undefined,
+): string {
+  return `${STORAGE_KEY_PREFIX}:${tenantId ?? 'no-tenant'}:${organizationId ?? 'no-org'}`
+}
+
 export type AiChatSessionStatus = 'open' | 'closed'
 
 export interface AiChatSession {
@@ -86,10 +108,10 @@ function makeId(): string {
   return `${Date.now().toString(16)}-${rand()}-${rand()}`
 }
 
-function readPersisted(): AiChatSessionsState {
+function readPersisted(storageKey: string): AiChatSessionsState {
   if (typeof window === 'undefined') return { sessions: [], activeByAgent: {} }
   try {
-    const raw = window.localStorage.getItem(STORAGE_KEY)
+    const raw = window.localStorage.getItem(storageKey)
     if (!raw) return { sessions: [], activeByAgent: {} }
     const parsed = JSON.parse(raw) as Partial<AiChatSessionsState> | null
     const sessions = Array.isArray(parsed?.sessions)
@@ -130,10 +152,10 @@ function readPersisted(): AiChatSessionsState {
   }
 }
 
-function writePersisted(state: AiChatSessionsState): void {
+function writePersisted(storageKey: string, state: AiChatSessionsState): void {
   if (typeof window === 'undefined') return
   try {
-    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(state))
+    window.localStorage.setItem(storageKey, JSON.stringify(state))
   } catch {
     /* quota / privacy mode — drop silently */
   }
@@ -194,11 +216,34 @@ export function AiChatSessionsProvider({ children }: { children: React.ReactNode
   // server (no `window`), so SSR stays consistent with the bare-bones
   // shell — actual session-dependent UI only renders after a user
   // interaction opens a chat surface.
-  const [state, setState] = React.useState<AiChatSessionsState>(() => readPersisted())
+  //
+  // The storage key is scoped to the current tenant/organization so a
+  // scope switch in the topbar does not surface another tenant's
+  // sessions. `getCurrentOrganizationScope()` reads module-level state
+  // populated by the topbar before the provider mounts; a `null` scope
+  // (pre-resolution) lands in a harmless `no-tenant:no-org` bucket that
+  // the scope-change subscription below immediately corrects when the
+  // real scope arrives.
+  const [storageKey, setStorageKey] = React.useState<string>(() => {
+    const scope = getCurrentOrganizationScope()
+    return getScopedStorageKey(scope.tenantId, scope.organizationId)
+  })
+  const [state, setState] = React.useState<AiChatSessionsState>(() => readPersisted(storageKey))
+
+  React.useEffect(() => {
+    return subscribeOrganizationScopeChanged((detail) => {
+      const nextKey = getScopedStorageKey(detail.tenantId, detail.organizationId)
+      if (nextKey === storageKey) return
+      // React 18 batches both updates within the synchronous handler so
+      // there is no intermediate render with a mismatched key/state pair.
+      setStorageKey(nextKey)
+      setState(readPersisted(nextKey))
+    })
+  }, [storageKey])
 
   React.useEffect(() => {
-    writePersisted(state)
-  }, [state])
+    writePersisted(storageKey, state)
+  }, [storageKey, state])
 
   React.useEffect(() => {
     let cancelled = false
@@ -209,7 +254,7 @@ export function AiChatSessionsProvider({ children }: { children: React.ReactNode
     return () => {
       cancelled = true
     }
-  }, [])
+  }, [storageKey])
 
   const update = React.useCallback(
     (mutator: (prev: AiChatSessionsState) => AiChatSessionsState) => {

package/src/ai/AiDock.tsx

@@ -476,6 +476,16 @@ function DockedChatBody({ assistant }: { assistant: AiDockedAssistant }) {
     if (!session) sessions.ensureSession(assistant.agent)
   }, [assistant.agent, session, sessions])
 
+  const activeSessionId = session?.id ?? null
+  const handleConversationNotFound = React.useCallback(() => {
+    // The server returned 404 for this session's conversationId. The
+    // conversation does not exist in the current tenant/org scope (most
+    // commonly the user just switched scope and a stale id rode along in
+    // localStorage). Close the tab so the dock surfaces the empty state
+    // for the new scope rather than a perpetual blank chat.
+    if (activeSessionId) sessions.closeSession(activeSessionId)
+  }, [activeSessionId, sessions])
+
   return (
     <>
       <ChatPaneTabs agentId={assistant.agent} className="border-b" />
@@ -499,6 +509,7 @@ function DockedChatBody({ assistant }: { assistant: AiDockedAssistant }) {
               welcomeTitle={assistant.welcomeTitle}
               welcomeDescription={assistant.welcomeDescription}
               headerActions={<ConversationShareButton conversationId={session.conversationId} />}
+              onConversationNotFound={handleConversationNotFound}
             />
           </React.Suspense>
         ) : null}

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),
+      )
+    })
+  })
 })