manigent-server 0.1.0__py3-none-any.whl

manigent/web/frontend/src/components/sidebar/AgentsPanel.tsx

@@ -0,0 +1,231 @@
+import { useMemo, useState } from 'react'
+import { useNavigate, useMatch } from 'react-router-dom'
+import { Globe } from 'lucide-react'
+import { useAuthStore } from '../../stores/authStore'
+import { confirmLeaveIfDirty } from '../../stores/unsavedGuard'
+import { useAssistantAgent } from '../../hooks/useAssistantAgent'
+import { useRecentAgents } from '../../hooks/useRecentAgents'
+import { useDmThreads } from '../../hooks/useDmThreads'
+import { useTeamGroups } from '../../hooks/useTeamGroups'
+import { useAgents } from '../../hooks/useAgents'
+import { useRetainedAgents } from '../../hooks/useAgentAccess'
+import { reachableAgents } from '../../utils/reachableAgents'
+import { hubThreadPath, REMOTE_TEXT_CAP, retainedHubLabel, safeRemoteText } from '../../utils/hubDisplay'
+import type { RetainedAgent } from '../../api/endpoints/hub'
+import { formatRelativeTime } from '../../utils/formatDate'
+import { displayName } from '../../utils/agentDisplay'
+import { type AgentCard } from '../../types'
+import PanelShell from './PanelShell'
+import AssistantHero from './AssistantHero'
+import AgentRow from './AgentRow'
+import TeamGroup from './TeamGroup'
+import SidebarAvatar from './SidebarAvatar'
+import DmComposeModal from '../dm/DmComposeModal'
+
+function Eyebrow({ children }: { children: React.ReactNode }) {
+  return (
+    <div className="flex items-center gap-1.5 px-3 pt-3 pb-1 text-[10.5px] font-extrabold uppercase tracking-[0.08em] text-channel">
+      {children}
+    </div>
+  )
+}
+
+// One retained agent of another server. It has no agent card here, so it is
+// not an AgentRow: no presence dot, a globe for "elsewhere", and every remote
+// string through safeRemoteText. Opens its hub thread, as Cmd-K does.
+function HubAgentRow({
+  agent,
+  isSelected,
+  onClick,
+}: {
+  agent: RetainedAgent
+  isSelected: boolean
+  onClick: () => void
+}) {
+  const name = safeRemoteText(agent.name, REMOTE_TEXT_CAP.name)
+  const label = retainedHubLabel(agent)
+  const description = safeRemoteText(agent.description, REMOTE_TEXT_CAP.description)
+  return (
+    <button
+      onClick={onClick}
+      className={`flex items-center gap-2 pl-3 pr-4 py-1 w-full text-left rounded hover:bg-sidebar-hover transition-colors ${
+        isSelected ? 'bg-sidebar-active text-sidebar-text-active font-bold' : 'text-sidebar-text'
+      }`}
+      title={description ? `${label} — ${description}` : label}
+    >
+      <SidebarAvatar name={name} size={21} ringColor="var(--bg-sidebar)" />
+      <span className="truncate font-mono text-[13px]">{label}</span>
+      <Globe className="ml-auto w-3 h-3 shrink-0 opacity-60" aria-label="On another server" />
+    </button>
+  )
+}
+
+// The default rail context: pinned assistant, Recents, teams, then the agents
+// the user retained — the same agent-first roster from approach B, now inside
+// the rail panel.
+export default function AgentsPanel({
+  onNavigate,
+}: {
+  onNavigate?: () => void
+}) {
+  const { user } = useAuthStore()
+  const navigate = useNavigate()
+  const dmMatch = useMatch('/dm/:agentName')
+  const activeAgentName = dmMatch?.params.agentName ? decodeURIComponent(dmMatch.params.agentName) : null
+  const hubMatch = useMatch('/hub/:hubAgentId/*')
+  const activeHubAgentId = hubMatch?.params.hubAgentId ? decodeURIComponent(hubMatch.params.hubAgentId) : null
+
+  const assistant = useAssistantAgent()
+  const recents = useRecentAgents(6, assistant?.id)
+  const { sortedTeamNames, teamBuckets, untemmedAgents, myAgents, isLoading } = useTeamGroups()
+  const { mostRecentByAgentId } = useDmThreads()
+  const { data: allAgents } = useAgents()
+  const { data: retained } = useRetainedAgents()
+  // Retained: other accounts' agents of this server (still shared) and agents
+  // of other servers — the same set Cmd-K and the agents' rosters list
+  // (utils/reachableAgents), minus the user's own agents shown above.
+  const { retainedHere, retainedHub } = useMemo(() => {
+    const { local, hub } = reachableAgents(allAgents, user?.id, retained)
+    return {
+      retainedHere: local
+        .filter((a) => a.registered_by !== user?.id)
+        .sort((a, b) => displayName(a, user).localeCompare(displayName(b, user))),
+      retainedHub: [...hub].sort((a, b) => a.name.localeCompare(b.name)),
+    }
+  }, [allAgents, retained, user])
+  const [composeOpen, setComposeOpen] = useState(false)
+
+  const activeWorkRoomFor = (agent: AgentCard) => {
+    const recent = mostRecentByAgentId.get(agent.id)
+    return recent ? { projectId: recent.projectId, chatroomName: 'user-communication' } : undefined
+  }
+
+  const selectAgent = (agent: AgentCard) => {
+    if (!confirmLeaveIfDirty()) return
+    navigate(`/dm/${encodeURIComponent(agent.name)}`)
+    onNavigate?.()
+  }
+
+  const selectHubAgent = (agent: RetainedAgent) => {
+    if (!confirmLeaveIfDirty()) return
+    navigate(hubThreadPath(agent.hub_agent_id))
+    onNavigate?.()
+  }
+  const retainedCount = retainedHere.length + retainedHub.length
+
+  // `+` opens the DM compose modal (mode='agent') against the user's assistant.
+  // Falls back to the classic register form if no assistant is registered yet
+  // (brand-new user), so the button is never a dead end.
+  return (
+    <>
+    <PanelShell
+      title="Agents"
+      onAdd={assistant ? () => setComposeOpen(true) : undefined}
+      addTo={assistant ? undefined : '/agents/new'}
+      addLabel="Register agent"
+      onNavigate={onNavigate}
+    >
+      {assistant && (
+        <div className="pt-2">
+          <AssistantHero
+            assistant={assistant}
+            viewer={user}
+            isActive={activeAgentName === assistant.name}
+            onSelect={() => selectAgent(assistant)}
+          />
+        </div>
+      )}
+
+      {recents.length > 0 && (
+        <>
+          <Eyebrow>Recents</Eyebrow>
+          <div className="px-1.5">
+            {recents.map((r) => (
+              <AgentRow
+                key={r.agent.id}
+                agent={r.agent}
+                viewer={user}
+                isSelected={activeAgentName === r.agent.name}
+                onClick={() => selectAgent(r.agent)}
+                activeWorkRoom={activeWorkRoomFor(r.agent)}
+                time={formatRelativeTime(r.lastModified)}
+              />
+            ))}
+          </div>
+        </>
+      )}
+
+      <Eyebrow>
+        Teams
+        <span className="font-mono text-[10.5px] text-ink-4 tabular-nums normal-case tracking-normal">
+          · {myAgents.length}
+        </span>
+      </Eyebrow>
+      <div className="px-1.5 space-y-0.5">
+        {sortedTeamNames.map((teamName) => (
+          <TeamGroup
+            key={teamName}
+            teamName={teamName}
+            members={teamBuckets.get(teamName) ?? []}
+            viewer={user}
+            activeAgentName={activeAgentName}
+            onSelectAgent={selectAgent}
+            activeWorkRoomFor={activeWorkRoomFor}
+          />
+        ))}
+        {untemmedAgents.map((agent) => (
+          <AgentRow
+            key={agent.id}
+            agent={agent}
+            viewer={user}
+            isSelected={activeAgentName === agent.name}
+            onClick={() => selectAgent(agent)}
+            activeWorkRoom={activeWorkRoomFor(agent)}
+          />
+        ))}
+        {!isLoading && myAgents.length === 0 && (
+          <div className="pl-3 pr-4 py-2 text-sidebar-text text-xs opacity-75">No agents yet</div>
+        )}
+      </div>
+
+      {retainedCount > 0 && (
+        <>
+          <Eyebrow>
+            Retained
+            <span className="font-mono text-[10.5px] text-ink-4 tabular-nums normal-case tracking-normal">
+              · {retainedCount}
+            </span>
+          </Eyebrow>
+          <div className="px-1.5 space-y-0.5">
+            {retainedHere.map((agent) => (
+              <AgentRow
+                key={agent.id}
+                agent={agent}
+                viewer={user}
+                isSelected={activeAgentName === agent.name}
+                onClick={() => selectAgent(agent)}
+                activeWorkRoom={activeWorkRoomFor(agent)}
+              />
+            ))}
+            {retainedHub.map((agent) => (
+              <HubAgentRow
+                key={agent.hub_agent_id}
+                agent={agent}
+                isSelected={activeHubAgentId === agent.hub_agent_id}
+                onClick={() => selectHubAgent(agent)}
+              />
+            ))}
+          </div>
+        </>
+      )}
+    </PanelShell>
+    {composeOpen && assistant && (
+      <DmComposeModal
+        mode="agent"
+        recipient={assistant}
+        onClose={() => setComposeOpen(false)}
+      />
+    )}
+    </>
+  )
+}

