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/server/src/database/repos/ai-chat/ai-chat-message.repo.ts

@@ -25,6 +25,7 @@ export class AiChatMessageRepo {
     'content',
     'toolCalls',
     'metadata',
+    'status',
     'createdAt',
     'updatedAt',
     'deletedAt',
@@ -60,6 +61,26 @@ export class AiChatMessageRepo {
     });
   }
 
+  // Load ALL (non-deleted) messages of a chat in ascending chronological order
+  // (oldest -> newest), unpaginated. Used by the server-side Markdown export
+  // (#183), where the DB is the single source of truth and the whole transcript
+  // must be rendered in one pass (findByChat is cursor-paginated and would only
+  // return the first page).
+  async findAllByChat(
+    chatId: string,
+    workspaceId: string,
+  ): Promise<AiChatMessage[]> {
+    return this.db
+      .selectFrom('aiChatMessages')
+      .select(this.baseFields)
+      .where('chatId', '=', chatId)
+      .where('workspaceId', '=', workspaceId)
+      .where('deletedAt', 'is', null)
+      .orderBy('createdAt', 'asc')
+      .orderBy('id', 'asc')
+      .execute();
+  }
+
   // Load the most RECENT `limit` messages for a chat and return them in
   // ascending chronological order (oldest -> newest), as the model expects.
   // `findByChat` returns the FIRST page ASC (the OLDEST messages), which loses
@@ -96,4 +117,50 @@ export class AiChatMessageRepo {
       .returning(this.baseFields)
       .executeTakeFirst();
   }
+
+  /**
+   * Update a single message in place by id + workspace (#183 step-granular
+   * durability). The assistant row is created UPFRONT (status 'streaming') and
+   * patched as each step completes, then finalized once on the terminal status.
+   * `updatedAt` is always bumped. Returns the updated row (baseFields) or
+   * undefined when no row matched (e.g. a foreign workspace / deleted row).
+   */
+  async update(
+    id: string,
+    workspaceId: string,
+    patch: Partial<{
+      content: string | null;
+      toolCalls: unknown;
+      metadata: unknown;
+      status: string | null;
+    }>,
+    trx?: KyselyTransaction,
+  ): Promise<AiChatMessage | undefined> {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .updateTable('aiChatMessages')
+      .set({ ...(patch as Record<string, unknown>), updatedAt: new Date() })
+      .where('id', '=', id)
+      .where('workspaceId', '=', workspaceId)
+      .returning(this.baseFields)
+      .executeTakeFirst();
+  }
+
+  /**
+   * Crash-recovery sweep (#183): flip every assistant row still left in the
+   * 'streaming' state (a turn that died mid-write before reaching a terminal
+   * status) to 'aborted'. Run once on server start. Returns the number of rows
+   * swept so the caller can log it. Workspace-wide on purpose — a crash can have
+   * dangling streaming rows across any workspace.
+   */
+  async sweepStreaming(trx?: KyselyTransaction): Promise<number> {
+    const db = dbOrTx(this.db, trx);
+    const rows = await db
+      .updateTable('aiChatMessages')
+      .set({ status: 'aborted', updatedAt: new Date() })
+      .where('status', '=', 'streaming')
+      .returning('id')
+      .execute();
+    return rows.length;
+  }
 }