feat(desktop): reconcile live tool events, polish thread chrome, harden boot

- chat-messages: match tool rows by overlapping query/context/preview values so preview-first `tool.progress` rows reliably adopt later stable-id `tool.start` payloads instead of spawning ghost rows or mis-merging parallel same-name calls; preserve prior args/result across phases. - tui_gateway: emit full args + parsed result on `tool.start` / `tool.complete`, drop redundant `tool.started` re-emit from `tool.progress`. - electron/main: prefer SOURCE_REPO_ROOT before PATH `hermes` in dev so local backend edits actually run; split hardening helpers into `electron/hardening.cjs` with tests. - thread/tool UI: one-shot enter animation keyed by stable ids, braille spinner for running rows, Cursor-like disclosure rows, drill-down + duration/count formatting via new tool-fallback-model. - composer: extract `text-utils`, drop liquid-glass overrides. - right-rail: split preview-pane into preview-console / preview-file. - runtime: incremental external-store runtime + runtime-readiness gate; onboarding store + tests; route-resume hook test. - regression tests for live tool reconciliation (parallel tools, id-less progress, preview-first rows, structured args/results).
2026-05-11 21:38:47 -04:00
parent fdf73f0adf
commit d208f2c2c0
64 changed files with 5614 additions and 2703 deletions
@@ -65,7 +65,9 @@ const STREAM_DELTA_FLUSH_MS = 16
 // Anonymous progress events that carry todos but no name still belong to the
 // todo stream; named todo events are obviously routed there too.
 function toTodoPayload(payload: GatewayEventPayload | undefined): GatewayEventPayload | undefined {
-  if (!payload) {return undefined}
+  if (!payload) {
+    return undefined
+  }
  const isTodo = payload.name === 'todo' || (!payload.name && Object.hasOwn(payload, 'todos'))

  return isTodo ? { ...payload, name: 'todo', tool_id: payload.tool_id || 'todo-live' } : undefined
@@ -561,7 +563,9 @@ export function useMessageStream({
          setCurrentUsage(current => ({ ...current, ...payload.usage }))
        }
      } else if (event.type === 'tool.start' || event.type === 'tool.progress' || event.type === 'tool.generating') {
-        if (!sessionId) {return}
+        if (!sessionId) {
+          return
+        }
        flushQueuedDeltas(sessionId)
        upsertToolCall(sessionId, toTodoPayload(payload) ?? payload, 'running')
      } else if (event.type === 'tool.complete') {
@@ -46,19 +46,12 @@ function blobToDataUrl(blob: Blob): Promise<string> {
  })
 }