manigent/web/frontend/src/components/sidebar/AssistantHero.tsx

@@ -0,0 +1,48 @@
+import { Pin } from 'lucide-react'
+import { AgentStatus, type AgentCard, type User } from '../../types'
+import { displayName } from '../../utils/agentDisplay'
+import SidebarAvatar, { statusDotColor } from './SidebarAvatar'
+
+interface AssistantHeroProps {
+  assistant: AgentCard
+  viewer: User | null
+  isActive: boolean
+  onSelect: () => void
+}
+
+// The pinned coordinator card: a raised, gradient-filled hero that keeps the
+// user's assistant at the top of the roster instead of buried among agents.
+export default function AssistantHero({ assistant, viewer, isActive, onSelect }: AssistantHeroProps) {
+  const label = displayName(assistant, viewer)
+  const online = assistant.status === AgentStatus.ONLINE
+  return (
+    <button
+      onClick={onSelect}
+      className="w-full flex items-center gap-2.5 px-3 py-2.5 rounded-[11px] border text-left transition-all mx-2.5"
+      style={{
+        width: 'calc(100% - 20px)',
+        background: 'linear-gradient(180deg, #ffffff, var(--accent-softer))',
+        borderColor: isActive ? 'var(--accent)' : 'var(--accent-soft)',
+        boxShadow: isActive
+          ? '0 0 0 2px var(--accent-soft)'
+          : 'var(--shadow-1)',
+      }}
+      title={`DM with ${label}`}
+    >
+      <SidebarAvatar
+        name={label}
+        size={34}
+        dot
+        dotColor={statusDotColor(assistant.status)}
+        ringColor="#ffffff"
+      />
+      <span className="flex flex-col min-w-0 flex-1">
+        <span className="text-[13.5px] font-extrabold text-ink-1 truncate">{label}</span>
+        <span className="text-[11px] font-semibold" style={{ color: 'var(--accent-deep)' }}>
+          Your coordinator{online ? ' · online' : ''}
+        </span>
+      </span>
+      <Pin className="w-3.5 h-3.5 flex-shrink-0" style={{ color: 'var(--accent)' }} />
+    </button>
+  )
+}

