diff --git a/app/layouts/dashboard.vue b/app/layouts/dashboard.vue
index 7959129c5..692c19f66 100644
--- a/app/layouts/dashboard.vue
+++ b/app/layouts/dashboard.vue
@@ -9,15 +9,10 @@ const { renameChat, deleteChat, groups, refresh: refreshChats } = useChats()
 
 const sidebarOpen = ref(false)
 
-await useFetch<ChatListItem[]>('/api/chats', {
-  key: 'chats',
-  default: () => []
-})
-
 watch(loggedIn, () => {
   refreshChats()
   sidebarOpen.value = false
-})
+}, { immediate: true })
 
 const items = computed(() => groups.value?.flatMap(group => [
   { label: group.label, type: 'label' as const },
diff --git a/layers/nuxi/app/components/agent/AgentChatBody.vue b/layers/nuxi/app/components/agent/AgentChatBody.vue
new file mode 100644
index 000000000..ab26831c9
--- /dev/null
+++ b/layers/nuxi/app/components/agent/AgentChatBody.vue
@@ -0,0 +1,105 @@
+<script setup lang="ts">
+import type { UIMessage } from 'ai'
+import type { AgentChatHandle } from '../../composables/eve/types'
+
+const input = defineModel<string>('input', { required: true })
+
+const props = withDefaults(defineProps<{
+  chat: AgentChatHandle
+  chatId: string
+  prompt: { pasteAttachments: TextPasteAttachment[], canSubmit: boolean }
+  usage?: { used: number, remaining: number, limit: number }
+  rateLimitReached?: boolean
+  compact?: boolean
+  showFaqEmpty?: boolean
+  faqQuestions?: FaqCategory[]
+  showActions?: boolean
+  showUserTimestamps?: boolean
+  spacingOffset?: number
+  getVote: (messageId: string) => boolean | null
+  variant?: 'subtle' | 'naked'
+  size?: 'sm' | 'md'
+  promptClass?: string
+  promptUi?: Record<string, string>
+  submitDisabled?: boolean
+  rateLimitVariant?: 'sticky' | 'footer'
+  loginHintBar?: boolean
+}>(), {
+  compact: false,
+  showFaqEmpty: false,
+  faqQuestions: () => [],
+  showActions: true,
+  showUserTimestamps: false,
+  spacingOffset: 0,
+  variant: 'subtle',
+  rateLimitVariant: 'sticky',
+  loginHintBar: false
+})
+
+const emit = defineEmits<{
+  submit: []
+  paste: [event: ClipboardEvent]
+  removeAttachment: [index: number]
+  restoreAttachment: [index: number]
+  vote: [message: UIMessage, isUpvoted: boolean]
+  askQuestion: [question: string]
+}>()
+
+const { loggedIn } = useUserSession()
+const showLoginHint = computed(() => props.loginHintBar || !loggedIn.value)
+
+const promptRef = useTemplateRef('promptRef')
+defineExpose({
+  focus: () => promptRef.value?.focus()
+})
+</script>
+
+<template>
+  <AgentChatMessages
+    :chat="chat"
+    :chat-id="chatId"
+    :compact="compact"
+    :show-faq-empty="showFaqEmpty"
+    :faq-questions="faqQuestions"
+    :show-actions="showActions"
+    :show-user-timestamps="showUserTimestamps"
+    :spacing-offset="spacingOffset"
+    :get-vote="getVote"
+    :class="compact ? 'flex flex-col gap-4' : 'flex-1 pt-4 pb-4 sm:pb-6'"
+    @ask-question="emit('askQuestion', $event)"
+    @vote="(message, isUpvoted) => emit('vote', message, isUpvoted)"
+  />
+
+  <AgentRateLimitBanner v-if="rateLimitReached" :variant="rateLimitVariant" />
+
+  <div
+    v-else
+    class="flex flex-col gap-1.5"
+    :class="rateLimitVariant === 'sticky' ? 'sticky bottom-0 z-10 bg-default' : ''"
+  >
+    <slot name="before-prompt" />
+
+    <AgentLoginHint v-if="showLoginHint" :bar="loginHintBar" />
+
+    <AgentChatPrompt
+      ref="promptRef"
+      v-model="input"
+      v-bind="prompt"
+      :chat="chat"
+      :usage="usage"
+      :variant="variant"
+      :size="size"
+      :submit-disabled="submitDisabled"
+      :class="promptClass"
+      :ui="promptUi"
+      @submit="emit('submit')"
+      @paste="emit('paste', $event)"
+      @remove-attachment="emit('removeAttachment', $event)"
+      @restore-attachment="emit('restoreAttachment', $event)"
+    >
+      <template v-if="$slots['prompt-footer-left']" #footer-left>
+        <slot name="prompt-footer-left" />
+      </template>
+    </AgentChatPrompt>
+  </div>
+</template>
diff --git a/layers/nuxi/app/components/agent/AgentChatMessages.vue b/layers/nuxi/app/components/agent/AgentChatMessages.vue
index b74564206..fc61db484 100644
--- a/layers/nuxi/app/components/agent/AgentChatMessages.vue
+++ b/layers/nuxi/app/components/agent/AgentChatMessages.vue
@@ -30,6 +30,16 @@ const emit = defineEmits<{
 const display = computed(() =>
   resolveChatDisplayState(props.chat.messages, props.chat.status)
 )
+
+function isAssistantPending(message: UIMessage): boolean {
+  if (message.role !== 'assistant') return false
+
+  const { status, messages } = props.chat
+  if (status !== 'submitted' && status !== 'streaming') return false
+
+  const last = messages.at(-1)
+  return last?.role === 'assistant' && message.id === last.id
+}
 </script>
 
 <template>
@@ -59,7 +69,7 @@ const display = computed(() =>
           v-if="message.role === 'assistant'"
           :message="message"
           :vote="getVote(message.id)"
-          :streaming="chat.status === 'streaming' && message.id === chat.messages.at(-1)?.id"
+          :streaming="isAssistantPending(message)"
           :chat-id="chatId"
           :can-regenerate="message.id === chat.messages.at(-1)?.id && chat.status === 'ready'"
           @vote="(msg, isUpvoted) => emit('vote', msg, isUpvoted)"
diff --git a/layers/nuxi/app/components/agent/AgentPanel.vue b/layers/nuxi/app/components/agent/AgentPanel.vue
index 53cb1ff89..6930875f7 100644
--- a/layers/nuxi/app/components/agent/AgentPanel.vue
+++ b/layers/nuxi/app/components/agent/AgentPanel.vue
@@ -14,15 +14,16 @@ const {
 const { chatList } = useChats()
 const { loggedIn } = useUserSession()
 
-type ActiveChat = { id: string, messages: UIMessage[] }
-const active = shallowRef<ActiveChat>({ id: crypto.randomUUID(), messages: [] })
+type ActiveChat = { id: string, messages: UIMessage[], state: ChatEveState | null }
+const active = shallowRef<ActiveChat>({ id: crypto.randomUUID(), messages: [], state: null })
 const chatId = computed(() => active.value.id)
 const initialMessages = computed(() => active.value.messages)
+const initialState = computed(() => active.value.state)
 let loadToken = 0
 
 function startNewChat() {
   loadToken++
-  active.value = { id: crypto.randomUUID(), messages: [] }
+  active.value = { id: crypto.randomUUID(), messages: [], state: null }
 }
 
 async function setActiveChat(id: string) {
@@ -31,10 +32,10 @@ async function setActiveChat(id: string) {
   try {
     const data = await $fetch<ChatDetail>(`/api/chats/${id}`)
     if (token !== loadToken) return
-    active.value = { id, messages: toUIMessages(data.messages ?? []) }
+    active.value = { id, messages: dbRowsToUIMessages(data.messages ?? []), state: data.state ?? null }
   } catch {
     if (token === loadToken) {
-      active.value = { id: crypto.randomUUID(), messages: [] }
+      active.value = { id: crypto.randomUUID(), messages: [], state: null }
     }
   }
 }
@@ -116,6 +117,11 @@ defineShortcuts({
       </UTooltip>
     </template>
 
-    <AgentPanelChat :key="chatId" :chat-id="chatId" :initial-messages="initialMessages" />
+    <AgentPanelChat
+      :key="chatId"
+      :chat-id="chatId"
+      :initial-messages="initialMessages"
+      :initial-state="initialState"
+    />
   </AgentPanelShell>
 </template>
diff --git a/layers/nuxi/app/components/agent/AgentPanelChat.vue b/layers/nuxi/app/components/agent/AgentPanelChat.vue
index 2341d8d9d..c8a290ecb 100644
--- a/layers/nuxi/app/components/agent/AgentPanelChat.vue
+++ b/layers/nuxi/app/components/agent/AgentPanelChat.vue
@@ -1,9 +1,11 @@
 <script setup lang="ts">
 import type { UIMessage } from 'ai'
+import { useNuxiChat } from '../../composables/useNuxiChat'
 
 const props = defineProps<{
   chatId: string
   initialMessages?: UIMessage[]
+  initialState?: ChatEveState | null
 }>()
 
 const {
@@ -29,12 +31,18 @@ const {
   getVote,
   vote,
   askQuestion,
-  send
-} = useAgentChat({
+  onSubmit,
+  handlePaste,
+  removeAttachment,
+  restoreToInput
+} = useNuxiChat({
   chatId: props.chatId,
   initialMessages: props.initialMessages,
+  initialState: props.initialState,
   source: 'prompt',
   withPageContext: 'when-enabled',
+  consumePendingPrompt,
+  consumePendingMessageParts: () => null,
   onFinish: () => {
     if (loggedIn.value) refreshChats()
   }
@@ -47,8 +55,6 @@ watch(() => chat.status, (status) => {
   else nuxiMood.value = 'idle'
 }, { immediate: true })
 
-// The docked sidebar keeps its content mounted when closed, so `autofocus`
-// only fires once. Refocus the prompt each time the panel reopens.
 const promptRef = useTemplateRef('promptRef')
 watch(isOpen, (value) => {
   if (value) {
@@ -57,11 +63,6 @@ watch(isOpen, (value) => {
     })
   }
 })
-
-onMounted(() => {
-  const pendingPrompt = consumePendingPrompt()
-  if (pendingPrompt) send(pendingPrompt)
-})
 </script>
 
 <template>
@@ -81,85 +82,92 @@ onMounted(() => {
     </div>
 
     <div class="flex w-full shrink-0 flex-col border-y border-default">
-      <AgentLoginHint v-if="!loggedIn" bar />
-
-      <Transition
-        enter-active-class="transition duration-200 ease-out"
-        leave-active-class="transition duration-150 ease-in"
-        enter-from-class="opacity-0"
-        enter-to-class="opacity-100"
-        leave-from-class="opacity-100"
-        leave-to-class="opacity-0"
-      >
-        <div
-          v-if="pageContextEnabled"
-          class="flex items-center gap-2 border-b border-default px-4 py-2.5"
-        >
-          <div class="min-w-0 flex-1 flex items-center gap-1.5 text-xs">
-            <span class="shrink-0 text-dimmed">Agent is using</span>
-            <img
-              src="/icon.png"
-              alt=""
-              class="size-3.5 shrink-0 rounded-sm opacity-90"
-            >
-            <span
-              class="min-w-0 truncate font-medium text-highlighted"
-              :title="currentPage ?? undefined"
-            >{{ contextPathLabel }}</span>
-          </div>
-          <UTooltip text="Stop using this page as context" :kbds="['tab']">
-            <UButton
-              icon="i-lucide-x"
-              color="neutral"
-              variant="ghost"
-              size="sm"
-              class="shrink-0 text-dimmed hover:text-default -me-1"
-              aria-label="Stop using this page as context"
-              @click="pageContextDismissed = true"
-            />
-          </UTooltip>
-        </div>
-      </Transition>
-
       <AgentRateLimitBanner v-if="rateLimitReached" variant="footer" />
 
-      <AgentChatPrompt
-        v-else
-        ref="promptRef"
-        v-model="input"
-        v-bind="prompt"
-        :chat="chat"
-        :usage="usage"
-        variant="naked"
-        size="sm"
-        :submit-disabled="chat.status === 'ready' && !(prompt.canSubmit ?? input.trim())"
-        :ui="{ root: 'px-4 pb-2', body: 'px-0', base: 'px-0 rounded-none', header: 'px-0 pt-2 pb-0 gap-1.5 flex flex-wrap items-start', footer: 'px-0 items-baseline' }"
-      >
-        <template #footer-left>
-          <div class="flex items-center gap-2 text-xs text-dimmed">
-            <UTooltip v-if="currentPage && !pageContextEnabled" text="Use page as context" :kbds="['tab']">
+      <div v-else class="flex flex-col gap-1.5">
+        <Transition
+          enter-active-class="transition duration-200 ease-out"
+          leave-active-class="transition duration-150 ease-in"
+          enter-from-class="opacity-0"
+          enter-to-class="opacity-100"
+          leave-from-class="opacity-100"
+          leave-to-class="opacity-0"
+        >
+          <div
+            v-if="pageContextEnabled"
+            class="flex items-center gap-2 border-b border-default px-4 py-2.5"
+          >
+            <div class="min-w-0 flex-1 flex items-center gap-1.5 text-xs">
+              <span class="shrink-0 text-dimmed">Agent is using</span>
+              <img src="/icon.png" alt="" class="size-3.5 shrink-0 rounded-sm opacity-90">
+              <span
+                class="min-w-0 truncate font-medium text-highlighted"
+                :title="currentPage ?? undefined"
+              >{{ contextPathLabel }}</span>
+            </div>
+            <UTooltip text="Stop using this page as context" :kbds="['tab']">
               <UButton
-                type="button"
-                icon="i-lucide-file-plus"
+                icon="i-lucide-x"
                 color="neutral"
                 variant="ghost"
                 size="sm"
-                class="-my-1 -mx-1.5 text-dimmed hover:text-default"
-                aria-label="Use page as context"
-                @click.stop="pageContextDismissed = false"
+                class="shrink-0 text-dimmed hover:text-default -me-1"
+                aria-label="Stop using this page as context"
+                @click="pageContextDismissed = true"
               />
             </UTooltip>
+          </div>
+        </Transition>
 
-            <USeparator v-if="currentPage && !pageContextEnabled" orientation="vertical" class="h-4" />
+        <AgentLoginHint v-if="!loggedIn" bar />
 
-            <UTooltip v-if="usage" text="Daily messages remaining">
-              <span :class="usage.remaining <= 5 ? 'text-warning' : ''">
-                {{ usage.remaining }}/{{ usage.limit }}
-              </span>
-            </UTooltip>
-          </div>
-        </template>
-      </AgentChatPrompt>
+        <AgentChatPrompt
+          ref="promptRef"
+          v-model="input"
+          v-bind="prompt"
+          :chat="chat"
+          :usage="usage"
+          variant="naked"
+          size="sm"
+          :submit-disabled="chat.status === 'ready' && !(prompt.canSubmit ?? input.trim())"
+          :ui="{
+            root: 'px-4 pb-2',
+            body: 'px-0',
+            base: 'px-0 rounded-none',
+            header: 'px-0 pt-2 pb-0 gap-1.5 flex flex-wrap items-start',
+            footer: 'px-0 items-baseline'
+          }"
+          @submit="onSubmit"
+          @paste="handlePaste"
+          @remove-attachment="removeAttachment"
+          @restore-attachment="restoreToInput"
+        >
+          <template #footer-left>
+            <div class="flex items-center gap-2 text-xs text-dimmed">
+              <UTooltip v-if="currentPage && !pageContextEnabled" text="Use page as context" :kbds="['tab']">
+                <UButton
+                  type="button"
+                  icon="i-lucide-file-plus"
+                  color="neutral"
+                  variant="ghost"
+                  size="sm"
+                  class="-my-1 -mx-1.5 text-dimmed hover:text-default"
+                  aria-label="Use page as context"
+                  @click.stop="pageContextDismissed = false"
+                />
+              </UTooltip>
+
+              <USeparator v-if="currentPage && !pageContextEnabled" orientation="vertical" class="h-4" />
+
+              <UTooltip v-if="usage" text="Daily messages remaining">
+                <span :class="usage.remaining <= 5 ? 'text-warning' : ''">
+                  {{ usage.remaining }}/{{ usage.limit }}
+                </span>
+              </UTooltip>
+            </div>
+          </template>
+        </AgentChatPrompt>
+      </div>
     </div>
   </div>
 </template>
diff --git a/layers/nuxi/app/composables/eve/adapter.ts b/layers/nuxi/app/composables/eve/adapter.ts
index 6d2283999..64c79ed95 100644
--- a/layers/nuxi/app/composables/eve/adapter.ts
+++ b/layers/nuxi/app/composables/eve/adapter.ts
@@ -2,7 +2,7 @@ import type { UIMessage } from 'ai'
 import type { EveMessage } from 'eve/vue'
 import type { AgentChatStatus } from './types'
 
-export function toUIMessages(messages: readonly EveMessage[]): UIMessage[] {
+export function eveMessagesToUIMessages(messages: readonly EveMessage[]): UIMessage[] {
   return [...messages] as UIMessage[]
 }
 
diff --git a/layers/nuxi/app/composables/eve/init.ts b/layers/nuxi/app/composables/eve/init.ts
deleted file mode 100644
index 9d89d6564..000000000
--- a/layers/nuxi/app/composables/eve/init.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import type { UseEveAgentReturn, EveMessageData, UseEveAgentSnapshot } from 'eve/vue'
-import type { ChatSessionOptions } from './types'
-
-const clientAgentsByChatId = import.meta.client
-  ? new Map<string, UseEveAgentReturn<EveMessageData>>()
-  : null
-
-export interface EveAgentBindingOptions extends ChatSessionOptions {
-  headers?: () => Record<string, string>
-  onFinish?: (snapshot: UseEveAgentSnapshot<EveMessageData>) => void | Promise<void>
-}
-
-function createAgent(chatId: string, options?: EveAgentBindingOptions) {
-  return useEveAgent({
-    initialSession: options?.initialSession ?? {
-      continuationToken: chatId,
-      streamIndex: 0
-    },
-    initialEvents: options?.initialEvents as never,
-    headers: options?.headers,
-    onFinish: (snapshot) => {
-      void options?.onFinish?.(snapshot)
-    }
-  })
-}
-
-export function getOrCreateEveAgent(chatId: string, options?: EveAgentBindingOptions) {
-  if (import.meta.server) {
-    const state = useState<UseEveAgentReturn<EveMessageData> | undefined>(`eve-agent:${chatId}`)
-    if (!state.value) {
-      state.value = createAgent(chatId, options)
-    }
-    return state.value
-  }
-
-  let agent = clientAgentsByChatId!.get(chatId)
-  if (!agent) {
-    agent = createAgent(chatId, options)
-    clientAgentsByChatId!.set(chatId, agent)
-  }
-  return agent
-}
-
-export function removeEveAgent(chatId: string) {
-  if (import.meta.server) {
-    useState<UseEveAgentReturn<EveMessageData> | undefined>(`eve-agent:${chatId}`).value = undefined
-    return
-  }
-  clientAgentsByChatId?.delete(chatId)
-}
-
-export function getEveAgent(chatId: string) {
-  if (import.meta.server) {
-    return useState<UseEveAgentReturn<EveMessageData> | undefined>(`eve-agent:${chatId}`).value
-  }
-  return clientAgentsByChatId?.get(chatId)
-}
diff --git a/layers/nuxi/app/composables/eve/session.ts b/layers/nuxi/app/composables/eve/session.ts
deleted file mode 100644
index 2e5ec1de8..000000000
--- a/layers/nuxi/app/composables/eve/session.ts
+++ /dev/null
@@ -1,110 +0,0 @@
-import type { EveMessageData } from 'eve/vue'
-import type { FileUIPart, UIMessage } from 'ai'
-import type { MaybeRefOrGetter } from 'vue'
-import { computed, toValue } from 'vue'
-import type { AgentChatHandle } from './types'
-import type { EveAgentBindingOptions } from './init'
-import { toUIMessages } from './adapter'
-import { getOrCreateEveAgent } from './init'
-
-function lastUserMessage(data: EveMessageData) {
-  for (let index = data.messages.length - 1; index >= 0; index -= 1) {
-    const message = data.messages[index]
-    if (message?.role === 'user' && message.parts.length > 0) {
-      return message
-    }
-  }
-}
-
-async function sendUserParts(
-  agent: ReturnType<typeof getOrCreateEveAgent>,
-  parts: UIMessage['parts']
-) {
-  const text = parts
-    .filter((part): part is { type: 'text', text: string } => part.type === 'text')
-    .map(part => part.text)
-    .join('\n')
-    .trim()
-
-  const fileParts = parts.filter((part): part is FileUIPart => part.type === 'file')
-
-  if (fileParts.length && text) {
-    await agent.send({
-      message: [
-        { type: 'text', text },
-        ...fileParts.map(part => ({
-          type: 'file' as const,
-          data: part.url,
-          mediaType: part.mediaType,
-          filename: part.filename
-        }))
-      ]
-    })
-    return
-  }
-
-  if (fileParts.length) {
-    await agent.send({
-      message: fileParts.map(part => ({
-        type: 'file' as const,
-        data: part.url,
-        mediaType: part.mediaType,
-        filename: part.filename
-      }))
-    })
-    return
-  }
-
-  if (text) {
-    await agent.send({ message: text })
-  }
-}
-
-export function createEveChatSession(
-  chatId: MaybeRefOrGetter<string>,
-  options?: MaybeRefOrGetter<EveAgentBindingOptions | undefined>
-): AgentChatHandle & {
-  send: (input: string | { parts: UIMessage['parts'] }) => Promise<void>
-} {
-  const id = computed(() => toValue(chatId))
-  const resolvedOptions = computed(() => toValue(options))
-  const agent = computed(() => getOrCreateEveAgent(id.value, resolvedOptions.value))
-
-  const messages = computed(() => toUIMessages(agent.value.data.value.messages))
-  const status = computed(() => agent.value.status.value)
-  const error = computed(() => agent.value.error.value)
-
-  async function send(input: string | { parts: UIMessage['parts'] }) {
-    const parts = typeof input === 'string'
-      ? [{ type: 'text' as const, text: input }]
-      : input.parts
-
-    await sendUserParts(agent.value, parts)
-  }
-
-  function stop() {
-    agent.value.stop()
-  }
-
-  async function regenerate() {
-    if (status.value === 'submitted' || status.value === 'streaming') return
-    const message = lastUserMessage(agent.value.data.value)
-    if (!message) return
-    await sendUserParts(agent.value, message.parts as UIMessage['parts'])
-  }
-
-  return {
-    get messages() {
-      return messages.value
-    },
-    get status() {
-      return status.value
-    },
-    get error() {
-      return error.value
-    },
-    send,
-    stop,
-    regenerate
-  }
-}
diff --git a/layers/nuxi/app/composables/eve/thread-state.ts b/layers/nuxi/app/composables/eve/thread-state.ts
deleted file mode 100644
index fb4ea42eb..000000000
--- a/layers/nuxi/app/composables/eve/thread-state.ts
+++ /dev/null
@@ -1,130 +0,0 @@
-import type { EveMessageData, UseEveAgentSnapshot } from 'eve/vue'
-import type { UIMessage } from 'ai'
-import type { ChatEveState, ChatDetail } from '../../../shared/types/chat'
-import type { ChatSessionOptions } from './types'
-import { titleFromParts } from '../../../shared/utils/chat'
-
-export function resumeOptionsFromChat(chat: Pick<ChatDetail, 'state'>): ChatSessionOptions {
-  const events = chat.state?.events
-  if (!events?.length) {
-    return {}
-  }
-
-  const session = chat.state?.session ?? { streamIndex: 0 }
-
-  return {
-    initialSession: {
-      ...session,
-      streamIndex: Math.max(session.streamIndex ?? 0, events.length)
-    },
-    initialEvents: events
-  }
-}
-
-export async function persistChatState(
-  chatId: string,
-  snapshot: UseEveAgentSnapshot<EveMessageData>,
-  options?: {
-    syncMessages?: boolean
-    messages?: UIMessage[]
-  }
-) {
-  if (!snapshot.events.length) {
-    return
-  }
-
-  const state: ChatEveState = {
-    session: {
-      sessionId: snapshot.session.sessionId,
-      continuationToken: snapshot.session.continuationToken ?? chatId,
-      streamIndex: snapshot.events.length
-    },
-    events: [...snapshot.events]
-  }
-
-  await $fetch(`/api/chats/${chatId}/state`, {
-    method: 'PATCH',
-    body: {
-      state,
-      ...(options?.syncMessages && options.messages?.length
-        ? {
-            messages: options.messages.map(message => ({
-              id: message.id,
-              role: message.role,
-              parts: message.parts,
-              metadata: message.metadata as Record<string, unknown> | undefined
-            }))
-          }
-        : {})
-    }
-  })
-}
-
-export async function persistAnonymousTitle(chatId: string, title: string) {
-  if (!import.meta.client) return
-  sessionStorage.setItem(`nuxi-chat-title:${chatId}`, title)
-}
-
-export function readAnonymousTitle(chatId: string): string | null {
-  if (!import.meta.client) return null
-  return sessionStorage.getItem(`nuxi-chat-title:${chatId}`)
-}
-
-export interface EveChatRuntimeOptions {
-  chatId: string
-  getMessages: () => UIMessage[]
-  loggedIn: () => boolean
-  onTitle?: (title: string) => void
-  onFinish?: () => void
-  refreshChats?: () => Promise<void>
-  patchTitle?: (chatId: string, title: string) => void
-  findChatTitle?: (chatId: string) => string | null | undefined
-}
-
-export function createEveFinishHandler(options: EveChatRuntimeOptions) {
-  return async (snapshot: UseEveAgentSnapshot<EveMessageData>) => {
-    const agentMessages = options.getMessages()
-
-    if (options.loggedIn()) {
-      try {
-        await persistChatState(options.chatId, snapshot, {
-          syncMessages: true,
-          messages: [...agentMessages]
-        })
-        await options.refreshChats?.()
-
-        let generatedTitle = options.findChatTitle?.(options.chatId) ?? null
-
-        if (!generatedTitle) {
-          const firstUser = [...agentMessages].find(message => message.role === 'user')
-          const fallback = firstUser
-            ? titleFromParts(firstUser.parts as UIMessage['parts'])
-            : null
-          if (fallback && fallback !== 'Untitled') {
-            await $fetch(`/api/chats/${options.chatId}/title`, {
-              method: 'PATCH',
-              body: { title: fallback }
-            })
-            generatedTitle = fallback
-          }
-        }
-
-        if (generatedTitle) {
-          options.patchTitle?.(options.chatId, generatedTitle)
-          options.onTitle?.(generatedTitle)
-        }
-      } catch {
-        // Non-fatal sync failure
-      }
-    } else {
-      const firstUser = [...agentMessages].find(message => message.role === 'user')
-      if (firstUser) {
-        const title = titleFromParts(firstUser.parts as UIMessage['parts'])
-        await persistAnonymousTitle(options.chatId, title)
-        options.onTitle?.(title)
-      }
-    }
-
-    options.onFinish?.()
-  }
-}
diff --git a/layers/nuxi/app/composables/eve/types.ts b/layers/nuxi/app/composables/eve/types.ts
index 3a3bd7d29..209953abd 100644
--- a/layers/nuxi/app/composables/eve/types.ts
+++ b/layers/nuxi/app/composables/eve/types.ts
@@ -9,17 +9,3 @@ export interface AgentChatHandle {
   stop: () => void
   regenerate: () => Promise<void>
 }
-
-export interface ChatSessionOptions {
-  initialSession?: {
-    sessionId?: string
-    continuationToken?: string
-    streamIndex: number
-  }
-  initialEvents?: readonly unknown[]
-}
-
-export interface EveStreamEvent {
-  type: string
-  [key: string]: unknown
-}
diff --git a/layers/nuxi/app/composables/eve/useEveChat.ts b/layers/nuxi/app/composables/eve/useEveChat.ts
new file mode 100644
index 000000000..3e8a15c89
--- /dev/null
+++ b/layers/nuxi/app/composables/eve/useEveChat.ts
@@ -0,0 +1,152 @@
+import type { EveMessageData, UseEveAgentSnapshot } from 'eve/vue'
+import { useEveAgent } from 'eve/vue'
+import type { FileUIPart, UIMessage } from 'ai'
+import type { ChatEveState } from '../../../shared/types/chat'
+import { eveMessagesToUIMessages } from './adapter'
+import type { AgentChatHandle } from './types'
+
+export interface UseEveChatOptions {
+  chatId: MaybeRefOrGetter<string>
+  initialMessages?: MaybeRefOrGetter<UIMessage[] | undefined>
+  initialState?: MaybeRefOrGetter<ChatEveState | null | undefined>
+  headers?: () => Record<string, string>
+  onFinish?: (snapshot: UseEveAgentSnapshot<EveMessageData>) => void | Promise<void>
+}
+
+function resumeFromState(chatId: string, state: ChatEveState | null | undefined) {
+  const events = state?.events
+  if (!events?.length) {
+    return {
+      initialSession: {
+        continuationToken: chatId,
+        streamIndex: 0
+      }
+    }
+  }
+
+  const session = state?.session ?? { streamIndex: 0 }
+
+  return {
+    initialSession: {
+      ...session,
+      continuationToken: session.continuationToken ?? chatId,
+      streamIndex: Math.max(session.streamIndex ?? 0, events.length)
+    },
+    initialEvents: events as never
+  }
+}
+
+function lastUserMessage(data: EveMessageData) {
+  for (let index = data.messages.length - 1; index >= 0; index -= 1) {
+    const message = data.messages[index]
+    if (message?.role === 'user' && message.parts.length > 0) {
+      return message
+    }
+  }
+}
+
+async function sendUserParts(
+  agent: ReturnType<typeof useEveAgent>,
+  parts: UIMessage['parts']
+) {
+  const text = parts
+    .filter((part): part is { type: 'text', text: string } => part.type === 'text')
+    .map(part => part.text)
+    .join('\n')
+    .trim()
+
+  const fileParts = parts.filter((part): part is FileUIPart => part.type === 'file')
+
+  if (fileParts.length && text) {
+    await agent.send({
+      message: [
+        { type: 'text', text },
+        ...fileParts.map(part => ({
+          type: 'file' as const,
+          data: part.url,
+          mediaType: part.mediaType,
+          filename: part.filename
+        }))
+      ]
+    })
+    return
+  }
+
+  if (fileParts.length) {
+    await agent.send({
+      message: fileParts.map(part => ({
+        type: 'file' as const,
+        data: part.url,
+        mediaType: part.mediaType,
+        filename: part.filename
+      }))
+    })
+    return
+  }
+
+  if (text) {
+    await agent.send({ message: text })
+  }
+}
+
+export function useEveChat(options: UseEveChatOptions): AgentChatHandle & {
+  send: (input: string | { parts: UIMessage['parts'] }) => Promise<void>
+  hasAgentMessage: (role: UIMessage['role']) => boolean
+} {
+  const resume = resumeFromState(toValue(options.chatId), toValue(options.initialState))
+
+  const agent = useEveAgent({
+    ...resume,
+    headers: options.headers,
+    onFinish: (snapshot) => {
+      void options.onFinish?.(snapshot)
+    }
+  })
+
+  const seedMessages = computed(() => toValue(options.initialMessages) ?? [])
+
+  const messages = computed(() => {
+    const live = eveMessagesToUIMessages(agent.data.value.messages)
+    if (live.length > 0) return live
+    return seedMessages.value
+  })
+
+  async function send(input: string | { parts: UIMessage['parts'] }) {
+    const parts = typeof input === 'string'
+      ? [{ type: 'text' as const, text: input }]
+      : input.parts
+
+    await sendUserParts(agent, parts)
+  }
+
+  async function regenerate() {
+    if (agent.status.value === 'submitted' || agent.status.value === 'streaming') return
+    const message = lastUserMessage(agent.data.value)
+    if (!message) return
+    await sendUserParts(agent, message.parts as UIMessage['parts'])
+  }
+
+  function stop() {
+    agent.stop()
+  }
+
+  function hasAgentMessage(role: UIMessage['role']) {
+    return agent.data.value.messages.some(message => message.role === role)
+  }
+
+  return {
+    send,
+    hasAgentMessage,
+    get messages() {
+      return messages.value
+    },
+    get status() {
+      return agent.status.value
+    },
+    get error() {
+      return agent.error.value
+    },
+    stop,
+    regenerate
+  }
+}
diff --git a/layers/nuxi/app/composables/useAgentChat.ts b/layers/nuxi/app/composables/useAgentChat.ts
deleted file mode 100644
index f3d5c09a4..000000000
--- a/layers/nuxi/app/composables/useAgentChat.ts
+++ /dev/null
@@ -1,272 +0,0 @@
-import type { UIMessage } from 'ai'
-import type { ChatEveState } from '../../shared/types/chat'
-import { buildMessageParts, getMessageTextLength } from '../../shared/utils/paste-attachment'
-import { createEveChatSession } from './eve/session'
-import { getOrCreateEveAgent, removeEveAgent } from './eve/init'
-import { toUIMessages } from './eve/adapter'
-import {
-  createEveFinishHandler,
-  readAnonymousTitle,
-  resumeOptionsFromChat
-} from './eve/thread-state'
-import { useChatVotes } from './useChatVotes'
-import { usePasteAttachment } from './usePasteAttachment'
-
-type ChatModeOptions = {
-  mode?: 'chat'
-  chatId: string
-  initialMessages?: UIMessage[]
-  initialState?: ChatEveState | null
-  source: string
-  withPageContext?: 'always' | 'when-enabled'
-  fetchVotes?: boolean
-  onFinish?: () => void
-  onTitle?: (title: string) => void
-}
-
-type StartModeOptions = {
-  mode: 'start'
-  source: string
-}
-
-export type UseAgentChatOptions = ChatModeOptions | StartModeOptions
-
-function buildEveHeaders(
-  chatId: string,
-  agent: ReturnType<typeof useNuxtAgent>,
-  withPageContext: ComputedRef<boolean>
-) {
-  return () => {
-    const headers: Record<string, string> = {
-      'x-nuxi-chat-id': chatId
-    }
-
-    if (withPageContext.value && agent.currentPage.value) {
-      headers['x-page-path'] = agent.currentPage.value
-    }
-
-    return headers
-  }
-}
-
-type StartChatReturn = {
-  input: Ref<string>
-  loading: Ref<boolean>
-  prompt: ReturnType<ReturnType<typeof usePasteAttachment>['bindings']>
-  onSubmit: () => Promise<void>
-  createFromSuggestion: (label: string) => Promise<void>
-}
-
-type AgentChatReturn = {
-  chat: {
-    messages: UIMessage[]
-    status: 'ready' | 'submitted' | 'streaming' | 'error'
-    error?: Error
-    stop: () => void
-    regenerate: () => Promise<void>
-  }
-  input: Ref<string>
-  prompt: ReturnType<ReturnType<typeof usePasteAttachment>['bindings']>
-  getVote: (messageId: string) => boolean | null
-  vote: (message: UIMessage, isUpvoted: boolean) => void
-  send: (inputValue: string | { parts: UIMessage['parts'] }) => Promise<void>
-  onSubmit: () => Promise<void>
-  askQuestion: (question: string) => void
-  readAnonymousTitle: () => string | null
-}
-
-function useStartChat(source: string): StartChatReturn {
-  const agent = useNuxtAgent()
-  const chats = useChats()
-  const { loggedIn } = useUserSession()
-  const { track } = useAnalytics()
-  const toast = useToast()
-
-  const input = ref('')
-  const paste = usePasteAttachment(input)
-  const loading = ref(false)
-
-  async function createChat(parts: UIMessage['parts']) {
-    if (loading.value || agent.rateLimitReached.value || getMessageTextLength(parts) === 0) return
-    loading.value = true
-
-    try {
-      if (loggedIn.value) {
-        const chatId = crypto.randomUUID()
-        await createChatWithMessage(chatId, parts)
-        await chats.refresh()
-        await navigateTo(`/dashboard/chat/${chatId}`)
-      } else {
-        agent.pendingMessageParts.value = parts
-        await navigateTo(`/dashboard/chat/${crypto.randomUUID()}`)
-      }
-    } catch {
-      toast.add({ description: 'Failed to create chat', icon: 'i-lucide-alert-circle', color: 'error' })
-    } finally {
-      loading.value = false
-    }
-  }
-
-  async function onSubmit() {
-    if (!paste.canSubmit.value) return
-    const parts = paste.buildMessageParts()
-    paste.clearAttachments()
-    input.value = ''
-    track('Nuxi Message Sent', { source, queryLength: getMessageTextLength(parts) })
-    await createChat(parts)
-  }
-
-  function createFromSuggestion(label: string) {
-    track('Nuxi FAQ Clicked', { question: label, source })
-    return createChat(buildMessageParts(label, []))
-  }
-
-  return {
-    input,
-    loading,
-    prompt: paste.bindings(onSubmit),
-    onSubmit,
-    createFromSuggestion
-  }
-}
-
-export function useAgentChat<T extends UseAgentChatOptions>(
-  options: T
-): T extends StartModeOptions ? StartChatReturn : AgentChatReturn
-export function useAgentChat(options: UseAgentChatOptions) {
-  if (options.mode === 'start') {
-    return useStartChat(options.source)
-  }
-
-  const chatOptions = options
-  const agent = useNuxtAgent()
-  const chats = useChats()
-  const { loggedIn } = useUserSession()
-  const { track } = useAnalytics()
-
-  const input = ref('')
-  const paste = usePasteAttachment(input)
-  const { getVote, vote } = useChatVotes(() => chatOptions.chatId, chatOptions.fetchVotes ?? false)
-
-  const initialDbPersistDone = ref((chatOptions.initialMessages?.length ?? 0) > 0)
-
-  const useContext = computed(() =>
-    chatOptions.withPageContext === 'always'
-      ? Boolean(agent.currentPage.value)
-      : agent.pageContextEnabled.value && Boolean(agent.currentPage.value)
-  )
-
-  const resumeOptions = computed(() => {
-    if (chatOptions.initialState) {
-      return resumeOptionsFromChat({ state: chatOptions.initialState })
-    }
-    return {}
-  })
-
-  const eveSession = createEveChatSession(() => chatOptions.chatId, () => ({
-    ...resumeOptions.value,
-    headers: buildEveHeaders(chatOptions.chatId, agent, useContext),
-    onFinish: createEveFinishHandler({
-      chatId: chatOptions.chatId,
-      loggedIn: () => loggedIn.value,
-      getMessages: () => toUIMessages(getOrCreateEveAgent(chatOptions.chatId).data.value.messages),
-      refreshChats: () => chats.refresh(),
-      patchTitle: (id, title) => chats.patchTitle(id, title),
-      findChatTitle: id => chats.chatList.value?.find(c => c.id === id)?.title ?? null,
-      onTitle: chatOptions.onTitle,
-      onFinish: chatOptions.onFinish
-    })
-  }))
-
-  const chat = {
-    get messages() {
-      const live = eveSession.messages
-      if (live.length > 0) return live
-      return chatOptions.initialMessages ?? []
-    },
-    get status() {
-      return eveSession.status
-    },
-    get error() {
-      return eveSession.error
-    },
-    stop: eveSession.stop,
-    regenerate: eveSession.regenerate
-  }
-
-  async function persistFirstUserMessage(parts: UIMessage['parts']) {
-    if (initialDbPersistDone.value) return
-    initialDbPersistDone.value = true
-
-    const metadata = {
-      createdAt: new Date().toISOString(),
-      ...(useContext.value && agent.currentPage.value ? { pagePath: agent.currentPage.value } : {})
-    }
-
-    try {
-      if (chatOptions.initialMessages?.length) {
-        await appendUserMessageToChat(chatOptions.chatId, parts, metadata)
-      } else {
-        await createChatWithMessage(chatOptions.chatId, parts, metadata)
-      }
-    } catch (error) {
-      initialDbPersistDone.value = false
-      throw error
-    }
-  }
-
-  type SendInput = string | { parts: UIMessage['parts'] }
-
-  async function send(inputValue: SendInput) {
-    const parts = typeof inputValue === 'string'
-      ? [{ type: 'text' as const, text: inputValue }]
-      : inputValue.parts
-
-    if (!parts.length || getMessageTextLength(parts) === 0 || agent.rateLimitReached.value) return
-
-    track('Nuxi Message Sent', {
-      source: chatOptions.source,
-      page: agent.currentPage.value,
-      withContext: useContext.value,
-      queryLength: getMessageTextLength(parts)
-    })
-
-    if (loggedIn.value) {
-      await persistFirstUserMessage(parts)
-    }
-
-    await eveSession.send(typeof inputValue === 'string' ? inputValue : { parts })
-    agent.onMessageSent()
-  }
-
-  async function onSubmit() {
-    if (!paste.canSubmit.value) return
-    const parts = paste.buildMessageParts()
-    input.value = ''
-    paste.clearAttachments()
-    await send({ parts })
-  }
-
-  function askQuestion(question: string) {
-    track('Nuxi FAQ Clicked', { question, source: chatOptions.source })
-    send(question)
-  }
-
-  if (import.meta.client) {
-    onUnmounted(() => {
-      removeEveAgent(chatOptions.chatId)
-    })
-  }
-
-  return {
-    chat,
-    input,
-    prompt: paste.bindings(onSubmit),
-    getVote,
-    vote,
-    send,
-    onSubmit,
-    askQuestion,
-    readAnonymousTitle: () => readAnonymousTitle(chatOptions.chatId)
-  }
-}
diff --git a/layers/nuxi/app/composables/useChatDetail.ts b/layers/nuxi/app/composables/useChatDetail.ts
new file mode 100644
index 000000000..ae16ca38a
--- /dev/null
+++ b/layers/nuxi/app/composables/useChatDetail.ts
@@ -0,0 +1,178 @@
+import type { UIMessage } from 'ai'
+
+const navigationChatKey = 'nuxi-navigation-chat-id'
+
+export function setNavigationChatId(chatId: string) {
+  if (!import.meta.client) return
+  sessionStorage.setItem(navigationChatKey, chatId)
+}
+
+export function readNavigationChatId() {
+  if (!import.meta.client) return ''
+  return sessionStorage.getItem(navigationChatKey) ?? ''
+}
+
+export function clearNavigationChatId() {
+  if (!import.meta.client) return
+  sessionStorage.removeItem(navigationChatKey)
+}
+
+export function chatDetailCacheKey(chatId: string) {
+  if (!chatId) return 'chat-pending'
+  return `chat-${chatId}`
+}
+
+export function uiMessagesToRows(
+  messages: UIMessage[],
+  existing?: ChatMessageRow[]
+): ChatMessageRow[] {
+  const existingById = new Map(existing?.map(row => [row.id, row.createdAt]))
+
+  return messages.map(message => ({
+    id: message.id,
+    role: message.role,
+    parts: message.parts,
+    createdAt: (message.metadata as { createdAt?: string } | undefined)?.createdAt
+      ?? existingById.get(message.id)
+      ?? new Date().toISOString()
+  }))
+}
+
+export function seedChatDetailCache(chatId: string, detail: ChatDetail) {
+  if (!import.meta.client) return
+
+  const nuxtApp = useNuxtApp()
+  const key = chatDetailCacheKey(chatId)
+  nuxtApp.payload.data[key] = detail
+
+  const { data } = useNuxtData<ChatDetail>(key)
+  data.value = detail
+}
+
+export function patchChatDetailCache(
+  chatId: string,
+  patch: Partial<Pick<ChatDetail, 'title' | 'state' | 'messages'>>
+) {
+  if (!import.meta.client) return
+
+  const key = chatDetailCacheKey(chatId)
+  const { data } = useNuxtData<ChatDetail>(key)
+  if (!data.value) return
+
+  let resolved = patch
+  if (patch.messages?.length && data.value.messages?.length) {
+    const existingById = new Map(data.value.messages.map(row => [row.id, row.createdAt]))
+    resolved = {
+      ...patch,
+      messages: patch.messages.map(row => ({
+        ...row,
+        createdAt: existingById.get(row.id) ?? row.createdAt
+      }))
+    }
+  }
+
+  data.value = { ...data.value, ...resolved }
+
+  const nuxtApp = useNuxtApp()
+  nuxtApp.payload.data[key] = data.value
+}
+
+const freshChatKey = (chatId: string) => `nuxi-fresh-chat:${chatId}`
+
+export function markChatAsFresh(chatId: string) {
+  if (!import.meta.client) return
+  sessionStorage.setItem(freshChatKey(chatId), '1')
+}
+
+export function consumeFreshChat(chatId: string) {
+  if (!import.meta.client) return false
+  const key = freshChatKey(chatId)
+  if (!sessionStorage.getItem(key)) return false
+  sessionStorage.removeItem(key)
+  return true
+}
+
+export function resolveChatRouteId(path: string, param: string | string[] | undefined) {
+  if (typeof param === 'string' && param) return param
+  if (Array.isArray(param) && param[0]) return param[0]
+
+  const match = path.match(/^\/dashboard\/chat\/([^/]+)\/?$/)
+  if (match?.[1]) return match[1]
+
+  return readNavigationChatId()
+}
+
+export function useChatRouteId() {
+  const route = useRoute()
+  return computed(() => resolveChatRouteId(route.path, route.params.id))
+}
+
+export function useChatDetail(chatId: MaybeRefOrGetter<string>) {
+  const route = useRoute()
+  const { loggedIn } = useUserSession()
+
+  const id = computed(() => {
+    const value = toValue(chatId)
+    if (value) return value
+    return resolveChatRouteId(route.path, route.params.id)
+  })
+
+  const data = ref<ChatDetail | null>(null)
+  const error = ref<Error | null>(null)
+  const status = ref<'idle' | 'pending' | 'success' | 'error'>('idle')
+
+  let stopCacheWatch: ReturnType<typeof watch> | undefined
+
+  function bindCache(chatIdValue: string) {
+    stopCacheWatch?.()
+    const { data: shared } = useNuxtData<ChatDetail>(chatDetailCacheKey(chatIdValue))
+    data.value = shared.value ?? null
+    stopCacheWatch = watch(shared, (value) => {
+      data.value = value ?? null
+    }, { deep: true })
+  }
+
+  onScopeDispose(() => stopCacheWatch?.())
+
+  async function refresh() {
+    const chatIdValue = id.value
+
+    if (!loggedIn.value || !chatIdValue) {
+      stopCacheWatch?.()
+      data.value = null
+      error.value = null
+      status.value = 'success'
+      return
+    }
+
+    bindCache(chatIdValue)
+
+    if (data.value) {
+      error.value = null
+      status.value = 'success'
+      return
+    }
+
+    status.value = 'pending'
+    error.value = null
+
+    try {
+      const detail = await $fetch<ChatDetail>(`/api/chats/${chatIdValue}`)
+      if (id.value !== chatIdValue) return
+      seedChatDetailCache(chatIdValue, detail)
+      error.value = null
+      status.value = 'success'
+    } catch (err) {
+      if (id.value !== chatIdValue) return
+      data.value = null
+      error.value = err as Error
+      status.value = 'error'
+    }
+  }
+
+  watch([id, loggedIn], () => {
+    void refresh()
+  }, { immediate: true })
+
+  return { data, error, status, refresh }
+}
diff --git a/layers/nuxi/app/composables/useChatVotes.ts b/layers/nuxi/app/composables/useChatVotes.ts
deleted file mode 100644
index 696390534..000000000
--- a/layers/nuxi/app/composables/useChatVotes.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import type { UIMessage } from 'ai'
-
-export function useChatVotes(chatId: MaybeRefOrGetter<string>, immediate = false) {
-  const toast = useToast()
-  const chatIdValue = computed(() => toValue(chatId))
-
-  const { data: voteRows } = useLazyFetch<ChatVoteRow[]>(
-    () => `/api/chats/${chatIdValue.value}/votes`,
-    {
-      immediate,
-      default: () => [] as ChatVoteRow[]
-    }
-  )
-
-  const votes = ref(new Map<string, boolean>())
-
-  watch(voteRows, (rows) => {
-    const map = new Map<string, boolean>()
-    for (const row of (rows ?? []) as ChatVoteRow[]) {
-      map.set(row.messageId, row.isUpvoted)
-    }
-    votes.value = map
-  }, { immediate: true })
-
-  function getRows(): ChatVoteRow[] {
-    return (voteRows.value ?? []) as ChatVoteRow[]
-  }
-
-  function getVote(messageId: string): boolean | null {
-    const vote = votes.value.get(messageId)
-    return vote === undefined ? null : vote
-  }
-
-  function vote(message: UIMessage, isUpvoted: boolean) {
-    const current = votes.value.get(message.id)
-    const next = current === isUpvoted ? undefined : isUpvoted
-    const snapshot = new Map(votes.value)
-
-    if (next === undefined) votes.value.delete(message.id)
-    else votes.value.set(message.id, next)
-    votes.value = new Map(votes.value)
-
-    voteRows.value = next === undefined
-      ? getRows().filter(row => row.messageId !== message.id)
-      : [
-          ...getRows().filter(row => row.messageId !== message.id),
-          { chatId: chatIdValue.value, messageId: message.id, isUpvoted: next }
-        ]
-
-    $fetch(`/api/chats/${chatIdValue.value}/votes`, {
-      method: 'POST',
-      body: next === undefined
-        ? { messageId: message.id }
-        : { messageId: message.id, isUpvoted: next }
-    }).catch(() => {
-      votes.value = snapshot
-      voteRows.value = [...snapshot.entries()].map(([messageId, isUpvoted]) => ({
-        chatId: chatIdValue.value,
-        messageId,
-        isUpvoted
-      }))
-      toast.add({ description: 'Failed to save vote', icon: 'i-lucide-alert-circle', color: 'error' })
-    })
-  }
-
-  return { votes, getVote, vote }
-}
diff --git a/layers/nuxi/app/composables/useChats.ts b/layers/nuxi/app/composables/useChats.ts
index 018cd0ab9..28c6ac23a 100644
--- a/layers/nuxi/app/composables/useChats.ts
+++ b/layers/nuxi/app/composables/useChats.ts
@@ -1,5 +1,6 @@
 import { LazyChatModalConfirm, LazyChatModalRename } from '#components'
 import { isToday, isYesterday, subWeeks, subMonths } from 'date-fns'
+import { chatDetailCacheKey } from './useChatDetail'
 
 function groupChats(chats: UIChat[] | undefined | null) {
   const today: UIChat[] = []
@@ -46,6 +47,7 @@ export function useChats() {
   const route = useRoute()
   const toast = useToast()
   const overlay = useOverlay()
+  const { loggedIn } = useUserSession()
 
   const { data: chatList } = useFetch<ChatListItem[]>('/api/chats', {
     key: 'chats',
@@ -70,7 +72,7 @@ export function useChats() {
     if (chatList.value) {
       chatList.value = chatList.value.map(c => c.id === id ? { ...c, title } : c)
     }
-    const { data: chatCache } = useNuxtData<ChatDetail>(`chat-${id}`)
+    const { data: chatCache } = useNuxtData<ChatDetail>(chatDetailCacheKey(id))
     if (chatCache.value) {
       chatCache.value = { ...chatCache.value, title }
     }
@@ -83,6 +85,10 @@ export function useChats() {
   }
 
   async function refresh() {
+    if (!loggedIn.value) {
+      if (chatList.value?.length) chatList.value = []
+      return
+    }
     await refreshNuxtData('chats')
   }
 
diff --git a/layers/nuxi/app/composables/useNuxiChat.ts b/layers/nuxi/app/composables/useNuxiChat.ts
new file mode 100644
index 000000000..e763cdd35
--- /dev/null
+++ b/layers/nuxi/app/composables/useNuxiChat.ts
@@ -0,0 +1,499 @@
+import type { EveMessageData, UseEveAgentSnapshot } from 'eve/vue'
+import type { UIMessage } from 'ai'
+import type { ChatEveState } from '../../shared/types/chat'
+import { getMessageTextLength } from '../../shared/utils/paste-attachment'
+import {
+  appendUserMessageToChat,
+  createChatWithMessage,
+  persistAnonymousTitle,
+  readAnonymousTitle,
+  titleFromParts
+} from '../../shared/utils/chat'
+import {
+  clearNavigationChatId,
+  consumeFreshChat,
+  patchChatDetailCache,
+  seedChatDetailCache,
+  uiMessagesToRows
+} from './useChatDetail'
+import { eveMessagesToUIMessages } from './eve/adapter'
+import { useEveChat } from './eve/useEveChat'
+import { usePasteAttachment } from './usePasteAttachment'
+
+export type NuxiChatSendInput = string | { parts: UIMessage['parts'], persist?: boolean }
+
+export interface UseNuxiChatOptions {
+  chatId: MaybeRefOrGetter<string>
+  initialMessages?: MaybeRefOrGetter<UIMessage[] | undefined>
+  initialState?: MaybeRefOrGetter<ChatEveState | null | undefined>
+  source: string
+  withPageContext?: 'always' | 'when-enabled'
+  fetchVotes?: MaybeRefOrGetter<boolean>
+  onFinish?: () => void
+  onTitle?: (title: string) => void
+  data?: Ref<ChatDetail | null | undefined>
+  dataStatus?: Ref<string>
+  isOwner?: Ref<boolean>
+  consumePendingPrompt?: () => string | null
+  consumePendingMessageParts?: () => UIMessage['parts'] | null
+  onAnonymousTitle?: (parts: UIMessage['parts']) => void
+  redirectIfAnonymousEmpty?: () => void
+}
+
+interface SyncChatOptions {
+  chatId: () => string
+  loggedIn: () => boolean
+  refreshChats?: () => Promise<void>
+  patchTitle?: (chatId: string, title: string) => void
+  findChatTitle?: (chatId: string) => string | null | undefined
+  onTitle?: (title: string) => void
+  onFinish?: () => void
+}
+
+async function syncChatToDb(
+  id: string,
+  snapshot: UseEveAgentSnapshot<EveMessageData>,
+  messages: UIMessage[]
+) {
+  if (!snapshot.events.length) return
+
+  const state: ChatEveState = {
+    session: {
+      sessionId: snapshot.session.sessionId,
+      continuationToken: snapshot.session.continuationToken ?? id,
+      streamIndex: snapshot.events.length
+    },
+    events: [...snapshot.events]
+  }
+
+  await $fetch(`/api/chats/${id}/state`, {
+    method: 'PATCH',
+    body: {
+      state,
+      messages: messages.map(message => ({
+        id: message.id,
+        role: message.role,
+        parts: message.parts,
+        metadata: message.metadata as Record<string, unknown> | undefined
+      }))
+    }
+  })
+}
+
+function createChatSyncHandler(options: SyncChatOptions) {
+  return async (snapshot: UseEveAgentSnapshot<EveMessageData>) => {
+    const messages = eveMessagesToUIMessages(snapshot.data.messages)
+
+    if (options.loggedIn()) {
+      try {
+        const id = options.chatId()
+        await syncChatToDb(id, snapshot, messages)
+        patchChatDetailCache(id, {
+          state: {
+            session: {
+              sessionId: snapshot.session.sessionId,
+              continuationToken: snapshot.session.continuationToken ?? id,
+              streamIndex: snapshot.events.length
+            },
+            events: [...snapshot.events]
+          },
+          messages: uiMessagesToRows(messages)
+        })
+        await options.refreshChats?.()
+
+        let generatedTitle = options.findChatTitle?.(id) ?? null
+
+        if (!generatedTitle) {
+          const firstUser = [...messages].find(message => message.role === 'user')
+          const fallback = firstUser
+            ? titleFromParts(firstUser.parts as UIMessage['parts'])
+            : null
+          if (fallback && fallback !== 'Untitled') {
+            await $fetch(`/api/chats/${id}/title`, {
+              method: 'PATCH',
+              body: { title: fallback }
+            })
+            generatedTitle = fallback
+          }
+        }
+
+        if (generatedTitle) {
+          options.patchTitle?.(id, generatedTitle)
+          options.onTitle?.(generatedTitle)
+        }
+      } catch {
+        // Non-fatal sync failure
+      }
+    } else {
+      const firstUser = [...messages].find(message => message.role === 'user')
+      if (firstUser) {
+        const title = titleFromParts(firstUser.parts as UIMessage['parts'])
+        persistAnonymousTitle(options.chatId(), title)
+        options.onTitle?.(title)
+      }
+    }
+
+    options.onFinish?.()
+  }
+}
+
+function buildEveHeaders(
+  chatId: MaybeRefOrGetter<string>,
+  agent: ReturnType<typeof useNuxtAgent>,
+  withPageContext: ComputedRef<boolean>
+) {
+  return () => {
+    const headers: Record<string, string> = {
+      'x-nuxi-chat-id': toValue(chatId)
+    }
+
+    if (withPageContext.value && agent.currentPage.value) {
+      headers['x-page-path'] = agent.currentPage.value
+    }
+
+    return headers
+  }
+}
+
+function useChatVotes(chatId: MaybeRefOrGetter<string>, fetchVotes: MaybeRefOrGetter<boolean> = false) {
+  const toast = useToast()
+  const chatIdValue = computed(() => toValue(chatId))
+  const shouldFetch = computed(() => toValue(fetchVotes))
+
+  const { data: voteRows, execute } = useLazyFetch<ChatVoteRow[]>(
+    () => `/api/chats/${chatIdValue.value}/votes`,
+    {
+      immediate: false,
+      default: () => [] as ChatVoteRow[]
+    }
+  )
+
+  watch(shouldFetch, (next) => {
+    if (next) void execute()
+  }, { immediate: true })
+
+  const votes = ref(new Map<string, boolean>())
+
+  watch(voteRows, (rows) => {
+    const map = new Map<string, boolean>()
+    for (const row of (rows ?? []) as ChatVoteRow[]) {
+      map.set(row.messageId, row.isUpvoted)
+    }
+    votes.value = map
+  }, { immediate: true })
+
+  function getRows(): ChatVoteRow[] {
+    return (voteRows.value ?? []) as ChatVoteRow[]
+  }
+
+  function getVote(messageId: string): boolean | null {
+    const vote = votes.value.get(messageId)
+    return vote === undefined ? null : vote
+  }
+
+  function vote(message: UIMessage, isUpvoted: boolean) {
+    const current = votes.value.get(message.id)
+    const next = current === isUpvoted ? undefined : isUpvoted
+    const snapshot = new Map(votes.value)
+
+    if (next === undefined) votes.value.delete(message.id)
+    else votes.value.set(message.id, next)
+    votes.value = new Map(votes.value)
+
+    voteRows.value = next === undefined
+      ? getRows().filter(row => row.messageId !== message.id)
+      : [
+          ...getRows().filter(row => row.messageId !== message.id),
+          { chatId: chatIdValue.value, messageId: message.id, isUpvoted: next }
+        ]
+
+    $fetch(`/api/chats/${chatIdValue.value}/votes`, {
+      method: 'POST',
+      body: next === undefined
+        ? { messageId: message.id }
+        : { messageId: message.id, isUpvoted: next }
+    }).catch(() => {
+      votes.value = snapshot
+      voteRows.value = [...snapshot.entries()].map(([messageId, isUpvoted]) => ({
+        chatId: chatIdValue.value,
+        messageId,
+        isUpvoted
+      }))
+      toast.add({ description: 'Failed to save vote', icon: 'i-lucide-alert-circle', color: 'error' })
+    })
+  }
+
+  return { votes, getVote, vote }
+}
+
+function needsGeneration(messages: ChatMessageRow[]) {
+  const last = messages[messages.length - 1]
+  return last?.role === 'user'
+}
+
+export function chatDetailForResume(
+  chatId: string,
+  initialMessages: UIMessage[] | undefined,
+  initialState: ChatEveState | null | undefined,
+  fetched?: ChatDetail | null
+): ChatDetail | undefined {
+  if (fetched) return fetched
+  if (!initialMessages?.length) return undefined
+
+  const rows: ChatMessageRow[] = uiMessagesToRows(initialMessages)
+
+  if (!needsGeneration(rows)) return undefined
+
+  return {
+    id: chatId,
+    title: null,
+    visibility: 'private',
+    isOwner: true,
+    createdAt: new Date().toISOString(),
+    state: initialState ?? null,
+    messages: rows
+  }
+}
+
+export function setupStaleChatRefresh(options: {
+  chatId: MaybeRefOrGetter<string>
+  data: Ref<ChatDetail | null | undefined>
+  status: Ref<string>
+  refresh: () => Promise<void>
+}) {
+  onMounted(() => {
+    const id = toValue(options.chatId)
+    if (!id) return
+    if (consumeFreshChat(id)) return
+
+    const cached = options.data.value
+    if (!cached || options.status.value !== 'success') return
+
+    const looksIncomplete = needsGeneration(cached.messages)
+    if (looksIncomplete) void options.refresh()
+  })
+}
+
+function resumeChatSession(options: {
+  chat: ReturnType<typeof useNuxiChat>['chat']
+  send: ReturnType<typeof useNuxiChat>['send']
+  hasAgentUser: ReturnType<typeof useNuxiChat>['hasAgentUser']
+  data: Ref<ChatDetail | null | undefined>
+  loggedIn: Ref<boolean>
+  isOwner: Ref<boolean>
+  consumePendingPrompt: () => string | null
+  consumePendingMessageParts: () => UIMessage['parts'] | null
+  onAnonymousTitle?: (parts: UIMessage['parts']) => void
+  redirectIfAnonymousEmpty?: () => void
+}) {
+  if (!options.loggedIn.value) {
+    const pendingParts = options.consumePendingMessageParts()
+    const pendingPrompt = options.consumePendingPrompt()
+
+    if (!pendingParts && !pendingPrompt) {
+      options.redirectIfAnonymousEmpty?.()
+      return
+    }
+
+    if (pendingParts) {
+      options.onAnonymousTitle?.(pendingParts)
+      void options.send({ parts: pendingParts })
+      return
+    }
+
+    if (pendingPrompt) void options.send({ parts: [{ type: 'text', text: pendingPrompt }] })
+    return
+  }
+
+  const messages = options.data.value?.messages ?? []
+
+  if (options.isOwner.value && needsGeneration(messages)) {
+    const lastUserMessage = [...messages].reverse().find(message => message.role === 'user')
+    if (!lastUserMessage) return
+
+    if (options.hasAgentUser()) {
+      void options.chat.regenerate()
+    } else {
+      void options.send({ parts: lastUserMessage.parts as UIMessage['parts'], persist: false })
+    }
+    return
+  }
+
+  const pendingParts = options.consumePendingMessageParts()
+  if (pendingParts) {
+    void options.send({ parts: pendingParts })
+    return
+  }
+
+  const pendingPrompt = options.consumePendingPrompt()
+  if (pendingPrompt) void options.send({ parts: [{ type: 'text', text: pendingPrompt }] })
+}
+
+export function useNuxiChat(options: UseNuxiChatOptions) {
+  const agent = useNuxtAgent()
+  const chats = useChats()
+  const { loggedIn } = useUserSession()
+  const { track } = useAnalytics()
+  const toast = useToast()
+  const chatId = computed(() => toValue(options.chatId))
+
+  const input = ref('')
+  const paste = usePasteAttachment(input)
+  const { getVote, vote } = useChatVotes(chatId, () => toValue(options.fetchVotes) ?? false)
+
+  const chatExistsInDb = ref((toValue(options.initialMessages)?.length ?? 0) > 0)
+
+  watch(
+    () => toValue(options.initialMessages)?.length ?? 0,
+    (length) => {
+      if (length > 0) chatExistsInDb.value = true
+    }
+  )
+
+  const useContext = computed(() =>
+    options.withPageContext === 'always'
+      ? Boolean(agent.currentPage.value)
+      : agent.pageContextEnabled.value && Boolean(agent.currentPage.value)
+  )
+
+  const eveChat = useEveChat({
+    chatId: options.chatId,
+    initialMessages: options.initialMessages,
+    initialState: options.initialState,
+    headers: buildEveHeaders(options.chatId, agent, useContext),
+    onFinish: createChatSyncHandler({
+      chatId: () => chatId.value,
+      loggedIn: () => loggedIn.value,
+      refreshChats: () => chats.refresh(),
+      patchTitle: (id, title) => chats.patchTitle(id, title),
+      findChatTitle: id => chats.chatList.value?.find(c => c.id === id)?.title ?? null,
+      onTitle: options.onTitle,
+      onFinish: options.onFinish
+    })
+  })
+
+  const chat = {
+    get messages() {
+      return eveChat.messages
+    },
+    get status() {
+      return eveChat.status
+    },
+    get error() {
+      return eveChat.error
+    },
+    stop: eveChat.stop,
+    regenerate: eveChat.regenerate
+  }
+
+  async function persistUserMessage(parts: UIMessage['parts']) {
+    const metadata = {
+      createdAt: new Date().toISOString(),
+      ...(useContext.value && agent.currentPage.value ? { pagePath: agent.currentPage.value } : {})
+    }
+
+    if (!chatExistsInDb.value) {
+      const detail = await createChatWithMessage(chatId.value, parts, metadata)
+      seedChatDetailCache(chatId.value, detail)
+      chatExistsInDb.value = true
+      return
+    }
+
+    await appendUserMessageToChat(chatId.value, parts, metadata)
+  }
+
+  async function send(inputValue: NuxiChatSendInput) {
+    const parts = typeof inputValue === 'string'
+      ? [{ type: 'text' as const, text: inputValue }]
+      : inputValue.parts
+    const persist = typeof inputValue === 'string' || inputValue.persist !== false
+
+    if (!parts.length || getMessageTextLength(parts) === 0 || agent.rateLimitReached.value) return
+
+    track('Nuxi Message Sent', {
+      source: options.source,
+      page: agent.currentPage.value,
+      withContext: useContext.value,
+      queryLength: getMessageTextLength(parts)
+    })
+
+    if (loggedIn.value && persist) {
+      try {
+        await persistUserMessage(parts)
+      } catch {
+        toast.add({
+          description: 'Failed to save message',
+          icon: 'i-lucide-alert-circle',
+          color: 'error'
+        })
+      }
+    }
+
+    await eveChat.send(typeof inputValue === 'string' ? inputValue : { parts })
+    agent.onMessageSent()
+  }
+
+  async function onSubmit() {
+    if (!paste.canSubmit.value) return
+    const parts = paste.buildMessageParts()
+    input.value = ''
+    paste.clearAttachments()
+    await send({ parts })
+  }
+
+  function askQuestion(question: string) {
+    track('Nuxi FAQ Clicked', { question, source: options.source })
+    send(question)
+  }
+
+  const isOwner = options.isOwner ?? computed(() => loggedIn.value)
+  const resumeDone = ref(false)
+
+  const resumeData = computed(() => chatDetailForResume(
+    chatId.value,
+    toValue(options.initialMessages),
+    toValue(options.initialState),
+    options.data?.value
+  ))
+
+  watch(
+    [() => options.data?.value, () => options.dataStatus?.value, loggedIn, chatId],
+    () => {
+      if (resumeDone.value) return
+      if (!chatId.value) return
+      if (loggedIn.value && options.dataStatus?.value === 'pending') return
+
+      resumeDone.value = true
+      resumeChatSession({
+        chat,
+        send,
+        hasAgentUser: () => eveChat.hasAgentMessage('user'),
+        data: options.data ?? resumeData,
+        loggedIn,
+        isOwner,
+        consumePendingPrompt: options.consumePendingPrompt ?? (() => null),
+        consumePendingMessageParts: options.consumePendingMessageParts ?? (() => null),
+        onAnonymousTitle: options.onAnonymousTitle,
+        redirectIfAnonymousEmpty: options.redirectIfAnonymousEmpty
+      })
+      clearNavigationChatId()
+    },
+    { immediate: true }
+  )
+
+  return {
+    chat,
+    input,
+    prompt: paste.prompt,
+    getVote,
+    vote,
+    send,
+    onSubmit,
+    askQuestion,
+    handlePaste: paste.handlePaste,
+    removeAttachment: paste.removeAttachment,
+    restoreToInput: paste.restoreToInput,
+    hasAgentUser: () => eveChat.hasAgentMessage('user'),
+    readAnonymousTitle: () => readAnonymousTitle(chatId.value)
+  }
+}
diff --git a/layers/nuxi/app/composables/usePasteAttachment.ts b/layers/nuxi/app/composables/usePasteAttachment.ts
index 1d0a437f6..016bff814 100644
--- a/layers/nuxi/app/composables/usePasteAttachment.ts
+++ b/layers/nuxi/app/composables/usePasteAttachment.ts
@@ -43,16 +43,10 @@ export function usePasteAttachment(input: Ref<string>) {
     attachments.value = []
   }
 
-  function bindings(onSubmit: () => void | Promise<void>) {
-    return computed(() => ({
-      pasteAttachments: attachments.value,
-      canSubmit: canSubmit.value,
-      onPaste: handlePaste,
-      onRemoveAttachment: removeAttachment,
-      onRestoreAttachment: restoreToInput,
-      onSubmit
-    }))
-  }
+  const prompt = computed(() => ({
+    pasteAttachments: attachments.value,
+    canSubmit: canSubmit.value
+  }))
 
   return {
     attachments,
@@ -62,6 +56,6 @@ export function usePasteAttachment(input: Ref<string>) {
     restoreToInput,
     buildMessageParts: (): UIMessage['parts'] => buildMessageParts(input.value, attachments.value),
     clearAttachments,
-    bindings
+    prompt
   }
 }
diff --git a/layers/nuxi/app/composables/useStartChat.ts b/layers/nuxi/app/composables/useStartChat.ts
new file mode 100644
index 000000000..6c43cdbb6
--- /dev/null
+++ b/layers/nuxi/app/composables/useStartChat.ts
@@ -0,0 +1,71 @@
+import type { UIMessage } from 'ai'
+import { buildMessageParts, getMessageTextLength } from '../../shared/utils/paste-attachment'
+import { createChatWithMessage } from '../../shared/utils/chat'
+import { markChatAsFresh, seedChatDetailCache, setNavigationChatId } from './useChatDetail'
+import { usePasteAttachment } from './usePasteAttachment'
+
+export function useStartChat(source: string) {
+  const agent = useNuxtAgent()
+  const chats = useChats()
+  const { loggedIn } = useUserSession()
+  const { track } = useAnalytics()
+  const toast = useToast()
+
+  const input = ref('')
+  const paste = usePasteAttachment(input)
+  const loading = ref(false)
+
+  async function createChat(parts: UIMessage['parts']): Promise<boolean> {
+    if (loading.value || agent.rateLimitReached.value || getMessageTextLength(parts) === 0) return false
+    loading.value = true
+
+    try {
+      if (loggedIn.value) {
+        const chatId = crypto.randomUUID()
+        const detail = await createChatWithMessage(chatId, parts)
+        seedChatDetailCache(chatId, detail)
+        markChatAsFresh(chatId)
+        setNavigationChatId(chatId)
+        await navigateTo(`/dashboard/chat/${chatId}`)
+        void chats.refresh()
+      } else {
+        const chatId = crypto.randomUUID()
+        setNavigationChatId(chatId)
+        agent.pendingMessageParts.value = parts
+        await navigateTo(`/dashboard/chat/${chatId}`)
+      }
+      return true
+    } catch {
+      toast.add({ description: 'Failed to create chat', icon: 'i-lucide-alert-circle', color: 'error' })
+      return false
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function onSubmit() {
+    if (!paste.canSubmit.value) return
+    const parts = paste.buildMessageParts()
+    track('Nuxi Message Sent', { source, queryLength: getMessageTextLength(parts) })
+    if (await createChat(parts)) {
+      paste.clearAttachments()
+      input.value = ''
+    }
+  }
+
+  function createFromSuggestion(label: string) {
+    track('Nuxi FAQ Clicked', { question: label, source })
+    return createChat(buildMessageParts(label, []))
+  }
+
+  return {
+    input,
+    loading,
+    prompt: paste.prompt,
+    onSubmit,
+    handlePaste: paste.handlePaste,
+    removeAttachment: paste.removeAttachment,
+    restoreToInput: paste.restoreToInput,
+    createFromSuggestion
+  }
+}
diff --git a/layers/nuxi/app/pages/dashboard/chat/[id].vue b/layers/nuxi/app/pages/dashboard/chat/[id].vue
index 3f8fb8c84..8b4327a28 100644
--- a/layers/nuxi/app/pages/dashboard/chat/[id].vue
+++ b/layers/nuxi/app/pages/dashboard/chat/[id].vue
@@ -1,104 +1,83 @@
 <script setup lang="ts">
-import type { UIMessage } from 'ai'
-import { getOrCreateEveAgent } from '../../../composables/eve/init'
+import { setupStaleChatRefresh, useNuxiChat } from '../../../composables/useNuxiChat'
+import { resolveChatRouteId, useChatDetail, useChatRouteId } from '../../../composables/useChatDetail'
 
 definePageMeta({
-  layout: 'dashboard'
+  layout: 'dashboard',
+  key: route => resolveChatRouteId(route.path, route.params.id) || route.path
 })
 
-const route = useRoute()
+const chatId = useChatRouteId()
 const { loggedIn } = useUserSession()
 const { usage, rateLimitReached, consumePendingPrompt, consumePendingMessageParts } = useNuxtAgent()
 const { refresh: refreshChats } = useChats()
 
-const chatId = route.params.id as string
+const { data, error, status, refresh } = useChatDetail(chatId)
 
-const { data, error } = await useFetch<ChatDetail>(
-  () => loggedIn.value ? `/api/chats/${chatId}` : null,
-  { key: `chat-${chatId}` }
-)
+setupStaleChatRefresh({ chatId, data, status, refresh })
 
-if (loggedIn.value && (error.value || !data.value)) {
-  throw createError({ statusCode: 404, statusMessage: 'Chat not found', fatal: true })
-}
+watch([error, status, loggedIn], () => {
+  if (!loggedIn.value || status.value === 'pending') return
+  if (error.value || !data.value) {
+    throw createError({ statusCode: 404, statusMessage: 'Chat not found', fatal: true })
+  }
+}, { immediate: true })
 
 const isOwner = computed(() => data.value?.isOwner ?? false)
 const visibility = ref<'public' | 'private' | 'admin'>(data.value?.visibility ?? 'private')
 const title = ref<string | null>(loggedIn.value ? (data.value?.title ?? null) : null)
+
 watch(() => data.value?.title, (next) => {
   if (loggedIn.value) title.value = next ?? null
 })
 
-const initialMessages: UIMessage[] = loggedIn.value
-  ? toUIMessages(data.value?.messages ?? [])
-  : []
+watch(data, (detail) => {
+  if (detail?.visibility) visibility.value = detail.visibility
+}, { immediate: true })
+
+const initialMessages = computed(() =>
+  loggedIn.value ? dbRowsToUIMessages(data.value?.messages ?? []) : []
+)
+const initialState = computed(() => data.value?.state ?? null)
 
 const {
   chat,
   input,
   prompt,
-  send,
   getVote,
-  vote
-} = useAgentChat({
+  vote,
+  onSubmit,
+  handlePaste,
+  removeAttachment,
+  restoreToInput
+} = useNuxiChat({
   chatId,
   initialMessages,
-  initialState: data.value?.state ?? null,
+  initialState,
+  data,
+  dataStatus: status,
   source: 'chat-page',
   withPageContext: 'always',
-  fetchVotes: isOwner.value,
+  fetchVotes: isOwner,
+  isOwner,
+  consumePendingPrompt,
+  consumePendingMessageParts,
   onTitle: (generatedTitle) => {
     title.value = generatedTitle
   },
   onFinish: () => {
     if (loggedIn.value) refreshChats()
-  }
+  },
+  onAnonymousTitle: (parts) => {
+    if (!title.value) title.value = titleFromParts(parts)
+  },
+  redirectIfAnonymousEmpty: () => navigateTo('/dashboard/chat')
 })
 
 useNuxiChatSeo({
   title,
   description: 'A conversation with Nuxi.'
 })
-
-onMounted(() => {
-  if (!loggedIn.value) {
-    const pendingParts = consumePendingMessageParts()
-    const pendingPrompt = consumePendingPrompt()
-
-    if (!pendingParts && !pendingPrompt) {
-      navigateTo('/dashboard/chat')
-      return
-    }
-
-    if (pendingParts) {
-      if (!title.value) title.value = titleFromParts(pendingParts)
-      send({ parts: pendingParts })
-      return
-    }
-
-    if (pendingPrompt) send(pendingPrompt)
-    return
-  }
-
-  if (isOwner.value && data.value?.messages.length === 1 && data.value.messages[0]?.role === 'user') {
-    const eveHasUser = getOrCreateEveAgent(chatId).data.value.messages.some(message => message.role === 'user')
-    if (eveHasUser) {
-      void chat.regenerate()
-    } else {
-      void send({ parts: data.value.messages[0].parts as UIMessage['parts'] })
-    }
-    return
-  }
-
-  const pendingParts = consumePendingMessageParts()
-  if (pendingParts) {
-    send({ parts: pendingParts })
-    return
-  }
-
-  const pendingPrompt = consumePendingPrompt()
-  if (pendingPrompt) send(pendingPrompt)
-})
 </script>
 
 <template>
@@ -142,34 +121,41 @@ onMounted(() => {
 
     <template #body>
       <UContainer class="flex min-w-0 flex-1 flex-col gap-4 sm:gap-6">
-        <AgentChatMessages
+        <AgentChatBody
+          v-if="isOwner || !loggedIn"
+          v-model:input="input"
           :chat="chat"
           :chat-id="chatId"
+          :prompt="prompt"
+          :usage="usage"
+          :rate-limit-reached="rateLimitReached"
           :show-actions="isOwner"
           show-user-timestamps
           :spacing-offset="(isOwner || !loggedIn) && !rateLimitReached ? 160 : 0"
           :get-vote="getVote"
+          variant="subtle"
+          prompt-class="rounded-b-none border-b-0 bg-default [view-transition-name:chat-prompt]"
+          :prompt-ui="{
+            root: 'rounded-t-lg rounded-b-none border-b-0 bg-default',
+            base: 'px-1.5',
+            footer: 'items-baseline',
+            header: 'px-1.5 pt-1.5 pb-0 gap-1.5 flex flex-wrap items-start'
+          }"
+          @submit="onSubmit"
+          @paste="handlePaste"
+          @remove-attachment="removeAttachment"
+          @restore-attachment="restoreToInput"
           @vote="vote"
         />
 
-        <AgentRateLimitBanner v-if="rateLimitReached" variant="sticky" />
-        <div v-else-if="isOwner || !loggedIn" class="sticky bottom-0 z-10 flex flex-col gap-1.5 bg-default">
-          <AgentLoginHint v-if="!loggedIn" />
-          <AgentChatPrompt
-            v-model="input"
-            v-bind="prompt"
-            :chat="chat"
-            :usage="usage"
-            variant="subtle"
-            class="rounded-b-none border-b-0 bg-default [view-transition-name:chat-prompt]"
-            :ui="{
-              root: 'rounded-t-lg rounded-b-none border-b-0 bg-default',
-              base: 'px-1.5',
-              footer: 'items-baseline',
-              header: 'px-1.5 pt-1.5 pb-0 gap-1.5 flex flex-wrap items-start'
-            }"
-          />
-        </div>
+        <AgentChatMessages
+          v-else
+          :chat="chat"
+          :chat-id="chatId"
+          :show-actions="false"
+          :get-vote="getVote"
+          class="flex-1 pt-4 pb-4 sm:pb-6"
+        />
       </UContainer>
     </template>
   </UDashboardPanel>
diff --git a/layers/nuxi/app/pages/dashboard/chat/index.vue b/layers/nuxi/app/pages/dashboard/chat/index.vue
index b5c18bf4c..dc9c3884a 100644
--- a/layers/nuxi/app/pages/dashboard/chat/index.vue
+++ b/layers/nuxi/app/pages/dashboard/chat/index.vue
@@ -12,8 +12,12 @@ const {
   input,
   loading,
   prompt,
+  onSubmit,
+  handlePaste,
+  removeAttachment,
+  restoreToInput,
   createFromSuggestion
-} = useAgentChat({ mode: 'start', source: 'dashboard-home' })
+} = useStartChat('dashboard-home')
 
 const baseGreeting = computed(() => {
   const name = user.value?.name?.split(' ')[0] || user.value?.username
@@ -88,6 +92,10 @@ const suggestions = [
                   :submit-disabled="!prompt.canSubmit"
                   class="[view-transition-name:chat-prompt]"
                   :ui="{ base: 'px-1.5', footer: 'items-baseline', header: 'px-1.5 pt-1.5 pb-0 gap-1.5 flex flex-wrap items-start' }"
+                  @submit="onSubmit"
+                  @paste="handlePaste"
+                  @remove-attachment="removeAttachment"
+                  @restore-attachment="restoreToInput"
                 />
               </div>
             </template>
@@ -103,6 +111,10 @@ const suggestions = [
               :submit-disabled="!prompt.canSubmit"
               class="[view-transition-name:chat-prompt]"
               :ui="{ base: 'px-1.5', footer: 'items-baseline', header: 'px-1.5 pt-1.5 pb-0 gap-1.5 flex flex-wrap items-start' }"
+              @submit="onSubmit"
+              @paste="handlePaste"
+              @remove-attachment="removeAttachment"
+              @restore-attachment="restoreToInput"
             />
           </div>
 
diff --git a/layers/nuxi/app/plugins/chat-view-transitions.client.ts b/layers/nuxi/app/plugins/chat-view-transitions.client.ts
new file mode 100644
index 000000000..e2fcc7e92
--- /dev/null
+++ b/layers/nuxi/app/plugins/chat-view-transitions.client.ts
@@ -0,0 +1,101 @@
+/**
+ * Scoped View Transitions for dashboard chat only.
+ * Morphs the prompt between /dashboard/chat and /dashboard/chat/:id.
+ */
+export default defineNuxtPlugin((nuxtApp) => {
+  if (!document.startViewTransition) return
+
+  let transition: ViewTransition | undefined
+  let finishTransition: (() => void) | undefined
+  let hasUAVisualTransition = false
+
+  const resetTransitionState = (active?: ViewTransition) => {
+    if (active && transition !== active) return
+    transition = undefined
+    finishTransition = undefined
+    hasUAVisualTransition = false
+  }
+
+  window.addEventListener('popstate', (event) => {
+    hasUAVisualTransition
+      = (event as PopStateEvent & { hasUAVisualTransition?: boolean }).hasUAVisualTransition ?? false
+    if (hasUAVisualTransition) {
+      transition?.skipTransition()
+    }
+  })
+
+  const router = useRouter()
+
+  router.beforeResolve(async (to, from) => {
+    if (to.matched.length === 0) return
+
+    if (!isChatPromptTransition(to.path, from.path)) return
+
+    if (window.matchMedia('(prefers-reduced-motion: reduce)').matches) return
+    if (hasUAVisualTransition) return
+
+    if (transition) {
+      transition.skipTransition()
+      finishTransition?.()
+      resetTransitionState(transition)
+    }
+
+    const promise = new Promise<void>((resolve) => {
+      finishTransition = resolve
+    })
+
+    let changeRoute: () => void
+    const ready = new Promise<void>(resolve => (changeRoute = resolve))
+
+    const activeTransition = document.startViewTransition(() => {
+      changeRoute!()
+      return promise
+    })
+    transition = activeTransition
+
+    activeTransition.ready.catch(handleViewTransitionRejection)
+    activeTransition.updateCallbackDone.catch(handleViewTransitionRejection)
+    activeTransition.finished.catch(handleViewTransitionRejection).finally(() => resetTransitionState(activeTransition))
+
+    await nuxtApp.callHook('page:view-transition:start', activeTransition)
+
+    return ready
+  })
+
+  router.onError(() => {
+    finishTransition?.()
+    resetTransitionState(transition)
+  })
+  nuxtApp.hook('app:error', () => {
+    finishTransition?.()
+    resetTransitionState(transition)
+  })
+  nuxtApp.hook('vue:error', () => {
+    finishTransition?.()
+    resetTransitionState(transition)
+  })
+
+  nuxtApp.hook('page:finish', () => {
+    finishTransition?.()
+    resetTransitionState(transition)
+  })
+})
+
+function isChatPromptTransition(toPath: string, fromPath: string) {
+  const toChat = /^\/dashboard\/chat\/[^/]+$/.test(toPath)
+  const fromHome = fromPath === '/dashboard/chat'
+  const fromChat = /^\/dashboard\/chat\/[^/]+$/.test(fromPath)
+  const toHome = toPath === '/dashboard/chat'
+  return (fromHome && toChat) || (fromChat && toHome)
+}
+
+function handleViewTransitionRejection(error: unknown) {
+  if (!import.meta.dev || isExpectedViewTransitionRejection(error)) return
+  console.warn('[chat-view-transitions] transition promise rejected', error)
+}
+
+function isExpectedViewTransitionRejection(error: unknown) {
+  const name = error instanceof Error ? error.name : ''
+  const message = error instanceof Error ? error.message : String(error)
+  return name === 'AbortError' || message.includes('Transition was aborted')
+}
diff --git a/layers/nuxi/server/api/chats/index.post.ts b/layers/nuxi/server/api/chats/index.post.ts
index 865e93682..37be6fa3c 100644
--- a/layers/nuxi/server/api/chats/index.post.ts
+++ b/layers/nuxi/server/api/chats/index.post.ts
@@ -1,6 +1,7 @@
 import { createError } from 'h3'
 import type { ExtractTablesWithRelations } from 'drizzle-orm'
 import type { LibSQLTransaction } from 'drizzle-orm/libsql'
+import { asc, eq } from 'drizzle-orm'
 import { z } from 'zod'
 
 type Tx = LibSQLTransaction<typeof schema, ExtractTablesWithRelations<typeof schema>>
@@ -23,7 +24,7 @@ export default defineEventHandler(async (event) => {
     chat: { id }
   })
 
-  const chat = await db.transaction(async (tx: Tx) => {
+  await db.transaction(async (tx: Tx) => {
     const existing = await tx.query.chats.findFirst({
       where: () => eq(schema.chats.id, id)
     })
@@ -67,5 +68,19 @@ export default defineEventHandler(async (event) => {
     return row
   })
 
-  return chat
+  const detail = await db.query.chats.findFirst({
+    where: () => eq(schema.chats.id, id),
+    with: {
+      messages: {
+        orderBy: () => [asc(schema.messages.createdAt), asc(schema.messages.id)]
+      }
+    }
+  })
+
+  if (!detail) {
+    throw createError({ statusCode: 500, statusMessage: 'Failed to load created chat' })
+  }
+
+  const { userId: _, ...rest } = detail
+  return { ...rest, isOwner: true }
 })
diff --git a/layers/nuxi/shared/utils/chat.ts b/layers/nuxi/shared/utils/chat.ts
index b9029a1ec..0bbbab8e5 100644
--- a/layers/nuxi/shared/utils/chat.ts
+++ b/layers/nuxi/shared/utils/chat.ts
@@ -1,7 +1,7 @@
 import type { UIMessage } from 'ai'
 import { format } from 'date-fns'
 
-export function toUIMessages(rows: ChatMessageRow[]): UIMessage[] {
+export function dbRowsToUIMessages(rows: ChatMessageRow[]): UIMessage[] {
   return rows.map(m => ({
     id: m.id,
     role: m.role,
@@ -35,7 +35,7 @@ export async function createChatWithMessage(
   chatId: string,
   parts: UIMessage['parts'],
   metadata: Record<string, unknown> = {}
-): Promise<UIMessage> {
+): Promise<ChatDetail> {
   const userMessage: UIMessage = {
     id: crypto.randomUUID(),
     role: 'user',
@@ -46,12 +46,12 @@ export async function createChatWithMessage(
     }
   }
 
-  await $fetch('/api/chats', {
+  const detail = await $fetch<ChatDetail>('/api/chats', {
     method: 'POST',
     body: { id: chatId, message: userMessage }
   })
 
-  return userMessage
+  return detail
 }
 
 export async function appendUserMessageToChat(
@@ -76,3 +76,13 @@ export async function appendUserMessageToChat(
 
   return userMessage
 }
+
+export function persistAnonymousTitle(chatId: string, title: string) {
+  if (!import.meta.client) return
+  sessionStorage.setItem(`nuxi-chat-title:${chatId}`, title)
+}
+
+export function readAnonymousTitle(chatId: string): string | null {
+  if (!import.meta.client) return null
+  return sessionStorage.getItem(`nuxi-chat-title:${chatId}`)
+}
diff --git a/nuxt.config.ts b/nuxt.config.ts
index bdf46880d..bdaff8add 100644
--- a/nuxt.config.ts
+++ b/nuxt.config.ts
@@ -453,7 +453,6 @@ export default defineNuxtConfig({
   sourcemap: true,
   experimental: {
     extractAsyncDataHandlers: true,
-    viewTransition: true,
     defaults: {
       nuxtLink: {
         externalRelAttribute: 'noopener'