feat(ai-chat): persistent history as source of truth — step durability + server export (#183)

The chat lived in inconsistent paradigms (in-memory stream + client export vs.
DB-as-context), which made export flaky and lost the assistant answer if the
process died mid-turn. Make the DB the single source of truth.

A. STEP-GRANULAR DURABILITY (server)
- ai_chat_messages gains a nullable `status` column (migration; NULL = legacy =
  completed). The assistant row is now INSERTED UPFRONT as `status:'streaming'`
  and UPDATEd on every onStepFinish with all finished steps (text + tool calls +
  tool RESULTS), then finalized once to completed/error/aborted on the terminal
  callback. So a process death mid-turn keeps every finished step; a startup
  sweep (OnModuleInit → sweepStreaming) flips any dangling 'streaming' row to
  'aborted'. The write path no longer depends on a live socket.
- Pure exported `flushAssistant(steps, inProgressText, status, extra?)` builds
  the persist payload (metadata.parts byte-identical to the old builder), so a
  future background worker can call the same path. AiChatMessageRepo gains
  `update`, `sweepStreaming`, and `findAllByChat`.
- consumeStream drain, external-MCP client close-once, SSE heartbeat preserved.

B. SERVER-SIDE EXPORT
- New pure `chat-markdown.util.ts` renders Markdown from DB rows ONLY (server
  port of the client builder). Because A persists the in-progress row, the
  export now includes an interrupted turn up to its last finished step (flagged
  "still generating"). `POST /ai-chat/export` (owner-gated via assertOwnedChat,
  workspace-scoped) returns it; `lang` accepts a full client locale tag
  ('en-US'/'ru-RU') and is normalized server-side (normalizeLang) — a strict
  @IsIn(['en','ru']) DTO rejected the real client's i18n.language with a 400,
  caught in real-browser testing.
- Client: handleCopy calls the endpoint; `canExport = !!activeChatId`. The whole
  liveThreadRef/liveStateRef/onLiveContentChange/hasLiveContent hybrid (and the
  client chat-markdown util + test) is removed — the server is now authoritative.

Tests: flushAssistant unit (status shapes + parts parity), chat-markdown.util
unit (incl. legacy NULL-status + interrupted note + ru + normalizeLang locale
tags), controller export wiring + owner-gate, integration update/sweepStreaming.
Verified: server build + 318 ai-chat unit + 3 integration; client tsc + 157
ai-chat unit; and END-TO-END in a real browser — a chat turn persists mid-stream
and the Copy button exports the DB-sourced markdown (showing the in-progress
row), HTTP 200 after the locale fix.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

apps/client/src/features/ai-chat/components/ai-chat-window.tsx

@@ -6,7 +6,6 @@ import {
   useRef,
   useState,
 } from "react";
-import { type UIMessage } from "@ai-sdk/react";
 import { Group, Loader, Tooltip } from "@mantine/core";
 import {
   IconArrowsDiagonal,
@@ -40,7 +39,7 @@ import {
 } from "@/features/ai-chat/queries/ai-chat-query.ts";
 import ConversationList from "@/features/ai-chat/components/conversation-list.tsx";
 import ChatThread from "@/features/ai-chat/components/chat-thread.tsx";
-import { buildChatMarkdown } from "@/features/ai-chat/utils/chat-markdown.ts";
+import { exportAiChat } from "@/features/ai-chat/services/ai-chat-service.ts";
 import { useChatSession } from "@/features/ai-chat/hooks/use-chat-session.ts";
 import {
   shouldCollapseOnOutsidePointer,
@@ -121,7 +120,7 @@ function clampGeom(g: {
  * ported from the GitmostAgent.jsx design.
  */
 export default function AiChatWindow() {
-  const { t } = useTranslation();
+  const { t, i18n } = useTranslation();
   const clipboard = useClipboard({ timeout: 500 });
   const queryClient = useQueryClient();
   const [windowOpen, setWindowOpen] = useAtom(aiChatWindowOpenAtom);
@@ -162,30 +161,11 @@ export default function AiChatWindow() {
   const { data: messageRows, isLoading: messagesLoading } =
     useAiChatMessagesQuery(activeChatId ?? undefined);
 
-  // Live snapshot of the active thread's useChat state, kept up to date by
-  // ChatThread. Lets the export include the in-progress (not-yet-persisted)
-  // streaming turn. A ref avoids re-rendering this window on every token.
-  const liveThreadRef = useRef<{
-    messages: UIMessage[];
-    isStreaming: boolean;
-    banner: string | null;
-  }>({
-    messages: [],
-    isStreaming: false,
-    banner: null,
-  });
-
   // Live turn-token total (reasoning + output) for the in-flight turn, pushed up
   // (THROTTLED to ~8 Hz inside ChatThread) so the header badge ticks mid-stream.
   // `null` means no turn is in flight -> the badge falls back to the persisted
   // context size below.
   const [liveTurnTokens, setLiveTurnTokens] = useState<number | null>(null);
-  // Whether the on-screen thread currently holds at least one message. Reported
-  // reactively by ChatThread (the live snapshot lives in a non-reactive ref). This
-  // lets the "Copy chat" button stay available for a brand-new, not-yet-persisted
-  // chat whose first turn is in flight or was interrupted — that case has no
-  // persisted rows yet, so a persisted-rows-only gate would hide the button (#174).
-  const [hasLiveContent, setHasLiveContent] = useState(false);
 
   // The page the user is currently viewing. AiChatWindow lives in a pathless
   // parent layout route, so useParams() can't see :pageSlug. Match the full
@@ -254,20 +234,16 @@ export default function AiChatWindow() {
     [cancelPendingAdoption, setActiveChatId, setDraft, setSelectedRoleId],
   );
 
-  // The active chat object (for its title) and an export gate: only enable the
-  // export button when an existing chat with loaded persisted rows is active.
+  // The active chat object (for its title) and an export gate. The export is now
+  // SERVER-sourced (the DB is the single source of truth — #183): the assistant
+  // row is persisted upfront + per step, so even a brand-new chat whose first
+  // turn is streaming/interrupted has a server row to render. Enable the button
+  // whenever a persisted chat is active (`activeChatId` is set).
   const activeChat = useMemo(
     () => chats?.items?.find((c) => c.id === activeChatId) ?? null,
     [chats, activeChatId],
   );
-  // Export is available when there is anything to export: either persisted rows
-  // for the active chat, OR a live on-screen thread with at least one message.
-  // The live arm covers a brand-new chat whose first turn is streaming or was
-  // interrupted before the server persisted any row (#174); the persisted arm is
-  // the steady-state path for an already-saved chat (#160).
-  const canExport =
-    hasLiveContent ||
-    (!!activeChatId && !!messageRows && messageRows.length > 0);
+  const canExport = !!activeChatId;
 
   // The role to display in the header and as the assistant's name. Prefer the
   // persisted role of an existing chat (chat-list JOIN); fall back to the role
@@ -284,53 +260,21 @@ export default function AiChatWindow() {
     return picked ? { name: picked.name, emoji: picked.emoji } : null;
   }, [activeChat, enabledRoles, selectedRoleId]);
 
-  // Build a Markdown export from the already-loaded persisted rows (no network
-  // call) and copy it to the clipboard. The "Copied" notification is the
-  // feedback.
-  const handleCopy = useCallback(() => {
-    // Export gate. There must be SOMETHING to export — either a live on-screen
-    // message or a persisted row. A brand-new chat whose first turn is streaming
-    // or was interrupted has live messages but no persisted rows yet; it still
-    // exports the on-screen thread WYSIWYG (#174). Only a truly empty chat (no
-    // live messages and no rows) is non-exportable (the button is hidden too —
-    // see `canExport`).
-    const live = liveThreadRef.current;
-    const hasRows = !!messageRows && messageRows.length > 0;
-    if (live.messages.length === 0 && !hasRows) return;
-    // WYSIWYG export: the live on-screen messages ARE the document (so a partial
-    // reply from an interrupted turn — which never reached the persisted rows —
-    // is exported just as it appears). The persisted rows enrich each live
-    // message (token usage / error / timestamp) by id and serve as the fallback
-    // when the live mirror is empty. The on-screen banner is appended too. See
-    // issues #160 and #174. `chatId` may be null for a not-yet-saved chat — use a
-    // placeholder so the header line still renders.
-    const markdown = buildChatMarkdown({
-      title: activeChat?.title ?? null,
-      chatId: activeChatId ?? "unsaved",
-      live: live.messages.map((m) => ({
-        id: m.id,
-        role: m.role,
-        parts: (m.parts ?? []) as { type: string; text?: string }[],
-        metadata: m.metadata as
-          | {
-              usage?: {
-                inputTokens?: number;
-                outputTokens?: number;
-                totalTokens?: number;
-                reasoningTokens?: number;
-              };
-              error?: string;
-            }
-          | undefined,
-      })),
-      rows: messageRows,
-      isStreaming: live.isStreaming,
-      banner: live.banner,
-      t,
-    });
-    clipboard.copy(markdown);
-    notifications.show({ message: t("Copied") });
-  }, [activeChatId, messageRows, activeChat, clipboard, t]);
+  // Fetch the server-rendered Markdown export and copy it to the clipboard. The
+  // server is the single source of truth (#183): it renders the transcript from
+  // the persisted rows — including an interrupted turn's in-progress row — so the
+  // export is identical whether the chat is freshly streaming, just switched to,
+  // or reloaded. The `lang` of the active i18n drives the few localized labels.
+  const handleCopy = useCallback(async () => {
+    if (!activeChatId) return;
+    try {
+      const markdown = await exportAiChat(activeChatId, i18n.language);
+      clipboard.copy(markdown);
+      notifications.show({ message: t("Copied") });
+    } catch {
+      notifications.show({ message: t("Failed to export chat"), color: "red" });
+    }
+  }, [activeChatId, clipboard, t, i18n.language]);
 
   // Current context size for the active chat: how much the conversation now
   // occupies in the model's context window — NOT the cumulative tokens spent.
@@ -685,9 +629,7 @@ export default function AiChatWindow() {
               onRolePicked={(role) => setSelectedRoleId(role.id)}
               assistantName={currentRole?.name}
               onTurnFinished={onTurnFinished}
-              liveStateRef={liveThreadRef}
               onLiveTurnTokens={setLiveTurnTokens}
-              onLiveContentChange={setHasLiveContent}
             />
           )}
         </div>

apps/client/src/features/ai-chat/components/chat-thread.tsx

@@ -1,11 +1,4 @@
-import {
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-  type MutableRefObject,
-} from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { generateId } from "ai";
 import { ActionIcon, Box, Group, Stack, Text } from "@mantine/core";
 import { IconClockHour4, IconX } from "@tabler/icons-react";
@@ -68,30 +61,12 @@ interface ChatThreadProps {
    *  authoritative id the server streamed on the assistant message metadata, or
    *  undefined on a failed turn — see adopt-chat-id.ts for the full #137 design. */
   onTurnFinished: (serverChatId?: string) => void;
-  /** Parent-owned ref that this thread keeps updated with its live useChat
-   *  snapshot (full message list + streaming flag), so the header's
-   *  "Copy chat" export can include the in-progress, not-yet-persisted
-   *  assistant message. A ref (not state) avoids re-rendering the parent on
-   *  every streamed delta. */
-  liveStateRef?: MutableRefObject<{
-    messages: UIMessage[];
-    isStreaming: boolean;
-    banner: string | null;
-  }>;
   /** Reports the live turn-token total (reasoning + output) for the in-flight
    *  turn so the parent can show a header badge that ticks mid-stream. THROTTLED
    *  here (~8 Hz) so the parent re-renders a handful of times a second, not on
    *  every streamed delta. Called with `null` when no turn is in flight (the
    *  parent then reverts the badge to the persisted context size). */
   onLiveTurnTokens?: (tokens: number | null) => void;
-  /** Reports whether the live thread currently holds at least one message, so the
-   *  parent can gate the "Copy chat" button on the on-screen thread rather than on
-   *  the persisted rows alone. This stays truthy for a brand-new, not-yet-saved
-   *  chat the moment its first user message appears — so an interrupted very first
-   *  turn (no persisted rows yet) is still exportable (#174). Called with `false`
-   *  on unmount so a thread torn down by `key` on chat switch can't leave the
-   *  button enabled for the next, possibly empty, chat. */
-  onLiveContentChange?: (hasContent: boolean) => void;
 }
 
 /**
@@ -135,9 +110,7 @@ export default function ChatThread({
   onRolePicked,
   assistantName,
   onTurnFinished,
-  liveStateRef,
   onLiveTurnTokens,
-  onLiveContentChange,
 }: ChatThreadProps) {
   const { t } = useTranslation();
 
@@ -328,44 +301,6 @@ export default function ChatThread({
   // the SAME on-screen banner text can be mirrored into the export (issue #160).
   const errorView = error ? describeChatError(error.message ?? "", t) : null;
 
-  // The exact banner the user sees under the message list, flattened to a single
-  // string for the "Copy chat" export so the artifact records the interruption
-  // WYSIWYG. Mirrors the JSX precedence below: error first, else the stop notice.
-  const banner = errorView
-    ? errorView.detail
-      ? `${errorView.title} — ${errorView.detail}`
-      : errorView.title
-    : stopNotice === "manual"
-      ? t("Response stopped.")
-      : stopNotice === "disconnect"
-        ? t("Connection lost — the answer was interrupted.")
-        : null;
-
-  // Mirror the live useChat snapshot into the parent-owned ref so the export
-  // (handled in AiChatWindow) can include the in-progress streaming turn AND the
-  // on-screen banner. The cleanup clears the ref on unmount so a thread torn down
-  // by `key` on chat switch can't leak its (possibly still-streaming) tail into
-  // the next chat's export before the new thread's effect repopulates the ref.
-  useEffect(() => {
-    if (!liveStateRef) return;
-    liveStateRef.current = { messages, isStreaming, banner };
-    return () => {
-      liveStateRef.current = { messages: [], isStreaming: false, banner: null };
-    };
-  }, [liveStateRef, messages, isStreaming, banner]);
-
-  // Reactively report "the live thread has content" to the parent. `liveStateRef`
-  // above is a ref (deliberately non-reactive so streaming deltas don't re-render
-  // the parent), so the export button needs a SEPARATE reactive signal to flip on
-  // for a not-yet-persisted chat. Keyed on the boolean only — identical values are
-  // a no-op setState in the parent, so this does not add per-delta re-renders.
-  const hasLiveContent = messages.length > 0;
-  useEffect(() => {
-    if (!onLiveContentChange) return;
-    onLiveContentChange(hasLiveContent);
-    return () => onLiveContentChange(false);
-  }, [onLiveContentChange, hasLiveContent]);
-
   // Report the live turn-token total to the parent header badge, THROTTLED to
   // ~8 Hz so the parent re-renders a few times a second instead of on every
   // streamed delta. The tail assistant message's reasoning+output (estimate while