manigent/web/frontend/src/components/sidebar/ChatroomItem.tsx

@@ -0,0 +1,48 @@
+import { useMatch, useNavigate } from 'react-router-dom'
+import { useActiveWorkStore, selectActiveParticipants } from '../../stores/activeWorkStore'
+import { confirmLeaveIfDirty } from '../../stores/unsavedGuard'
+import { getChatroomDisplayName } from '../../utils/chatroomDisplay'
+import ActiveWorkDot from './ActiveWorkDot'
+
+// Local view model for chatroom in sidebar
+interface ChatroomView {
+  chatroom_id: string
+  chatroom_name: string
+}
+
+interface ChatroomItemProps {
+  projectId: string
+  chatroom: ChatroomView
+  onNavigate?: () => void
+}
+
+export default function ChatroomItem({ projectId, chatroom, onNavigate }: ChatroomItemProps) {
+  const navigate = useNavigate()
+  const match = useMatch('/projects/:projectId/chatrooms/:chatroomName')
+  const isSelected =
+    match?.params.projectId === projectId &&
+    match?.params.chatroomName === chatroom.chatroom_name
+  const activeParticipants = useActiveWorkStore(selectActiveParticipants(projectId, chatroom.chatroom_name))
+  const isActive = activeParticipants.length > 0
+
+  const handleClick = () => {
+    if (!confirmLeaveIfDirty()) return
+    navigate(`/projects/${projectId}/chatrooms/${chatroom.chatroom_name}`)
+    onNavigate?.()
+  }
+
+  return (
+    <button
+      onClick={handleClick}
+      className={`
+        flex items-center gap-2 w-full pl-7 pr-4 py-1 text-left text-sm
+        hover:bg-sidebar-hover transition-colors
+        ${isSelected ? 'bg-sidebar-active text-sidebar-text-active font-bold' : 'text-sidebar-text'}
+      `}
+    >
+      <span className="mr-2 text-channel">#</span>
+      <span className="truncate">{getChatroomDisplayName(chatroom.chatroom_name)}</span>
+      {isActive && <ActiveWorkDot />}
+    </button>
+  )
+}