-interface SetupStatus {
-  provider_configured?: boolean
-}
-
-interface RuntimeCheck {
-  error?: string
-  ok?: boolean
-}
-
 function isProviderSetupError(error: unknown) {
  const message = error instanceof Error ? error.message : String(error)

-  return /No inference provider configured|OPENROUTER_API_KEY|OPENAI_API_KEY|ANTHROPIC_API_KEY|set an API key/i.test(message)
+  return /No inference provider configured|OPENROUTER_API_KEY|OPENAI_API_KEY|ANTHROPIC_API_KEY|set an API key/i.test(
+    message
+  )
 }

 interface PromptActionsOptions {
@@ -197,25 +190,24 @@ export function usePromptActions({
    async (rawText: string) => {
      const visibleText = rawText.trim()
      const attachments = $composerAttachments.get()
-
      const contextRefs = attachments
-        .map(attachment => attachment.refText)
+        .map(a => a.refText)
        .filter(Boolean)
        .join('\n')
-
-      const hasImageAttachment = attachments.some(attachment => attachment.kind === 'image')
-      const attachmentRefs = attachments.map(attachmentDisplayText).filter((ref): ref is string => Boolean(ref))
+      const hasImage = attachments.some(a => a.kind === 'image')
+      const attachmentRefs = attachments.map(attachmentDisplayText).filter((r): r is string => Boolean(r))

      const text =
-        [contextRefs, visibleText].filter(Boolean).join('\n\n') ||
-        (hasImageAttachment ? 'What do you see in this image?' : '')
+        [contextRefs, visibleText].filter(Boolean).join('\n\n') || (hasImage ? 'What do you see in this image?' : '')

      if (!text || busyRef.current) {
        return
      }

+      const optimisticId = `user-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+
      const userMessage: ChatMessage = {
-        id: `user-${Date.now()}`,
+        id: optimisticId,
        role: 'user',
        parts: [textPart(visibleText || (attachmentRefs.length ? '' : attachments.map(a => a.label).join(', ')))],
        attachmentRefs
@@ -227,61 +219,80 @@ export function usePromptActions({
        setAwaitingResponse(false)
      }

+      // Idempotent optimistic insert — re-running with the resolved sessionId
+      // after createBackendSessionForSend just overwrites with the same id.
+      const seedOptimistic = (sid: string) =>
+        updateSessionState(
+          sid,
+          state => ({
+            ...state,
+            messages: state.messages.some(m => m.id === optimisticId)
+              ? state.messages
+              : [...state.messages, userMessage],
+            busy: true,
+            awaitingResponse: true,
+            pendingBranchGroup: null,
+            sawAssistantPayload: false,
+            interrupted: false
+          }),
+          selectedStoredSessionIdRef.current
+        )
+
+      const dropOptimistic = (sid: null | string) => {
+        if (!sid) {
+          setMessages(current => current.filter(m => m.id !== optimisticId))
+
+          return
+        }
+
+        updateSessionState(
+          sid,
+          state => ({
+            ...state,
+            messages: state.messages.filter(m => m.id !== optimisticId),
+            busy: false,
+            awaitingResponse: false,
+            pendingBranchGroup: null
+          }),
+          selectedStoredSessionIdRef.current
+        )
+      }
+
      busyRef.current = true
      setBusy(true)
      setAwaitingResponse(true)
      clearNotifications()

-      const [setup, runtime] = await Promise.all([
-        requestGateway<SetupStatus>('setup.status').catch(() => null),
-        requestGateway<RuntimeCheck>('setup.runtime_check').catch(() => null)
-      ])
+      let sessionId: null | string = activeSessionId

-      const runtimeReady = runtime?.ok !== undefined ? Boolean(runtime?.ok) : setup?.provider_configured !== false
-
-      if (!runtimeReady) {
-        releaseBusy()
-        requestDesktopOnboarding(
-          runtime?.error || 'Add a provider credential before sending your first message.'
-        )
-
-        return
+      if (sessionId) {
+        seedOptimistic(sessionId)
+      } else {
+        setMessages(current => [...current, userMessage])
      }

-      let sessionId = activeSessionId
-
      if (!sessionId) {
        try {
          sessionId = await createBackendSessionForSend()
        } catch (err) {
+          dropOptimistic(null)
          releaseBusy()
          notifyError(err, 'Session unavailable')

          return
        }
+
+        if (!sessionId) {
+          dropOptimistic(null)
+          releaseBusy()
+          notify({ kind: 'error', title: 'Session unavailable', message: 'Could not create a new session' })
+
+          return
+        }
+
+        seedOptimistic(sessionId)
      }

-      if (!sessionId) {
-        releaseBusy()
-        notify({ kind: 'error', title: 'Session unavailable', message: 'Could not create a new session' })
-
-        return
-      }
-
-      updateSessionState(
-        sessionId,
-        state => ({
-          ...state,
-          messages: [...state.messages, userMessage],
-          busy: true,
-          awaitingResponse: true,
-          pendingBranchGroup: null,
-          sawAssistantPayload: false,
-          interrupted: false
-        }),
-        selectedStoredSessionIdRef.current
-      )
-
      try {
        await syncImageAttachmentsForSubmit(sessionId, attachments)
        await requestGateway('prompt.submit', { session_id: sessionId, text })
@@ -0,0 +1,136 @@
+import { cleanup, render } from '@testing-library/react'
+import type { MutableRefObject } from 'react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { useRouteResume } from './use-route-resume'
+
+interface HarnessProps {
+  activeSessionId: null | string
+  activeSessionIdRef: MutableRefObject<null | string>
+  creatingSessionRef: MutableRefObject<boolean>
+  currentView: string
+  freshDraftReady: boolean
+  gatewayState: string
+  locationPathname: string
+  resumeSession: (sessionId: string, focus: boolean) => Promise<unknown>
+  routedSessionId: null | string
+  runtimeIdByStoredSessionIdRef: MutableRefObject<Map<string, string>>
+  selectedStoredSessionId: null | string
+  selectedStoredSessionIdRef: MutableRefObject<null | string>
+  startFreshSessionDraft: (focus: boolean) => unknown
+}
+
+function RouteResumeHarness(props: HarnessProps) {
+  useRouteResume(props)
+
+  return null
+}
+
+describe('useRouteResume', () => {
+  afterEach(() => {
+    cleanup()
+    vi.restoreAllMocks()
+  })
+
+  it('does not re-resume the old session during a /:sid -> /new transition', () => {
+    const resumeSession = vi.fn(async () => undefined)
+    const startFreshSessionDraft = vi.fn()
+    const activeSessionIdRef: MutableRefObject<null | string> = { current: 'runtime-1' }
+    const creatingSessionRef = { current: false }
+    const runtimeIdByStoredSessionIdRef = { current: new Map([['session-1', 'runtime-1']]) }
+    const selectedStoredSessionIdRef: MutableRefObject<null | string> = { current: 'session-1' }
+
+    const { rerender } = render(
+      <RouteResumeHarness
+        activeSessionId="runtime-1"
+        activeSessionIdRef={activeSessionIdRef}
+        creatingSessionRef={creatingSessionRef}
+        currentView="chat"
+        freshDraftReady={false}
+        gatewayState="open"
+        locationPathname="/session-1"
+        resumeSession={resumeSession}
+        routedSessionId="session-1"
+        runtimeIdByStoredSessionIdRef={runtimeIdByStoredSessionIdRef}
+        selectedStoredSessionId="session-1"
+        selectedStoredSessionIdRef={selectedStoredSessionIdRef}
+        startFreshSessionDraft={startFreshSessionDraft}
+      />
+    )
+
+    expect(resumeSession).not.toHaveBeenCalled()
+
+    // Simulate startFreshSessionDraft state updates landing before route update.
+    activeSessionIdRef.current = null
+    selectedStoredSessionIdRef.current = null
+    rerender(
+      <RouteResumeHarness
+        activeSessionId={null}
+        activeSessionIdRef={activeSessionIdRef}
+        creatingSessionRef={creatingSessionRef}
+        currentView="chat"
+        freshDraftReady
+        gatewayState="open"
+        locationPathname="/session-1"
+        resumeSession={resumeSession}
+        routedSessionId="session-1"
+        runtimeIdByStoredSessionIdRef={runtimeIdByStoredSessionIdRef}
+        selectedStoredSessionId={null}
+        selectedStoredSessionIdRef={selectedStoredSessionIdRef}
+        startFreshSessionDraft={startFreshSessionDraft}
+      />
+    )
+
+    expect(resumeSession).not.toHaveBeenCalled()
+  })
+
+  it('resumes when pathname changes to a routed session', () => {
+    const resumeSession = vi.fn(async () => undefined)
+    const startFreshSessionDraft = vi.fn()
+    const activeSessionIdRef: MutableRefObject<null | string> = { current: null }
+    const creatingSessionRef = { current: false }
+    const runtimeIdByStoredSessionIdRef = { current: new Map() }
+    const selectedStoredSessionIdRef: MutableRefObject<null | string> = { current: null }
+
+    const { rerender } = render(
+      <RouteResumeHarness
+        activeSessionId={null}
+        activeSessionIdRef={activeSessionIdRef}
+        creatingSessionRef={creatingSessionRef}
+        currentView="chat"
+        freshDraftReady
+        gatewayState="open"
+        locationPathname="/"
+        resumeSession={resumeSession}
+        routedSessionId={null}
+        runtimeIdByStoredSessionIdRef={runtimeIdByStoredSessionIdRef}
+        selectedStoredSessionId={null}
+        selectedStoredSessionIdRef={selectedStoredSessionIdRef}
+        startFreshSessionDraft={startFreshSessionDraft}
+      />
+    )
+
+    expect(resumeSession).not.toHaveBeenCalled()
+
+    rerender(
+      <RouteResumeHarness
+        activeSessionId={null}
+        activeSessionIdRef={activeSessionIdRef}
+        creatingSessionRef={creatingSessionRef}
+        currentView="chat"
+        freshDraftReady
+        gatewayState="open"
+        locationPathname="/session-2"
+        resumeSession={resumeSession}
+        routedSessionId="session-2"
+        runtimeIdByStoredSessionIdRef={runtimeIdByStoredSessionIdRef}
+        selectedStoredSessionId={null}
+        selectedStoredSessionIdRef={selectedStoredSessionIdRef}
+        startFreshSessionDraft={startFreshSessionDraft}
+      />
+    )
+
+    expect(resumeSession).toHaveBeenCalledTimes(1)
+    expect(resumeSession).toHaveBeenCalledWith('session-2', true)
+  })
+})
@@ -1,4 +1,4 @@
-import { type MutableRefObject, useEffect } from 'react'
+import { type MutableRefObject, useEffect, useRef } from 'react'

 import { isNewChatRoute } from '@/app/routes'

@@ -55,8 +55,17 @@ export function useRouteResume({
  selectedStoredSessionIdRef,
  startFreshSessionDraft
 }: RouteResumeOptions) {
+  const lastPathnameRef = useRef<string | null>(null)
+  const wasGatewayOpenRef = useRef(false)
+
  useEffect(() => {
-    if (currentView !== 'chat' || gatewayState !== 'open') {
+    const gatewayOpen = gatewayState === 'open'
+    const pathnameChanged = lastPathnameRef.current !== locationPathname
+    const gatewayBecameOpen = !wasGatewayOpenRef.current && gatewayOpen
+    lastPathnameRef.current = locationPathname
+    wasGatewayOpenRef.current = gatewayOpen
+
+    if (currentView !== 'chat' || !gatewayOpen) {
      return
    }

@@ -68,7 +77,12 @@ export function useRouteResume({
        Boolean(cachedRuntime) &&
        cachedRuntime === activeSessionIdRef.current

-      if (!alreadyActive) {
+      // Resume only when the route meaningfully changed (or gateway just opened).
+      // This avoids a transient /:sid re-resume during "new chat" state clears
+      // before the pathname updates from /:sid -> /.
+      const shouldResume = pathnameChanged || gatewayBecameOpen
+
+      if (!alreadyActive && shouldResume && !creatingSessionRef.current) {
        void resumeSession(routedSessionId, true)
      }