Chat mode, phase 1: grounded streaming chat over your notes

Entry points (no sixth tab): Ask in the Library header (desktop button,
phone icon), Ask about this deck in the deck menu, Ask a question on
study/homework results (compact result travels as context), and a Chat
row in the desktop sidebar. Phones get a full-screen route with back +
New chat; the tab bar steps aside.

- Client-side retrieval: chunk scoped decks (~800 tokens), BM25 against
  the question + recent turns, top chunks under ~7k tokens, each
  labelled with deck + section. Notes come from the deck's stored
  sourceText (already kept for Regenerate); decks without it fall back
  to generated content and the UI says so.
- Stateless server: /api/chat validates against the CHAT_MODELS
  allowlist, trims the history to ~6k tokens, caps context at ~9k and
  streams token/thinking/done/error NDJSON. /api/chat/extract reduces
  attachments to text through the existing vision step.
- UI: user bubbles + full-width assistant text, streaming with stop,
  auto-scroll that pauses with a jump-to-bottom button, safe markdown
  (React nodes, no HTML injection; KaTeX dynamically imported only when
  a message has math), Thinking row for reasoning, copy/regenerate/
  edit-and-resend, model + context pickers (last model remembered),
  composer with visualViewport keyboard handling, safe-area, 16px
  textarea, Enter-to-send on desktop.
- Usage-limit failures keep the draft and show the shared message with
  Settings/Ollama actions; stopping maps the reader abort to a clean
  stopped state; offline disables sending with a reason.
- Settings: Keep notes text for chat toggle; deck menu: Delete notes
  text. RATE_LIMIT_CHAT + CHAT_MODELS in .env.example and README.
- Tests: chat suite (63 checks, stub Ollama) wired into run-all.
  Full set: 12/12 suites, 487 checks. SW -> freezmo-v32.

Also: tests/model-compare.mjs (diagnostic) benchmarks two models on the
same notes (latency, repair rounds, activity types) so the gpt-oss vs
gemma default can be decided on numbers; defaults unchanged.

lib/chat-client.ts

@@ -0,0 +1,105 @@
+"use client";
+
+import { ApiError, consumeNdjson } from "./client-api";
+import { localeHeader, t } from "./i18n";
+import { authHeaders } from "./settings";
+import type { ChatSource } from "./chat";
+
+/**
+ * Client for the streaming chat route. The conversation window and the chosen
+ * context chunks travel with every request (the server never stores either);
+ * the API key only ever goes to our own route in its usual header.
+ */
+
+export type ChatStreamEvent =
+  | { type: "token"; text: string }
+  | { type: "thinking"; text: string }
+  | { type: "done"; model: string }
+  | { type: "error"; error: string; kind?: string };
+
+export type StreamChatInput = {
+  model?: string;
+  messages: { role: "user" | "assistant"; content: string }[];
+  context: (ChatSource & { text: string })[];
+  signal?: AbortSignal;
+  onToken: (text: string) => void;
+  onThinking: (text: string) => void;
+  onDone: (model: string) => void;
+};
+
+export async function streamChat(input: StreamChatInput): Promise<void> {
+  let response: Response;
+  try {
+    response = await fetch("/api/chat", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...authHeaders(), ...localeHeader() },
+      body: JSON.stringify({
+        model: input.model || undefined,
+        messages: input.messages,
+        context: input.context,
+      }),
+      signal: input.signal,
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new ApiError(t("api.cancelled"), "aborted");
+    }
+    throw new ApiError(t("api.unreachable"), "network");
+  }
+
+  if (!response.ok) {
+    const body = (await response.json().catch(() => null)) as { error?: string; kind?: string } | null;
+    throw new ApiError(body?.error ?? t("api.httpError", { status: response.status }), body?.kind);
+  }
+
+  let streamError: ApiError | null = null;
+  try {
+    await consumeNdjson(response, (raw) => {
+      const event = raw as ChatStreamEvent;
+      if (event.type === "token") input.onToken(event.text);
+      else if (event.type === "thinking") input.onThinking(event.text);
+      else if (event.type === "done") input.onDone(event.model);
+      else if (event.type === "error") streamError = new ApiError(event.error, event.kind);
+    });
+  } catch (error) {
+    // Aborting while the body is being read rejects the reader with an
+    // AbortError, not a fetch rejection — treat it as a user stop.
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new ApiError(t("api.cancelled"), "aborted");
+    }
+    throw error;
+  }
+
+  if (streamError) throw streamError;
+}
+
+/**
+ * Turns attached photos (and any client-extracted document text) into plain
+ * text through the existing vision pipeline, so the chat model itself never
+ * needs to be multimodal.
+ */
+export async function extractChatAttachment(
+  input: { images?: string[]; text?: string },
+  options: { signal?: AbortSignal } = {},
+): Promise<string> {
+  let response: Response;
+  try {
+    response = await fetch("/api/chat/extract", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...authHeaders(), ...localeHeader() },
+      body: JSON.stringify(input),
+      signal: options.signal,
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new ApiError(t("api.cancelled"), "aborted");
+    }
+    throw new ApiError(t("api.unreachable"), "network");
+  }
+  const body = (await response.json().catch(() => null)) as { text?: string; error?: string; kind?: string } | null;
+  if (!response.ok) {
+    throw new ApiError(body?.error ?? t("api.httpError", { status: response.status }), body?.kind);
+  }
+  if (!body?.text?.trim()) throw new ApiError(t("chat.attachEmpty"), "bad_response");
+  return body.text.trim();
+}