manigent/web/frontend/src/components/sidebar/CommandPalette.channelThreads.test.tsx

@@ -0,0 +1,76 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import type { AgentCard, Project } from '../../types'
+import type { ChannelThreadRow } from '../../api/endpoints/channels'
+
+/**
+ * ⌘K finds a channel thread by its contact's name, and labels it with who the
+ * person is and the channel — never the room name (`ch-…`).
+ */
+
+const navigate = vi.fn()
+const agents: AgentCard[] = [{ id: 'a-support', name: 'support', registered_by: 'u1' } as AgentCard]
+const projects: Project[] = [
+  { id: 'p-chan', name: 'ch-1a2b3c4d-deadbeef', display_name: 'Table booking', surface: 'frontdesk',
+    coordinator_id: 'a-support', created_by: 'u1', created_at: '', status: 'active' } as unknown as Project,
+]
+const rows = new Map<string, ChannelThreadRow>([['p-chan', {
+  project_id: 'p-chan', channel: 'whatsapp', connection_id: 'c', connection_enabled: true,
+  connection_removed: false, contact_id: 'k', contact_name: 'Mara Quintero', paused: false,
+}]])
+
+vi.mock('react-router-dom', () => ({ useNavigate: () => navigate }))
+vi.mock('../../hooks/useSops', () => ({ useSops: () => ({ sops: [], isLoading: false }) }))
+vi.mock('../../hooks/useTodos', () => ({ useTodos: () => ({ todos: [], isLoading: false }) }))
+vi.mock('../../hooks/useSopRecents', () => ({ useSopRecents: () => ({ recentIds: [], touch: vi.fn() }) }))
+vi.mock('../../hooks/useAgents', () => ({ useAgents: () => ({ data: agents }) }))
+vi.mock('../../hooks/useAgentAccess', () => ({ useRetainedAgents: () => ({ data: [] }) }))
+vi.mock('../../hooks/useTeamGroups', () => ({
+  useTeamGroups: () => ({ sortedTeamNames: [], teamBuckets: new Map() }),
+}))
+vi.mock('../../hooks/useChannelThreads', () => ({
+  useChannelThreads: () => ({ state: 'ready', byProject: rows }),
+}))
+vi.mock('../../hooks/useDmThreads', () => ({ useDmThreads: () => ({ groups: [] }) }))
+vi.mock('../../hooks/useProjects', () => ({
+  useUserProjects: () => ({ data: projects }),
+  useAllProjects: () => ({ data: [] }),
+}))
+vi.mock('../../stores/uiStore', () => ({
+  useUIStore: () => ({
+    expandedAgentTeams: new Set<string>(), toggleAgentTeam: vi.fn(), expandAgentTeam: vi.fn(),
+    setRailContext: vi.fn(), setProjectExpanded: vi.fn(),
+  }),
+}))
+vi.mock('../../stores/authStore', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>
+  return {
+    ...actual,
+    useAuthStore: (sel?: (s: Record<string, unknown>) => unknown) => {
+      const state = { user: { id: 'u1', username: 'manigent' }, sessions: [], activeUserId: 'u1' }
+      return sel ? sel(state) : state
+    },
+  }
+})
+vi.mock('../../hooks/useSwitchAccount', () => ({ useSwitchAccount: () => vi.fn() }))
+vi.mock('../../stores/deskStore', () => ({
+  useDeskStore: (sel: (s: Record<string, unknown>) => unknown) =>
+    sel({ requestSop: vi.fn(), requestTask: vi.fn(), requestRailTab: vi.fn() }),
+}))
+vi.mock('../../stores/unsavedGuard', () => ({ confirmLeaveIfDirty: () => true }))
+vi.mock('../../hooks/useMessageSearch', () => ({ useMessageSearch: () => ({ kind: 'idle' }) }))
+
+Element.prototype.scrollIntoView = vi.fn()
+
+const { default: CommandPalette } = await import('./CommandPalette')
+
+afterEach(cleanup)
+
+describe('CommandPalette — channel threads', () => {
+  it("searching the contact's name finds their thread, labelled with the person and the channel", () => {
+    render(<CommandPalette open onClose={vi.fn()} />)
+    fireEvent.change(screen.getByPlaceholderText(/Jump to a tab/), { target: { value: 'mara' } })
+    expect(screen.getByText('Mara Quintero · Table booking (WhatsApp)')).toBeTruthy()
+    expect(screen.queryByText(/ch-1a2b3c4d/)).toBeNull()
+  })
+})

