test(review): pin full-transcript history past 50 rows + changelog (PR #202)

Address the PR #202 review (approve-with-comments). The only actionable
non-blocking item was the test-coverage suggestion: the source switch in
AiChatService.handle from findRecent(chatId, ws, 50) to findAllByChat(chatId,
ws) was not pinned by a test. handle() is a streaming method the project marks
as not unit-testable, so cover the behavioral guarantee it now relies on at the
repo/integration level — seed a chat of 60 messages and assert the default
findAllByChat (exactly how handle calls it) returns the FULL transcript in
chronological order, including the first turn the old 50-window would have
dropped.

Also document the behavior change under CHANGELOG [Unreleased] -> Changed.

The two stability items (token-budget trim before streamText; O(N) history
rebuild per turn) are deferred: the reviewer flagged both as non-blocking
conscious trade-offs aligned with the PR's stated goal, and the trim is a
larger architecture change out of scope for this follow-up.

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

CHANGELOG.md

@@ -72,16 +72,18 @@ per-workspace rolling-day token budget.
 - **Footnote multi-backlinks.** A footnote referenced more than once now shows a
   back-link per reference (↩ a b c …), each scrolling to its own occurrence, like
   Pandoc/Wikipedia; a single-reference footnote keeps the plain ↩. (#168)
-- **AI chat: header button auto-opens the chat bound to the current document.**
-  Clicking the AI-chat button in the header while viewing a page now reopens the
-  latest chat tied to that document instead of whatever chat was last active,
-  reusing the existing `ai_chats.page_id` provenance (no migration). The newest
-  chat you created on the page wins; with no bound chat — or off a page, or if
-  the lookup fails — it falls soft to a fresh chat and keeps the current
-  selection otherwise. (#191)
 
 ### Changed
 
+- **AI chat now feeds the model the full stored transcript.** The per-turn model
+  conversation was rebuilt from a sliding window of the 50 most recent stored
+  rows, which silently dropped the beginning of any longer chat. It is now
+  rebuilt from the complete non-deleted transcript in chronological order, so
+  the model sees every turn (a 5000-row backstop guards process memory — a
+  safety net far above any realistic chat, not a conversational limit). On a
+  very long chat this can eventually reach the model's context window; the
+  client already surfaces that as "start a new chat". (#202)
+
 - **AI chat default provider is now `openai-compatible` (reasoning surfaced).**
   For the `openai` driver the chat provider defaults to the openai-compatible
   implementation, so a workspace pointing at z.ai/GLM/DeepSeek now streams the

apps/client/src/components/layouts/global/app-header.tsx

@@ -10,12 +10,12 @@ import classes from "./app-header.module.css";
 import { BrandLogo } from "@/components/ui/brand-logo";
 import TopMenu from "@/components/layouts/global/top-menu.tsx";
 import { Link } from "react-router-dom";
-import { useAtom } from "jotai";
+import { useAtom, useSetAtom } from "jotai";
 import {
   desktopSidebarAtom,
   mobileSidebarAtom,
 } from "@/components/layouts/global/hooks/atoms/sidebar-atom.ts";
-import { useOpenAiChatForCurrentPage } from "@/features/ai-chat/hooks/use-open-ai-chat.ts";
+import { aiChatWindowOpenAtom } from "@/features/ai-chat/atoms/ai-chat-atom.ts";
 import { workspaceAtom } from "@/features/user/atoms/current-user-atom.ts";
 import { useToggleSidebar } from "@/components/layouts/global/hooks/hooks/use-toggle-sidebar.ts";
 import SidebarToggle from "@/components/ui/sidebar-toggle-button.tsx";
@@ -38,9 +38,7 @@ export function AppHeader() {
   const toggleDesktop = useToggleSidebar(desktopSidebarAtom);
 
   const [workspace] = useAtom(workspaceAtom);
-  // Opening from the header auto-opens the document's bound chat (last chat
-  // created on the current page); off a page it keeps the current selection.
-  const openAiChat = useOpenAiChatForCurrentPage();
+  const setAiChatWindowOpen = useSetAtom(aiChatWindowOpenAtom);
   // AI chat entry point: only shown when the workspace enables it (A7 gate).
   const aiChatEnabled = workspace?.settings?.ai?.chat === true;
 
@@ -107,7 +105,7 @@ export function AppHeader() {
                 color="dark"
                 size="sm"
                 aria-label={t("AI chat")}
-                onClick={openAiChat}
+                onClick={() => setAiChatWindowOpen((v) => !v)}
               >
                 <IconMessage size={20} />
               </ActionIcon>

apps/client/src/features/ai-chat/hooks/use-open-ai-chat.test.tsx

@@ -1,135 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-import { Provider, createStore } from "jotai";
-import type { ReactNode } from "react";
-import { useOpenAiChatForCurrentPage } from "./use-open-ai-chat";
-import {
-  activeAiChatIdAtom,
-  aiChatWindowOpenAtom,
-  aiChatDraftAtom,
-  selectedAiRoleIdAtom,
-} from "@/features/ai-chat/atoms/ai-chat-atom.ts";
-
-// useMatch is the only react-router-dom export the hook uses; drive its return
-// per test to simulate "on a page" vs "off a page".
-const useMatchMock = vi.fn();
-vi.mock("react-router-dom", () => ({
-  useMatch: () => useMatchMock(),
-}));
-
-// The bound-chat resolver is the network boundary; stub it per test.
-const getBoundChatMock = vi.fn();
-vi.mock("@/features/ai-chat/services/ai-chat-service.ts", () => ({
-  getBoundChat: (pageId: string) => getBoundChatMock(pageId),
-}));
-
-// Put the hook on a page route by default ("doc-p1" -> page id "p1"); individual
-// tests override useMatch to go off-page.
-function onPage(pageSlug = "doc-p1") {
-  useMatchMock.mockReturnValue({ params: { pageSlug } });
-}
-function offPage() {
-  useMatchMock.mockReturnValue(null);
-}
-
-// Render the hook inside an explicit jotai store so atom side effects are
-// assertable; the store is returned for setup + assertions.
-function setup(seed?: (store: ReturnType<typeof createStore>) => void) {
-  const store = createStore();
-  seed?.(store);
-  const wrapper = ({ children }: { children: ReactNode }) => (
-    <Provider store={store}>{children}</Provider>
-  );
-  const { result } = renderHook(() => useOpenAiChatForCurrentPage(), { wrapper });
-  return { store, open: () => act(() => result.current()) };
-}
-
-describe("useOpenAiChatForCurrentPage", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    onPage();
-  });
-
-  it("on a page: resolves the bound chat, selects it, and opens the window", async () => {
-    getBoundChatMock.mockResolvedValue("bound-chat-1");
-    const { store, open } = setup((s) => s.set(aiChatDraftAtom, "stale draft"));
-
-    await open();
-
-    expect(getBoundChatMock).toHaveBeenCalledWith("p1");
-    expect(store.get(activeAiChatIdAtom)).toBe("bound-chat-1");
-    expect(store.get(aiChatWindowOpenAtom)).toBe(true);
-    expect(store.get(aiChatDraftAtom)).toBe(""); // cleared on a real switch
-  });
-
-  it("on a page with no bound chat: opens a fresh chat (null)", async () => {
-    getBoundChatMock.mockResolvedValue(null);
-    const { store, open } = setup((s) => s.set(activeAiChatIdAtom, "previous"));
-
-    await open();
-
-    expect(store.get(activeAiChatIdAtom)).toBeNull();
-    expect(store.get(aiChatWindowOpenAtom)).toBe(true);
-  });
-
-  it("off a page: keeps the current selection and does NOT resolve", async () => {
-    offPage();
-    const { store, open } = setup((s) => {
-      s.set(activeAiChatIdAtom, "keep-me");
-      s.set(aiChatDraftAtom, "untouched");
-    });
-
-    await open();
-
-    expect(getBoundChatMock).not.toHaveBeenCalled();
-    expect(store.get(activeAiChatIdAtom)).toBe("keep-me");
-    expect(store.get(aiChatDraftAtom)).toBe("untouched"); // no switch -> kept
-    expect(store.get(aiChatWindowOpenAtom)).toBe(true);
-  });
-
-  it("window already open: re-click does NOT re-resolve or switch chats", async () => {
-    getBoundChatMock.mockResolvedValue("would-switch");
-    const { store, open } = setup((s) => {
-      s.set(aiChatWindowOpenAtom, true);
-      s.set(activeAiChatIdAtom, "current");
-    });
-
-    await open();
-
-    expect(getBoundChatMock).not.toHaveBeenCalled();
-    expect(store.get(activeAiChatIdAtom)).toBe("current");
-    expect(store.get(aiChatWindowOpenAtom)).toBe(true);
-  });
-
-  it("does NOT clear the draft when the resolved chat equals the current one", async () => {
-    getBoundChatMock.mockResolvedValue("same");
-    const { store, open } = setup((s) => {
-      s.set(activeAiChatIdAtom, "same");
-      s.set(aiChatDraftAtom, "in-progress");
-    });
-
-    await open();
-
-    expect(store.get(aiChatDraftAtom)).toBe("in-progress"); // no switch
-    expect(store.get(aiChatWindowOpenAtom)).toBe(true);
-  });
-
-  it("fail-soft: a resolve error opens a fresh chat (null)", async () => {
-    getBoundChatMock.mockRejectedValue(new Error("network"));
-    const { store, open } = setup((s) => s.set(activeAiChatIdAtom, "previous"));
-
-    await open();
-
-    expect(store.get(activeAiChatIdAtom)).toBeNull();
-    expect(store.get(aiChatWindowOpenAtom)).toBe(true);
-  });
-
-  it("clears the picked role on a real switch", async () => {
-    getBoundChatMock.mockResolvedValue("bound");
-    const { store, open } = setup((s) => s.set(selectedAiRoleIdAtom, "role-1"));
-
-    await open();
-
-    expect(store.get(selectedAiRoleIdAtom)).toBeNull();
-  });
-});

apps/client/src/features/ai-chat/hooks/use-open-ai-chat.ts

@@ -1,67 +0,0 @@
-import { useCallback } from "react";
-import { useAtom, useSetAtom } from "jotai";
-import { useMatch } from "react-router-dom";
-import {
-  aiChatWindowOpenAtom,
-  activeAiChatIdAtom,
-  aiChatDraftAtom,
-  selectedAiRoleIdAtom,
-} from "@/features/ai-chat/atoms/ai-chat-atom.ts";
-import { getBoundChat } from "@/features/ai-chat/services/ai-chat-service.ts";
-import { extractPageSlugId } from "@/lib";
-
-/**
- * The generic "open the AI chat" action, WITH document binding: when invoked
- * while viewing a page, it resolves that page's bound chat and selects it before
- * opening — so the last chat for this document re-opens by itself. With no bound
- * chat (or off a page) it keeps the current selection / opens a fresh chat. Used
- * by the app-header entry point; NOT by the provenance badge (which deep-links).
- */
-export function useOpenAiChatForCurrentPage() {
-  const [windowOpen, setWindowOpen] = useAtom(aiChatWindowOpenAtom);
-  const [activeChatId, setActiveChatId] = useAtom(activeAiChatIdAtom);
-  const setDraft = useSetAtom(aiChatDraftAtom);
-  const setSelectedRoleId = useSetAtom(selectedAiRoleIdAtom);
-
-  // Same route-match trick the window uses: read :pageSlug from the pathname.
-  // AiChatWindow lives in a pathless parent layout route, so useParams() can't
-  // see :pageSlug — match the full path against the authenticated page route.
-  const match = useMatch("/s/:spaceSlug/p/:pageSlug");
-  const pageId = extractPageSlugId(match?.params?.pageSlug);
-
-  return useCallback(async () => {
-    // Re-clicks while the window is already open (incl. minimized) must NOT
-    // re-resolve and yank the user to another chat: resolve only on a genuine
-    // closed -> open transition. (`windowOpen` is already true here, so there
-    // is nothing to set — just bail.)
-    if (windowOpen) return;
-    // Open the window FIRST so the control feels instant: the bound-chat
-    // round-trip below must never gate the window appearing, or on a slow
-    // connection the first click reads as a hung control until the POST returns.
-    setWindowOpen(true);
-    let resolved: string | null = activeChatId; // off-a-page: keep current
-    if (pageId) {
-      try {
-        resolved = await getBoundChat(pageId); // null => fresh chat
-      } catch {
-        resolved = null; // fail-soft: a fresh chat is always a safe fallback
-      }
-    }
-    // Clear the composer draft / picked role ONLY on an actual switch, so
-    // reopening the same chat does not wipe an in-progress draft. Applied after
-    // the resolve so the window is already visible while the switch settles.
-    if (resolved !== activeChatId) {
-      setActiveChatId(resolved);
-      setDraft("");
-      setSelectedRoleId(null);
-    }
-  }, [
-    windowOpen,
-    activeChatId,
-    pageId,
-    setWindowOpen,
-    setActiveChatId,
-    setDraft,
-    setSelectedRoleId,
-  ]);
-}

apps/client/src/features/ai-chat/services/ai-chat-service.ts

@@ -37,17 +37,6 @@ export async function getAiChatMessages(
   return req.data;
 }
 
-/**
- * Resolve the chat bound to a document (the current user's most-recent chat
- * created on that page), or null when there is none. Drives auto-open-on-page.
- */
-export async function getBoundChat(pageId: string): Promise<string | null> {
-  const req = await api.post<{ chatId: string | null }>("/ai-chat/bound-chat", {
-    pageId,
-  });
-  return req.data.chatId;
-}
-
 /** Rename a chat. */
 export async function renameAiChat(data: {
   chatId: string;

apps/server/src/core/ai-chat/ai-chat.controller.bound-chat.spec.ts

@@ -1,44 +0,0 @@
-import { AiChatController } from './ai-chat.controller';
-import type { User, Workspace } from '@docmost/db/types/entity.types';
-
-/**
- * Wiring spec for the #191 `POST /ai-chat/bound-chat` endpoint. It must forward
- * the requesting user + workspace + pageId to findLatestByPage and return the
- * matched chat's id, or `{ chatId: null }` when there is none. The repo already
- * scopes to the caller's OWN chats, so a foreign pageId simply yields no match
- * (null) — no extra page-access check is needed. Exercised with hand-rolled
- * mocks, no Nest graph and no DB.
- */
-describe('AiChatController.boundChat', () => {
-  const user = { id: 'u1' } as User;
-  const workspace = { id: 'ws1' } as Workspace;
-
-  function makeController(chat: unknown) {
-    const aiChatRepo = {
-      findLatestByPage: jest.fn().mockResolvedValue(chat),
-    };
-    const controller = new AiChatController(
-      {} as never,
-      aiChatRepo as never,
-      {} as never,
-      {} as never,
-    );
-    return { controller, aiChatRepo };
-  }
-
-  it('returns the owned chat id and scopes the lookup to user + workspace + page', async () => {
-    const { controller, aiChatRepo } = makeController({
-      id: 'c1',
-      creatorId: 'u1',
-    });
-    const res = await controller.boundChat({ pageId: 'p1' }, user, workspace);
-    expect(aiChatRepo.findLatestByPage).toHaveBeenCalledWith('u1', 'ws1', 'p1');
-    expect(res).toEqual({ chatId: 'c1' });
-  });
-
-  it('returns { chatId: null } for a page with no owned chat (incl. foreign pageId)', async () => {
-    const { controller } = makeController(undefined);
-    const res = await controller.boundChat({ pageId: 'foreign' }, user, workspace);
-    expect(res).toEqual({ chatId: null });
-  });
-});

apps/server/src/core/ai-chat/ai-chat.controller.ts

@@ -30,7 +30,6 @@ import { FileInterceptor } from '../../common/interceptors/file.interceptor';
 import { AiChatService, AiChatStreamBody } from './ai-chat.service';
 import { AiTranscriptionService } from './ai-transcription.service';
 import {
-  BoundChatDto,
   ChatIdDto,
   ExportChatDto,
   GetChatMessagesDto,
@@ -67,28 +66,6 @@ export class AiChatController {
     return this.aiChatRepo.findByCreator(user.id, workspace.id, pagination);
   }
 
-  /**
-   * Resolve the chat bound to a document for the requesting user: the most-recent
-   * non-deleted chat created on that page (ai_chats.page_id). Returns
-   * { chatId: null } when the page has no owned chat (-> a fresh chat). No page
-   * access check needed: only the caller's OWN chats are matched, so a foreign
-   * pageId reveals nothing.
-   */
-  @HttpCode(HttpStatus.OK)
-  @Post('bound-chat')
-  async boundChat(
-    @Body() dto: BoundChatDto,
-    @AuthUser() user: User,
-    @AuthWorkspace() workspace: Workspace,
-  ): Promise<{ chatId: string | null }> {
-    const chat = await this.aiChatRepo.findLatestByPage(
-      user.id,
-      workspace.id,
-      dto.pageId,
-    );
-    return { chatId: chat?.id ?? null };
-  }
-
   /** Fetch the messages of a chat (oldest first, paginated). */
   @HttpCode(HttpStatus.OK)
   @Post('messages')

apps/server/src/core/ai-chat/ai-chat.service.spec.ts

@@ -240,7 +240,7 @@ describe('prepareAgentStep', () => {
  * write path. It runs identically for the upfront insert (empty steps,
  * 'streaming'), every per-step update, and the terminal finalize — so a future
  * background worker can call the same function. These tests pin the four status
- * shapes and the `metadata.parts` shape that rowToUiMessage/findRecent depend on
+ * shapes and the `metadata.parts` shape that rowToUiMessage/findAllByChat depend on
  * (per-step text + tool parts via assistantParts, in-progress text appended).
  */
 describe('flushAssistant', () => {

apps/server/src/core/ai-chat/ai-chat.service.ts

@@ -322,12 +322,14 @@ export class AiChatService implements OnModuleInit {
 
     // Rebuild the conversation from persisted history (not the client payload),
     // so the model always sees the authoritative server-side transcript. Load
-    // the most RECENT tail (oldest -> newest) so chats longer than one page do
-    // not drop recent turns (incl. the user message just inserted above).
-    const history = await this.aiChatMessageRepo.findRecent(
+    // the FULL history in chronological order (oldest -> newest, incl. the user
+    // message just inserted above) so NO turns are dropped — there is no
+    // recent-tail window anymore. `findAllByChat` keeps a 5000-row memory-safety
+    // backstop (on overflow it keeps the NEWEST rows and logs a warning); that
+    // is a safety net far above any realistic chat, not a conversational limit.
+    const history = await this.aiChatMessageRepo.findAllByChat(
       chatId,
       workspace.id,
-      50,
     );
     const uiMessages = history.map(rowToUiMessage);
     // convertToModelMessages is async in ai@6.0.134 (returns Promise<ModelMessage[]>).
@@ -1215,7 +1217,7 @@ export async function applyFinalize(
  *
  * `metadata.parts` is built by assistantParts over the finished steps, then the
  * in-progress text appended as a trailing text part, so rowToUiMessage /
- * findRecent keep replaying the turn unchanged. `metadata.finishReason`,
+ * findAllByChat keep replaying the turn unchanged. `metadata.finishReason`,
  * `metadata.error`, `metadata.usage`, `metadata.contextTokens` and
  * `metadata.maxContextTokens` are attached only when provided/relevant, matching
  * the pre-#183 onFinish/onError records.

apps/server/src/core/ai-chat/dto/ai-chat.dto.ts

@@ -27,12 +27,6 @@ export class GetChatMessagesDto {
   cursor?: string;
 }
 
-/** Resolve the chat bound to a document (the page's most-recent owned chat). */
-export class BoundChatDto {
-  @IsString()
-  pageId: string;
-}
-
 /** Export a chat to Markdown (#183). `lang` localizes the few fixed
  *  role/tool-action labels; defaults to English server-side. */
 export class ExportChatDto {

apps/server/src/database/repos/ai-chat/ai-chat-message.repo.ts

@@ -18,7 +18,8 @@ import { executeWithCursorPagination } from '@docmost/db/pagination/cursor-pagin
 // (multi-instance deploy).
 const SWEEP_STREAMING_STALE_MS = 10 * 60 * 1000; // 10 minutes
 
-// Hard upper bound on the rows materialized by `findAllByChat` (export path).
+// Hard upper bound on the rows materialized by `findAllByChat`, which now feeds
+// BOTH the Markdown export and the per-turn model history.
 // A generous cap so a pathologically huge chat cannot load an unbounded result
 // into memory; far above any realistic transcript length.
 const FIND_ALL_BY_CHAT_LIMIT = 5000;
@@ -78,14 +79,17 @@ 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).
+  // (oldest -> newest), unpaginated. Two callers, both treating the DB as the
+  // single source of truth and needing the whole transcript in one pass
+  // (findByChat is cursor-paginated and would only return the first page):
+  //   - the server-side Markdown export (#183);
+  //   - the per-turn model history, rebuilt fresh on every turn so the model
+  //     sees the full authoritative transcript.
   //
   // Hard-capped at FIND_ALL_BY_CHAT_LIMIT rows (a generous bound, far above any
-  // realistic transcript) so exporting a pathologically huge chat cannot
-  // materialize an unbounded result set in memory.
+  // realistic transcript) — a shared memory-safety backstop for BOTH paths so a
+  // pathologically huge chat cannot materialize an unbounded result set in
+  // memory. On overflow the NEWEST rows are kept and a warning is logged.
   async findAllByChat(
     chatId: string,
     workspaceId: string,
@@ -93,9 +97,9 @@ export class AiChatMessageRepo {
     limit: number = FIND_ALL_BY_CHAT_LIMIT,
   ): Promise<AiChatMessage[]> {
     // Fetch newest-first (+1 to DETECT truncation), so on overflow we keep the
-    // NEWEST `limit` messages — the recent conversation matters most for an
-    // export — rather than silently dropping the tail (#183 review). Reverse back
-    // to chronological for rendering, like findRecent.
+    // NEWEST `limit` messages — the recent conversation matters most — rather
+    // than silently dropping the tail (#183 review). Then reverse back to
+    // chronological order (oldest -> newest) for rendering / model replay.
     const rows = await this.db
       .selectFrom('aiChatMessages')
       .select(this.baseFields)
@@ -110,38 +114,13 @@ export class AiChatMessageRepo {
     if (rows.length > limit) {
       rows.length = limit; // keep the newest `limit` (rows are newest-first here)
       this.logger.warn(
-        `Chat ${chatId} export truncated to the newest ${limit} messages ` +
+        `Chat ${chatId} truncated to the newest ${limit} messages ` +
           `(older messages omitted).`,
       );
     }
     return rows.reverse();
   }
 
-  // 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
-  // recent turns once a chat grows beyond a page; this rebuilds the model
-  // history from the tail instead. Plain query (no cursor pagination).
-  async findRecent(
-    chatId: string,
-    workspaceId: string,
-    limit: number,
-  ): Promise<AiChatMessage[]> {
-    const rows = await this.db
-      .selectFrom('aiChatMessages')
-      .select(this.baseFields)
-      .where('chatId', '=', chatId)
-      .where('workspaceId', '=', workspaceId)
-      .where('deletedAt', 'is', null)
-      .orderBy('createdAt', 'desc')
-      .orderBy('id', 'desc')
-      .limit(limit)
-      .execute();
-
-    // Selected newest-first for the limit; reverse to oldest-first for the model.
-    return rows.reverse();
-  }
-
   async insert(
     insertable: InsertableAiChatMessage,
     trx?: KyselyTransaction,

apps/server/src/database/repos/ai-chat/ai-chat.repo.spec.ts

@@ -1,85 +0,0 @@
-import { AiChatRepo } from './ai-chat.repo';
-import type { KyselyDB } from '../../types/kysely.types';
-
-/**
- * Unit test for AiChatRepo.findLatestByPage — the "bound chat" resolver behind
- * #191 (auto-open the last chat created on a document). It builds the scoping
- * query, so we assert the EXACT predicates/ordering the spec mandates over a
- * chainable builder mock (no live DB): user + workspace + page scope, the
- * deletedAt filter, newest-by-createdAt with an id tiebreaker, limit 1. A
- * live-Postgres ordering test is out of scope for this pure unit test.
- */
-describe('AiChatRepo.findLatestByPage', () => {
-  type Recorded = {
-    table?: string;
-    wheres: Array<[string, string, unknown]>;
-    orderBys: Array<[string, string]>;
-    limit?: number;
-  };
-
-  function makeDb(result: unknown): { db: KyselyDB; rec: Recorded } {
-    const rec: Recorded = { wheres: [], orderBys: [] };
-    const builder: Record<string, unknown> = {};
-    const chain = () => builder;
-    builder.selectAll = chain;
-    builder.where = (col: string, op: string, val: unknown) => {
-      rec.wheres.push([col, op, val]);
-      return builder;
-    };
-    builder.orderBy = (col: string, dir: string) => {
-      rec.orderBys.push([col, dir]);
-      return builder;
-    };
-    builder.limit = (n: number) => {
-      rec.limit = n;
-      return builder;
-    };
-    builder.executeTakeFirst = () => Promise.resolve(result);
-    const db = {
-      selectFrom: (table: string) => {
-        rec.table = table;
-        return builder;
-      },
-    } as unknown as KyselyDB;
-    return { db, rec };
-  }
-
-  it('returns the matched chat and scopes by user + workspace + page (deletedAt null)', async () => {
-    const chat = { id: 'c1', creatorId: 'u1', workspaceId: 'ws1', pageId: 'p1' };
-    const { db, rec } = makeDb(chat);
-    const repo = new AiChatRepo(db);
-
-    const res = await repo.findLatestByPage('u1', 'ws1', 'p1');
-
-    expect(res).toBe(chat);
-    expect(rec.table).toBe('aiChats');
-    expect(rec.wheres).toEqual(
-      expect.arrayContaining([
-        ['creatorId', '=', 'u1'],
-        ['workspaceId', '=', 'ws1'],
-        ['pageId', '=', 'p1'],
-        ['deletedAt', 'is', null],
-      ]),
-    );
-  });
-
-  it('orders newest-first by createdAt then id, limit 1', async () => {
-    const { db, rec } = makeDb(undefined);
-    const repo = new AiChatRepo(db);
-
-    await repo.findLatestByPage('u1', 'ws1', 'p1');
-
-    expect(rec.orderBys).toEqual([
-      ['createdAt', 'desc'],
-      ['id', 'desc'],
-    ]);
-    expect(rec.limit).toBe(1);
-  });
-
-  it('returns undefined when the page has no owned chat', async () => {
-    const { db } = makeDb(undefined);
-    const repo = new AiChatRepo(db);
-
-    await expect(repo.findLatestByPage('u1', 'ws1', 'p1')).resolves.toBeUndefined();
-  });
-});

apps/server/src/database/repos/ai-chat/ai-chat.repo.ts

@@ -80,32 +80,6 @@ export class AiChatRepo {
     });
   }
 
-  /**
-   * The "bound chat" for a document: the requesting user's most recently
-   * created, non-deleted chat whose origin page is `pageId`. Auto-opened when
-   * the AI chat window is opened on that page. Newest-by-createdAt wins, so a
-   * chat created later on the same page supersedes earlier ones — exactly how
-   * "new chat -> becomes the bound one" falls out for free. Scoped to the user +
-   * workspace, so a foreign pageId can only ever match the caller's own chats.
-   */
-  async findLatestByPage(
-    creatorId: string,
-    workspaceId: string,
-    pageId: string,
-  ): Promise<AiChat | undefined> {
-    return this.db
-      .selectFrom('aiChats')
-      .selectAll('aiChats')
-      .where('creatorId', '=', creatorId)
-      .where('workspaceId', '=', workspaceId)
-      .where('pageId', '=', pageId)
-      .where('deletedAt', 'is', null)
-      .orderBy('createdAt', 'desc')
-      .orderBy('id', 'desc') // stable tiebreaker, mirrors findByCreator's cursor
-      .limit(1)
-      .executeTakeFirst();
-  }
-
   async insert(
     insertable: InsertableAiChat,
     trx?: KyselyTransaction,

apps/server/test/integration/ai-chat-message-status.int-spec.ts

@@ -267,4 +267,36 @@ describe('AiChatMessageRepo.update + sweepStreaming [integration]', () => {
     const all = await repo.findAllByChat(cappedChat, workspaceId, 100);
     expect(all.map((r) => r.content)).toEqual(['m1-oldest', 'm2', 'm3-newest']);
   });
+
+  it('default findAllByChat returns the FULL transcript past 50 rows — no recent-tail window (#202)', async () => {
+    // PR #202 swapped the model-history rebuild in AiChatService.handle from
+    // findRecent(chatId, ws, 50) to findAllByChat(chatId, ws) WITHOUT a limit
+    // arg. This pins the behavioral guarantee that switch relies on: a chat
+    // longer than the old 50-msg window comes back in FULL (oldest -> newest),
+    // so no early turns are silently dropped from what the model sees. The old
+    // 50-cap would have returned only the last 50 of these 60 rows.
+    const longChat = (
+      await createChat(db, { workspaceId, creatorId: userId })
+    ).id;
+    const base = Date.now();
+    const total = 60;
+    for (let i = 0; i < total; i++) {
+      await createMessage(db, {
+        workspaceId,
+        chatId: longChat,
+        content: `msg-${i}`,
+        // Strictly increasing timestamps so ordering is deterministic.
+        createdAt: new Date(base + i * 1000),
+      });
+    }
+
+    // Default args == exactly how handle() calls it now.
+    const history = await repo.findAllByChat(longChat, workspaceId);
+    expect(history).toHaveLength(total);
+    expect(history.map((r) => r.content)).toEqual(
+      Array.from({ length: total }, (_, i) => `msg-${i}`),
+    );
+    // The very first turn (which the old 50-window would have dropped) is present.
+    expect(history[0]!.content).toBe('msg-0');
+  });
 });