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/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