manigent/web/frontend/src/components/sidebar/CommandPalette.reopen.test.tsx

@@ -0,0 +1,206 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import type { AgentCard, MessageSearchResponse, SearchHit } from '../../types'
+
+/**
+ * Review finding 3 — close → reopen must not flash the previous search.
+ *
+ * This lives in its own file because it needs the things CommandPalette.test.tsx
+ * deliberately stubs away: the REAL useMessageSearch (so the 150 ms debounce is
+ * real) and a REAL QueryClient that keeps its cache across the close (so the
+ * previous query's response is still there to be served synchronously). Neither
+ * of the two other palette suites can see this defect — they hand the component
+ * a `MessageSearchState` literal, so no sequence of opens and closes they drive
+ * can produce a stale one.
+ *
+ * The pre-fix mechanism, for whoever reads this after breaking it again:
+ * `query` was reset by an on-open EFFECT, and an effect runs after the render
+ * it is meant to correct. So the first render after ⌘K still had `invoice` in
+ * state, `useDebouncedValue` still held `invoice`, React Query answered the
+ * key `['message-search','invoice']` from cache, and the Messages section
+ * painted the old hits. Clearing the box then started a fresh 150 ms timer, so
+ * the hits stayed up under an empty input for the whole window. The fix is
+ * structural: the palette body unmounts on close, so there is no surviving
+ * state to be stale.
+ */
+
+const navigate = vi.fn()
+const onClose = vi.fn()
+const searchMessages = vi.fn()
+
+const HIT: SearchHit = {
+  message_id: 'm1',
+  project_id: 'p1',
+  project_name: 'chat-search-typeahead',
+  room_id: 'shared-context',
+  room_type: 'project',
+  room_label: 'shared-context',
+  ts: '2026-07-26T14:03:11.482000Z',
+  author_id: 'agent_1',
+  author_name: 'manigent-backend',
+  snippet: 'the invoice never arrived',
+  snippet_truncated_start: false,
+  snippet_truncated_end: false,
+  match_offsets: [[4, 11]],
+  score: 6.2,
+  deep_link: {
+    path: '/projects/p1/chatrooms/shared-context?msg=m1',
+    kind: 'project_room',
+    project_id: 'p1',
+    chatroom_name: 'shared-context',
+    agent_name: null,
+    message_id: 'm1',
+  },
+}
+
+function response(query: string, hits: SearchHit[]): MessageSearchResponse {
+  return {
+    query,
+    hits,
+    limit: 20,
+    offset: 0,
+    has_more: false,
+    next_offset: null,
+    indexing: false,
+    took_ms: 12,
+  }
+}
+
+vi.mock('react-router-dom', () => ({ useNavigate: () => navigate }))
+vi.mock('../../hooks/useSops', () => ({ useSops: () => ({ sops: [], isLoading: false }) }))
+vi.mock('../../hooks/useTodos', () => ({ useTodos: () => ({ todos: [], isLoading: false }) }))
+vi.mock('../../hooks/useSopRecents', () => ({
+  useSopRecents: () => ({ recentIds: [], touch: vi.fn() }),
+}))
+vi.mock('../../hooks/useAgents', () => ({ useAgents: () => ({ data: [] as AgentCard[] }) }))
+vi.mock('../../hooks/useAgentAccess', () => ({ useRetainedAgents: () => ({ data: [] }) }))
+vi.mock('../../hooks/useTeamGroups', () => ({
+  useTeamGroups: () => ({ sortedTeamNames: [], teamBuckets: new Map() }),
+}))
+vi.mock('../../hooks/useChannelThreads', () => ({
+  useChannelThreads: () => ({ state: 'ready', byProject: new Map() }),
+}))
+vi.mock('../../hooks/useDmThreads', () => ({ useDmThreads: () => ({ groups: [] }) }))
+vi.mock('../../hooks/useProjects', () => ({
+  useUserProjects: () => ({ data: [] }),
+  useAllProjects: () => ({ data: [] }),
+}))
+vi.mock('../../stores/uiStore', () => ({
+  useUIStore: () => ({
+    expandedAgentTeams: new Set<string>(),
+    toggleAgentTeam: vi.fn(),
+    expandAgentTeam: vi.fn(),
+    setRailContext: vi.fn(),
+    setProjectExpanded: vi.fn(),
+  }),
+}))
+vi.mock('../../stores/authStore', () => ({
+  useAuthStore: (sel?: (s: Record<string, unknown>) => unknown) => {
+    const state = { user: { id: 'u1', username: 'ana' } }
+    return sel ? sel(state) : state
+  },
+}))
+vi.mock('../../stores/deskStore', () => ({
+  useDeskStore: (sel: (s: Record<string, () => void>) => unknown) =>
+    sel({ requestSop: vi.fn(), requestTask: vi.fn(), requestRailTab: vi.fn() }),
+}))
+vi.mock('../../stores/unsavedGuard', () => ({ confirmLeaveIfDirty: () => true }))
+
+// The ONE thing stubbed on the search path: the HTTP call. Everything above it
+// — debounce, query key, cache, the `data.query === debounced` guard — is real.
+vi.mock('../../api/endpoints', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../api/endpoints')>()
+  return { ...actual, searchMessages: (...args: unknown[]) => searchMessages(...args) }
+})
+
+Element.prototype.scrollIntoView = vi.fn()
+
+const { default: CommandPalette } = await import('./CommandPalette')
+
+// One client for the whole sequence: the close must NOT throw the cache away,
+// or the test would pass for the wrong reason.
+let client: QueryClient
+
+function paletteAt(open: boolean) {
+  return (
+    <QueryClientProvider client={client}>
+      <CommandPalette open={open} onClose={onClose} />
+    </QueryClientProvider>
+  )
+}
+
+const input = () => screen.queryByPlaceholderText(/Jump to a tab/) as HTMLInputElement | null
+
+describe('CommandPalette — reopening after a search', () => {
+  beforeEach(() => {
+    navigate.mockReset()
+    onClose.mockReset()
+    searchMessages.mockReset()
+    searchMessages.mockImplementation(async (params: { q: string }) =>
+      response(params.q, [HIT]),
+    )
+    client = new QueryClient({
+      // Mirrors src/queryClient.ts — the cache retention that makes the stale
+      // render possible is the production setting, not a test artefact.
+      defaultOptions: { queries: { staleTime: 30000, retry: 1 } },
+    })
+    vi.useFakeTimers({ shouldAdvanceTime: true })
+  })
+  afterEach(() => {
+    vi.useRealTimers()
+    cleanup()
+  })
+
+  it('shows no trace of the previous query on reopen', async () => {
+    const { rerender } = render(paletteAt(true))
+
+    fireEvent.change(input()!, { target: { value: 'invoice' } })
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(200) // past the 150 ms debounce
+    })
+    await waitFor(() => expect(screen.getByText(/never arrived/)).toBeTruthy())
+    expect(searchMessages).toHaveBeenCalledTimes(1)
+
+    // Esc / click-away.
+    rerender(paletteAt(false))
+    expect(input()).toBeNull()
+    // The response is still cached — this is the retention the defect needs.
+    expect(client.getQueryData(['message-search', 'invoice'])).toBeTruthy()
+
+    // ⌘K. No timers advanced and nothing awaited: this assertion is the FIRST
+    // paint after reopening, which is the frame the defect lived in.
+    rerender(paletteAt(true))
+    expect(input()!.value).toBe('')
+    expect(screen.queryByText(/never arrived/)).toBeNull()
+    expect(document.querySelector('mark')).toBeNull()
+
+    // ...and still nothing once the old debounce window would have expired.
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(400)
+    })
+    expect(screen.queryByText(/never arrived/)).toBeNull()
+    // An empty box searches for nothing: no second request went out either.
+    expect(searchMessages).toHaveBeenCalledTimes(1)
+  })
+
+  it('searches again normally once the reopened palette is typed into', async () => {
+    // The fix must not cost the feature: a fresh mount still searches, and it
+    // may legitimately serve the same cached response for the same query.
+    const { rerender } = render(paletteAt(true))
+    fireEvent.change(input()!, { target: { value: 'invoice' } })
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(200)
+    })
+    await waitFor(() => expect(screen.getByText(/never arrived/)).toBeTruthy())
+
+    rerender(paletteAt(false))
+    rerender(paletteAt(true))
+
+    fireEvent.change(input()!, { target: { value: 'invoice' } })
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(200)
+    })
+    await waitFor(() => expect(screen.getByText(/never arrived/)).toBeTruthy())
+  })
+})