diff --git a/components/AIMode/AIModeContext.tsx b/components/AIMode/AIModeContext.tsx
index f5c7188e4..d76b232ff 100644
--- a/components/AIMode/AIModeContext.tsx
+++ b/components/AIMode/AIModeContext.tsx
@@ -14,32 +14,100 @@ import {
 import dynamic from 'next/dynamic';
 import { usePathname, useSearchParams } from 'next/navigation';
 
-/** `?ai=1` opens the overlay; `?ai=1&aiChat=<id>` selects a conversation. */
+/**
+ * `?ai=1` opens the workspace. `aiChat=<id>` selects a conversation;
+ * `aiNote=<id>` opens a document, with `aiChat` then naming the chat on that
+ * document; `aiView=doc` puts the document in the main pane.
+ */
 export const AI_MODE_OPEN_PARAM = 'ai';
 export const AI_MODE_CHAT_PARAM = 'aiChat';
+export const AI_MODE_NOTE_PARAM = 'aiNote';
+export const AI_MODE_VIEW_PARAM = 'aiView';
+const DOCUMENT_VIEW = 'doc';
+
+/**
+ * What the workspace is open on: one of the user's conversations (null = the
+ * new-conversation screen), or a document with a chat scoped to it (null =
+ * a chat not yet started).
+ */
+export type WorkspaceTarget =
+  | { readonly kind: 'conversation'; readonly chatId: number | null }
+  | { readonly kind: 'document'; readonly noteId: number; readonly chatId: number | null };
+
+/** Which pane is the main one; the other sits at a fixed width beside it. */
+export type WorkspaceLayout = 'chat' | 'document';
 
 interface AIModeUrlState {
-  isOpen: boolean;
-  chatId: number | null;
+  readonly isOpen: boolean;
+  readonly target: WorkspaceTarget;
+  readonly layout: WorkspaceLayout;
 }
 
+const NEW_CONVERSATION: WorkspaceTarget = { kind: 'conversation', chatId: null };
+const CLOSED: AIModeUrlState = { isOpen: false, target: NEW_CONVERSATION, layout: 'chat' };
+
 export interface AIModeContextValue extends AIModeUrlState {
-  /** Open on the last selected conversation, or the new-conversation screen. */
+  /** Open on the last target, or the new-conversation screen. */
   open: () => void;
   close: () => void;
   toggle: () => void;
+  /** Open on a target, laid out as its kind reads best unless told otherwise. */
+  selectTarget: (target: WorkspaceTarget, layout?: WorkspaceLayout) => void;
   /** Select a conversation (null = the new-conversation screen), opening if needed. */
   selectChat: (chatId: number | null) => void;
+  /** Open a document with a fresh chat beside it. */
+  selectDocument: (noteId: number) => void;
+  /** Swap which pane is the main one; nothing else changes. */
+  setLayout: (layout: WorkspaceLayout) => void;
 }
 
 const AIModeContext = createContext<AIModeContextValue | null>(null);
 
-function parseChatId(raw: string | null): number | null {
+function parseId(raw: string | null): number | null {
   if (raw == null) return null;
   const parsed = Number.parseInt(raw, 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
 }
 
+/** The layout a target opens in when nothing says otherwise. */
+const defaultLayout = (target: WorkspaceTarget): WorkspaceLayout =>
+  target.kind === 'document' ? 'document' : 'chat';
+
+function readUrlState(params: URLSearchParams): AIModeUrlState {
+  if (params.get(AI_MODE_OPEN_PARAM) !== '1') return CLOSED;
+  const chatId = parseId(params.get(AI_MODE_CHAT_PARAM));
+  const noteId = parseId(params.get(AI_MODE_NOTE_PARAM));
+  const target: WorkspaceTarget =
+    noteId != null ? { kind: 'document', noteId, chatId } : { kind: 'conversation', chatId };
+  // Only a document can be the main pane.
+  const layout: WorkspaceLayout =
+    noteId != null && params.get(AI_MODE_VIEW_PARAM) === DOCUMENT_VIEW ? 'document' : 'chat';
+  return { isOpen: true, target, layout };
+}
+
+function writeUrlState(params: URLSearchParams, state: AIModeUrlState): void {
+  for (const key of [
+    AI_MODE_OPEN_PARAM,
+    AI_MODE_CHAT_PARAM,
+    AI_MODE_NOTE_PARAM,
+    AI_MODE_VIEW_PARAM,
+  ]) {
+    params.delete(key);
+  }
+  if (!state.isOpen) return;
+  params.set(AI_MODE_OPEN_PARAM, '1');
+  if (state.target.chatId != null) params.set(AI_MODE_CHAT_PARAM, String(state.target.chatId));
+  if (state.target.kind === 'document') {
+    params.set(AI_MODE_NOTE_PARAM, String(state.target.noteId));
+    if (state.layout === 'document') params.set(AI_MODE_VIEW_PARAM, DOCUMENT_VIEW);
+  }
+}
+
+const sameTarget = (a: WorkspaceTarget, b: WorkspaceTarget): boolean =>
+  a.kind === b.kind &&
+  a.chatId === b.chatId &&
+  (a.kind !== 'document' || b.kind !== 'document' || a.noteId === b.noteId);
+
 /**
  * Reads the overlay's URL state. Isolated behind Suspense because
  * `useSearchParams` de-opts a statically rendered page up to the nearest
@@ -48,11 +116,19 @@ function parseChatId(raw: string | null): number | null {
  */
 function AIModeUrlSync({ onChange }: { readonly onChange: (state: AIModeUrlState) => void }) {
   const searchParams = useSearchParams();
-  const isOpen = searchParams.get(AI_MODE_OPEN_PARAM) === '1';
-  const chatId = isOpen ? parseChatId(searchParams.get(AI_MODE_CHAT_PARAM)) : null;
+  const { isOpen, layout, target } = readUrlState(searchParams);
+  const { chatId } = target;
+  const noteId = target.kind === 'document' ? target.noteId : null;
+  // Rebuilt from its parts so the effect runs on a change of state, not on
+  // every render's fresh object.
   useEffect(() => {
-    onChange({ isOpen, chatId });
-  }, [isOpen, chatId, onChange]);
+    onChange({
+      isOpen,
+      layout,
+      target:
+        noteId != null ? { kind: 'document', noteId, chatId } : { kind: 'conversation', chatId },
+    });
+  }, [isOpen, layout, chatId, noteId, onChange]);
   return null;
 }
 
@@ -62,21 +138,24 @@ const AIModeOverlay = dynamic(
 );
 
 /**
- * Owns the AI Mode overlay: its open/selected state lives in the URL, so a
- * reload or a shared link lands on the same conversation, and any client-side
- * navigation to another page naturally drops the params and closes it.
+ * Owns the AI Mode overlay: what it is open on lives in the URL, so a reload
+ * or a shared link lands on the same conversation or document, and any
+ * client-side navigation to another page naturally drops the params and
+ * closes it.
  *
  * Mounted once, globally. The overlay body is lazy-loaded so a session that
  * never opens it pays nothing.
  */
 export function AIModeProvider({ children }: { readonly children: ReactNode }) {
   const pathname = usePathname();
-  const [state, setState] = useState<AIModeUrlState>({ isOpen: false, chatId: null });
-  // Closing drops the chat from the URL; reopening from the sidebar in the same
-  // page session should still return to it. In memory only — a reload starts
-  // from whatever the URL says.
-  const lastChatIdRef = useRef<number | null>(null);
-  if (state.chatId != null) lastChatIdRef.current = state.chatId;
+  const [state, setState] = useState<AIModeUrlState>(CLOSED);
+  // Closing drops the target from the URL; reopening from the sidebar in the
+  // same page session should still return to it. In memory only — a reload
+  // starts from whatever the URL says.
+  const lastRef = useRef<Pick<AIModeUrlState, 'target' | 'layout'> | null>(null);
+  if (state.isOpen && !sameTarget(state.target, NEW_CONVERSATION)) {
+    lastRef.current = { target: state.target, layout: state.layout };
+  }
 
   const pathnameRef = useRef(pathname);
   pathnameRef.current = pathname;
@@ -85,16 +164,7 @@ export function AIModeProvider({ children }: { readonly children: ReactNode }) {
     // Event-handler only, so window is available; keeps every unrelated
     // query param the page already carries.
     const params = new URLSearchParams(window.location.search);
-    if (next.isOpen) {
-      params.set(AI_MODE_OPEN_PARAM, '1');
-    } else {
-      params.delete(AI_MODE_OPEN_PARAM);
-    }
-    if (next.isOpen && next.chatId != null) {
-      params.set(AI_MODE_CHAT_PARAM, String(next.chatId));
-    } else {
-      params.delete(AI_MODE_CHAT_PARAM);
-    }
+    writeUrlState(params, next);
     const query = params.toString();
     const hash = window.location.hash;
     // Native history, not router.replace: the app router keeps
@@ -108,28 +178,45 @@ export function AIModeProvider({ children }: { readonly children: ReactNode }) {
     setState(next);
   }, []);
 
+  const selectTarget = useCallback(
+    (target: WorkspaceTarget, layout: WorkspaceLayout = defaultLayout(target)) => {
+      if (sameTarget(target, NEW_CONVERSATION)) lastRef.current = null;
+      navigate({ isOpen: true, target, layout });
+    },
+    [navigate]
+  );
   const open = useCallback(() => {
-    navigate({ isOpen: true, chatId: lastChatIdRef.current });
+    const last = lastRef.current;
+    navigate(
+      last
+        ? { isOpen: true, target: last.target, layout: last.layout }
+        : { isOpen: true, target: NEW_CONVERSATION, layout: 'chat' }
+    );
   }, [navigate]);
-  const close = useCallback(() => navigate({ isOpen: false, chatId: null }), [navigate]);
+  const close = useCallback(() => navigate(CLOSED), [navigate]);
   const selectChat = useCallback(
-    (chatId: number | null) => {
-      if (chatId == null) lastChatIdRef.current = null;
-      navigate({ isOpen: true, chatId });
-    },
-    [navigate]
+    (chatId: number | null) => selectTarget({ kind: 'conversation', chatId }),
+    [selectTarget]
+  );
+  const selectDocument = useCallback(
+    (noteId: number) => selectTarget({ kind: 'document', noteId, chatId: null }),
+    [selectTarget]
   );
 
   const stateRef = useRef(state);
   stateRef.current = state;
+  const setLayout = useCallback(
+    (layout: WorkspaceLayout) => navigate({ ...stateRef.current, isOpen: true, layout }),
+    [navigate]
+  );
   const toggle = useCallback(() => {
     if (stateRef.current.isOpen) close();
     else open();
   }, [open, close]);
 
   const value = useMemo<AIModeContextValue>(
-    () => ({ ...state, open, close, toggle, selectChat }),
-    [state, open, close, toggle, selectChat]
+    () => ({ ...state, open, close, toggle, selectTarget, selectChat, selectDocument, setLayout }),
+    [state, open, close, toggle, selectTarget, selectChat, selectDocument, setLayout]
   );
 
   return (
diff --git a/components/AIMode/AIModeOverlay.tsx b/components/AIMode/AIModeOverlay.tsx
index 9393a2a47..554e87944 100644
--- a/components/AIMode/AIModeOverlay.tsx
+++ b/components/AIMode/AIModeOverlay.tsx
@@ -34,8 +34,9 @@ const DOCUMENT_DEFAULT_SHARE = 0.55;
  * from inside it still render on top.
  */
 export function AIModeOverlay() {
-  const { close } = useAIMode();
+  const { close, layout, setLayout } = useAIMode();
   const state = useAIModeChat();
+  const { target } = state;
   // Below the tablet breakpoint the sidebar lives in a bottom drawer.
   const [listDrawerOpen, setListDrawerOpen] = useState(false);
   const closeListDrawer = useCallback(() => setListDrawerOpen(false), []);
@@ -66,18 +67,21 @@ export function AIModeOverlay() {
     defaultWidth: LIST_DEFAULT_WIDTH,
     anchor: 'left',
   });
-  // Document or details in the right pane; details wants a wider floor.
+  // Document or details in the document pane; details wants a wider floor.
   const [documentView, setDocumentView] = useState<DocumentPaneView>('document');
   const documentMinWidth = documentView === 'details' ? DETAILS_MIN_WIDTH : DOCUMENT_MIN_WIDTH;
-  // The document may grow until the chat is down to its minimum column.
-  const documentMaxWidth = Math.max(
-    documentMinWidth,
-    viewportWidth - listWidth.width - CHAT_MIN_WIDTH
+  // The side pane is the document (chat first) or the chat (document first);
+  // it may grow until the main pane is down to its own minimum column.
+  const sideIsDocument = layout === 'chat';
+  const sideMinWidth = sideIsDocument ? documentMinWidth : CHAT_MIN_WIDTH;
+  const sideMaxWidth = Math.max(
+    sideMinWidth,
+    viewportWidth - listWidth.width - (sideIsDocument ? CHAT_MIN_WIDTH : DOCUMENT_MIN_WIDTH)
   );
-  const documentWidth = useResizableWidth({
+  const sideWidth = useResizableWidth({
     storageKey: 'ai-mode:document-width',
-    min: documentMinWidth,
-    max: documentMaxWidth,
+    min: sideMinWidth,
+    max: sideMaxWidth,
     defaultWidth: (width) => width * DOCUMENT_DEFAULT_SHARE,
     anchor: 'right',
   });
@@ -85,15 +89,17 @@ export function AIModeOverlay() {
   isBelowTabletRef.current = isBelowTablet;
 
   // On desktop the document pane opens by itself the moment a conversation
-  // gains a note. On mobile it never opens by itself — the card in the
-  // transcript is the way in, and it opens a drawer. Either way the user can
-  // close it and reopen it from the card or the chat header.
+  // gains a note, and a document opened from the sidebar shows at once
+  // everywhere. Otherwise on mobile the card in the transcript is the way in,
+  // and it opens a drawer. Either way the user can close it and reopen it
+  // from the card or the chat header.
   const noteId = state.note?.id ?? null;
+  const onDocument = target.kind === 'document';
   const [documentOpen, setDocumentOpen] = useState(false);
   useEffect(() => {
-    setDocumentOpen(noteId != null && !isBelowTabletRef.current);
+    setDocumentOpen(noteId != null && (onDocument || !isBelowTabletRef.current));
     setDocumentView('document');
-  }, [noteId]);
+  }, [noteId, onDocument]);
 
   const openDocument = useCallback(() => setDocumentOpen(true), []);
   const closeDocument = useCallback(() => setDocumentOpen(false), []);
@@ -119,8 +125,9 @@ export function AIModeOverlay() {
     }
     return null;
   }, [noteId, state.chat.chat]);
+  // A document opened from the sidebar is the main pane; no card needed.
   const documentCard =
-    noteId != null ? (
+    noteId != null && !onDocument ? (
       <DocumentCard
         title={documentTitle}
         status={doc.status}
@@ -158,14 +165,16 @@ export function AIModeOverlay() {
       <AIModeHeader
         documentTitle={showDocument ? documentTitle : null}
         publishControlsRef={isBelowTablet ? undefined : setPublishControlsSlot}
+        layout={showDocument && !isBelowTablet ? layout : undefined}
+        onLayoutChange={setLayout}
         onClose={close}
       />
 
       <WorkspacePanes
-        layout="chat"
+        layout={layout}
         isBelowTablet={isBelowTablet}
         sidebarWidth={{ ...listWidth, min: LIST_MIN_WIDTH, max: LIST_MAX_WIDTH }}
-        sideWidth={{ ...documentWidth, min: documentMinWidth, max: documentMaxWidth }}
+        sideWidth={{ ...sideWidth, min: sideMinWidth, max: sideMaxWidth }}
         listDrawerOpen={listDrawerOpen}
         onCloseListDrawer={closeListDrawer}
         onCloseDocumentDrawer={closeDocument}
diff --git a/components/AIMode/chat/ChatPane.tsx b/components/AIMode/chat/ChatPane.tsx
index d726441b9..b54c1ebc7 100644
--- a/components/AIMode/chat/ChatPane.tsx
+++ b/components/AIMode/chat/ChatPane.tsx
@@ -15,6 +15,7 @@ import { cn } from '@/utils/styles';
 import type { AIModeChatState } from '../useAIModeChat';
 import { aiModeGreeting, INTENT_COPY } from '../copy';
 import { StartScreen } from '../start/StartScreen';
+import { DocumentChatEmptyState } from './DocumentChatEmptyState';
 import { useUser } from '@/contexts/UserContext';
 
 interface ChatPaneProps {
@@ -85,8 +86,13 @@ export function ChatPane({
     chatId == null ? null : state.titleFor(chatId, chat.chat?.title ?? listedTitle);
   const titleLoading =
     chatId != null && currentTitle == null && (chat.chat == null || list.access === 'loading');
+  const onDocument = state.target.kind === 'document';
   const title =
-    chatId == null ? 'New conversation' : (currentTitle?.trim() ?? '') || 'Untitled conversation';
+    chatId == null
+      ? onDocument
+        ? 'New chat'
+        : 'New conversation'
+      : (currentTitle?.trim() ?? '') || 'Untitled conversation';
 
   const composer = (
     <ChatComposer
@@ -103,7 +109,9 @@ export function ChatPane({
       attachments={state.attachments}
       dropTargetRef={paneRef}
       className="border-t-0 bg-gray-50"
-      placeholder={chatId == null ? INTENT_COPY[state.intent].placeholder : undefined}
+      placeholder={
+        chatId == null && !onDocument ? INTENT_COPY[state.intent].placeholder : undefined
+      }
       toolbar={
         <ModelControls
           models={modelSelection.models}
@@ -167,6 +175,8 @@ export function ChatPane({
           <div ref={contentRef} className="mx-auto w-full max-w-[760px] px-4 py-5 tablet:!px-6">
             {listBlocked ? (
               <AccessBlocked detail={list.accessDetail} />
+            ) : chatId == null && onDocument ? (
+              <DocumentChatEmptyState />
             ) : chatId == null ? (
               <StartScreen
                 composer={composer}
@@ -221,9 +231,10 @@ export function ChatPane({
         </div>
       </div>
 
-      {/* A conversation keeps the composer docked at the bottom; the
-          new-conversation screen seats it in the middle with the starters. */}
-      {chatId != null && (
+      {/* A conversation keeps the composer docked at the bottom, as does a
+          document's chat before it starts; the new-conversation screen seats
+          it in the middle with the intent toggle. */}
+      {(chatId != null || onDocument) && (
         <div className="shrink-0 border-t border-gray-200 bg-gray-50">
           <div className={cn('mx-auto w-full max-w-[760px] px-3 py-3 tablet:!px-5')}>
             {composer}
diff --git a/components/AIMode/chat/DocumentChatEmptyState.tsx b/components/AIMode/chat/DocumentChatEmptyState.tsx
new file mode 100644
index 000000000..b91f2c091
--- /dev/null
+++ b/components/AIMode/chat/DocumentChatEmptyState.tsx
@@ -0,0 +1,19 @@
+import { MessageSquare } from 'lucide-react';
+
+/** A document is open and no one has said anything about it yet. */
+export function DocumentChatEmptyState() {
+  return (
+    <div className="flex min-h-[50vh] flex-col items-center justify-center gap-2.5 px-6 text-center">
+      <span className="flex h-10 w-10 items-center justify-center rounded-full bg-primary-100 text-primary-700">
+        <MessageSquare className="h-[18px] w-[18px]" aria-hidden="true" />
+      </span>
+      <p className="text-[15px] font-semibold text-gray-900">A new chat about this document</p>
+      <p className="max-w-[300px] text-[13px] leading-relaxed text-gray-600">
+        The assistant can read this document and propose edits you accept or reject.
+      </p>
+      <p className="text-xs text-gray-500">
+        Send a message and this chat is kept under Conversations.
+      </p>
+    </div>
+  );
+}
diff --git a/components/AIMode/shell/AIModeHeader.tsx b/components/AIMode/shell/AIModeHeader.tsx
index 1cccd8660..63d8be270 100644
--- a/components/AIMode/shell/AIModeHeader.tsx
+++ b/components/AIMode/shell/AIModeHeader.tsx
@@ -1,6 +1,8 @@
 'use client';
 
-import { Sparkles, X } from 'lucide-react';
+import { FileText, MessageSquare, Sparkles, X } from 'lucide-react';
+import { ButtonGroup } from '@/components/ui/ButtonGroup';
+import type { WorkspaceLayout } from '../AIModeContext';
 import { AI_MODE_NAME } from '../copy';
 
 interface AIModeHeaderProps {
@@ -11,16 +13,53 @@ interface AIModeHeaderProps {
    * into. Absent below the tablet breakpoint, where the drawer keeps them.
    */
   readonly publishControlsRef?: (element: HTMLDivElement | null) => void;
+  /** Which pane is the main one; absent when there is nothing to swap. */
+  readonly layout?: WorkspaceLayout;
+  readonly onLayoutChange?: (layout: WorkspaceLayout) => void;
   readonly onClose: () => void;
 }
 
 /** The workspace's top strip: the name, the open document's publishing state, close. */
-export function AIModeHeader({ documentTitle, publishControlsRef, onClose }: AIModeHeaderProps) {
+export function AIModeHeader({
+  documentTitle,
+  publishControlsRef,
+  layout,
+  onLayoutChange,
+  onClose,
+}: AIModeHeaderProps) {
   return (
     <header className="flex h-12 shrink-0 items-center justify-between gap-4 border-b border-gray-200 bg-white px-4">
       <div className="flex items-center gap-2">
         <Sparkles className="h-4 w-4 text-primary-600" aria-hidden="true" />
         <span className="text-sm font-semibold tracking-tight text-gray-900">{AI_MODE_NAME}</span>
+        {layout && onLayoutChange && (
+          <ButtonGroup
+            size="sm"
+            className="ml-3 rounded-[9px]"
+            value={layout}
+            onChange={(next) => onLayoutChange(next as WorkspaceLayout)}
+            options={[
+              {
+                value: 'chat',
+                label: (
+                  <>
+                    <MessageSquare className="h-3.5 w-3.5" aria-hidden="true" />
+                    Chat first
+                  </>
+                ),
+              },
+              {
+                value: 'document',
+                label: (
+                  <>
+                    <FileText className="h-3.5 w-3.5" aria-hidden="true" />
+                    Document first
+                  </>
+                ),
+              },
+            ]}
+          />
+        )}
       </div>
       <div className="flex min-w-0 items-center gap-3">
         {documentTitle != null && publishControlsRef && (
diff --git a/components/AIMode/shell/WorkspacePanes.tsx b/components/AIMode/shell/WorkspacePanes.tsx
index bb0694c49..15af510e2 100644
--- a/components/AIMode/shell/WorkspacePanes.tsx
+++ b/components/AIMode/shell/WorkspacePanes.tsx
@@ -5,15 +5,13 @@ import { ResizeHandle } from '@/components/ui/ResizeHandle';
 import { SwipeableDrawer } from '@/components/ui/SwipeableDrawer';
 import type { useResizableWidth } from '@/hooks/useResizableWidth';
 import { cn } from '@/utils/styles';
+import type { WorkspaceLayout } from '../AIModeContext';
 
 /** Above the overlay (9500), below BaseModal (9999). */
 const AI_MODE_DRAWER_Z_INDEX = 9600;
 
 type ResizableWidth = ReturnType<typeof useResizableWidth>;
 
-/** Which pane is the flexible main one; the other sits at a fixed width on the right. */
-export type WorkspaceLayout = 'chat' | 'document';
-
 interface WorkspacePanesProps {
   readonly layout: WorkspaceLayout;
   readonly sidebar: ReactNode;
diff --git a/components/AIMode/sidebar/ConversationsSection.tsx b/components/AIMode/sidebar/ConversationsSection.tsx
index 9e310624f..b2a449d91 100644
--- a/components/AIMode/sidebar/ConversationsSection.tsx
+++ b/components/AIMode/sidebar/ConversationsSection.tsx
@@ -23,7 +23,7 @@ interface ConversationsSectionProps {
   readonly activeChatId: number | null;
   /** Resolves a row's title, showing a rename before the server confirms it. */
   readonly titleFor: (chatId: number, fallback: string | null) => string | null;
-  readonly onSelect: (chatId: number) => void;
+  readonly onSelect: (item: AgentChatListItem) => void;
   readonly onRename: (chatId: number, title: string) => Promise<boolean>;
   readonly onDelete: (chatId: number, options: { deleteNotes: boolean }) => Promise<boolean>;
   readonly loadNotes: (chatId: number) => Promise<ChatNoteRef[]>;
@@ -92,7 +92,7 @@ export function ConversationsSection({
             title={title}
             meta={formatTimeAgo(item.updated_date)}
             isActive={isActive}
-            onSelect={() => onSelect(item.id)}
+            onSelect={() => onSelect(item)}
             titleAdornment={
               item.has_active_turn && (
                 <Loader size="sm" className="!h-3 !w-3 shrink-0 text-primary-500" />
diff --git a/components/AIMode/sidebar/DocumentsSection.tsx b/components/AIMode/sidebar/DocumentsSection.tsx
new file mode 100644
index 000000000..f5d597639
--- /dev/null
+++ b/components/AIMode/sidebar/DocumentsSection.tsx
@@ -0,0 +1,120 @@
+'use client';
+
+import { useEffect, useMemo } from 'react';
+import { File } from 'lucide-react';
+import { FundingDirectionIcon } from '@/components/Funding/FundingDirectionIcon';
+import { Button } from '@/components/ui/Button';
+import { ConversationListSkeleton } from '@/components/skeletons/AIModeSkeleton';
+import { useOrganizationContext } from '@/contexts/OrganizationContext';
+import { useUser } from '@/contexts/UserContext';
+import { useOrganizationNotes } from '@/hooks/useOrganizationNotes';
+import { getNoteKind, isChangelogNote, NOTE_KIND_LABELS, type Note } from '@/types/note';
+import { SidebarGroupHeading } from './SidebarGroupHeading';
+import { SidebarRow } from './SidebarRow';
+
+interface DocumentsSectionProps {
+  readonly activeNoteId: number | null;
+  /** A note the open conversation just created; the list fetches again to show it. */
+  readonly recentNoteId: number | null;
+  readonly onSelect: (noteId: number) => void;
+}
+
+/** The kind's mark: the money's direction for a proposal or an RFP, a plain file otherwise. */
+function NoteKindIcon({ note }: { readonly note: Note }) {
+  const kind = getNoteKind(note);
+  if (kind === 'rfp')
+    return <FundingDirectionIcon direction="giving" className="h-[22px] w-[22px]" />;
+  if (kind === 'proposal') {
+    return <FundingDirectionIcon direction="receiving" className="h-[22px] w-[22px]" />;
+  }
+  return (
+    <span
+      aria-hidden="true"
+      className="flex h-[22px] w-[22px] shrink-0 items-center justify-center rounded-full bg-gray-200 text-gray-600"
+    >
+      <File className="h-3 w-3" />
+    </span>
+  );
+}
+
+/**
+ * The user's notebook, as the notebook itself lists it: every note they can
+ * open, newest first, each marked by what it is. Opening one puts the
+ * document in the main pane with a fresh chat beside it.
+ */
+export function DocumentsSection({ activeNoteId, recentNoteId, onSelect }: DocumentsSectionProps) {
+  const { selectedOrg, isLoading: isLoadingOrg } = useOrganizationContext();
+  const { user } = useUser();
+  const notes = useOrganizationNotes(selectedOrg?.slug, { waiting: isLoadingOrg });
+  const isModerator = Boolean(user?.isModerator);
+
+  const rows = useMemo(
+    () =>
+      notes.notes
+        .filter(
+          (note) =>
+            (note.access === 'WORKSPACE' ||
+              note.access === 'SHARED' ||
+              note.access === 'PRIVATE') &&
+            (isModerator || !isChangelogNote(note))
+        )
+        .sort((a, b) => new Date(b.updatedDate).getTime() - new Date(a.updatedDate).getTime()),
+    [notes.notes, isModerator]
+  );
+
+  // The assistant created a note this list does not have yet.
+  const { refresh } = notes;
+  const known = recentNoteId == null || notes.notes.some((note) => note.id === recentNoteId);
+  useEffect(() => {
+    if (!known && !notes.isLoading) void refresh();
+    // Refetch once per new note, not on every list change.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [recentNoteId, known]);
+
+  return (
+    <section aria-label="Documents">
+      <SidebarGroupHeading>Documents</SidebarGroupHeading>
+
+      {notes.isLoading && <ConversationListSkeleton count={4} />}
+
+      {notes.error && !notes.isLoading && (
+        <div className="flex flex-col items-start gap-2 px-3 py-2">
+          <p className="text-xs leading-relaxed text-gray-600">Couldn’t load your documents.</p>
+          <Button variant="outlined" size="sm" onClick={() => void refresh()}>
+            Try again
+          </Button>
+        </div>
+      )}
+
+      {!notes.isLoading && !notes.error && rows.length === 0 && (
+        <p className="px-3 py-2 text-xs text-gray-400">No documents yet.</p>
+      )}
+
+      {rows.map((note) => {
+        const kind = getNoteKind(note);
+        const kindLabel = kind === 'other' ? 'Note' : NOTE_KIND_LABELS[kind];
+        return (
+          <SidebarRow
+            key={note.id}
+            title={note.title?.trim() || 'Untitled'}
+            meta={`${kindLabel} · ${note.post ? 'Published' : 'Draft'}`}
+            leading={<NoteKindIcon note={note} />}
+            isActive={note.id === activeNoteId}
+            onSelect={() => onSelect(note.id)}
+          />
+        );
+      })}
+
+      {notes.hasMore && (
+        <button
+          type="button"
+          onClick={notes.loadMore}
+          disabled={notes.isLoadingMore}
+          className="ml-1 mt-0.5 rounded-md px-2 py-1 text-xs font-medium text-gray-600 transition-colors hover:bg-gray-200/60 hover:text-gray-900 disabled:opacity-60"
+        >
+          {notes.isLoadingMore ? 'Loading…' : 'Load more'}
+        </button>
+      )}
+    </section>
+  );
+}
diff --git a/components/AIMode/sidebar/WorkspaceSidebar.tsx b/components/AIMode/sidebar/WorkspaceSidebar.tsx
index b8e419d9b..1e4a7bc78 100644
--- a/components/AIMode/sidebar/WorkspaceSidebar.tsx
+++ b/components/AIMode/sidebar/WorkspaceSidebar.tsx
@@ -1,9 +1,11 @@
 'use client';
 
 import { Plus } from 'lucide-react';
+import { useAIMode } from '../AIModeContext';
 import { cn } from '@/utils/styles';
 import type { AIModeChatState } from '../useAIModeChat';
 import { ConversationsSection } from './ConversationsSection';
+import { DocumentsSection } from './DocumentsSection';
 
 interface WorkspaceSidebarProps {
   readonly state: AIModeChatState;
@@ -11,9 +13,11 @@ interface WorkspaceSidebarProps {
   readonly onNavigate?: () => void;
 }
 
-/** The left column: start a conversation, or pick up one of your own. */
+/** The left column: start a conversation, pick up one of your own, or open a document. */
 export function WorkspaceSidebar({ state, onNavigate }: WorkspaceSidebarProps) {
-  const { chatId, list } = state;
+  const { selectDocument } = useAIMode();
+  const { target, chatId, list } = state;
+  const onNewConversation = target.kind === 'conversation' && chatId == null;
 
   return (
     <div className="flex h-full flex-col">
@@ -26,7 +30,7 @@ export function WorkspaceSidebar({ state, onNavigate }: WorkspaceSidebarProps) {
           }}
           className={cn(
             'flex w-full items-center gap-2 rounded-lg border border-gray-200 bg-white px-3 py-2 text-sm font-medium text-gray-900 shadow-sm transition-colors hover:bg-gray-50',
-            chatId == null && 'border-primary-200 bg-primary-50 hover:bg-primary-50'
+            onNewConversation && 'border-primary-200 bg-primary-50 hover:bg-primary-50'
           )}
         >
           <Plus className="h-4 w-4" aria-hidden="true" />
@@ -41,8 +45,8 @@ export function WorkspaceSidebar({ state, onNavigate }: WorkspaceSidebarProps) {
           accessDetail={list.accessDetail}
           activeChatId={chatId}
           titleFor={state.titleFor}
-          onSelect={(id) => {
-            state.selectChat(id);
+          onSelect={(item) => {
+            state.selectConversation(item);
             onNavigate?.();
           }}
           onRename={state.rename}
@@ -50,6 +54,17 @@ export function WorkspaceSidebar({ state, onNavigate }: WorkspaceSidebarProps) {
           loadNotes={state.notesForChat}
           onRetry={list.refresh}
         />
+
+        <div aria-hidden="true" className="mx-2 mt-2.5 h-px bg-gray-200" />
+
+        <DocumentsSection
+          activeNoteId={target.kind === 'document' ? target.noteId : null}
+          recentNoteId={target.kind === 'conversation' ? (state.note?.id ?? null) : null}
+          onSelect={(noteId) => {
+            selectDocument(noteId);
+            onNavigate?.();
+          }}
+        />
       </nav>
     </div>
   );
diff --git a/components/AIMode/useAIModeChat.ts b/components/AIMode/useAIModeChat.ts
index 7ab5dbf69..1cb5ba999 100644
--- a/components/AIMode/useAIModeChat.ts
+++ b/components/AIMode/useAIModeChat.ts
@@ -1,13 +1,13 @@
 'use client';
 
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { useAIMode } from './AIModeContext';
+import { useAIMode, type WorkspaceTarget } from './AIModeContext';
 import { getChatTransport } from '@/services/chatTransport';
 import { useAgentChatList, type UseAgentChatListResult } from '@/hooks/useAgentChat';
 import { useChatSession, type ChatSession } from '@/hooks/useChatSession';
 import type { ChatNoticePolicy } from '@/components/AgentChat/chatNotices';
 import type { FundingIntent } from '@/components/Funding/fundingDirection';
-import type { ChatNoteRef, AgentChat } from '@/types/agentChat';
+import type { AgentChatListItem, ChatNoteRef, AgentChat } from '@/types/agentChat';
 import type { SelectedGrantDetails } from '@/types/grant';
 import { useFundingIntent } from './start/useFundingIntent';
 
@@ -17,7 +17,9 @@ const LIST_POLL_INTERVAL_MS = 5000;
 const NOTICES: ChatNoticePolicy = { noun: 'conversation', usageLimit: 'inline' };
 
 export interface AIModeChatState extends ChatSession {
+  readonly target: WorkspaceTarget;
   readonly chatId: number | null;
+  /** Every conversation the user has, the notebook's included. */
   readonly list: UseAgentChatListResult;
   /** What the next conversation is for; sent with its creation. */
   readonly intent: FundingIntent;
@@ -34,14 +36,14 @@ export interface AIModeChatState extends ChatSession {
   readonly deleteChat: (chatId: number, options?: { deleteNotes?: boolean }) => Promise<boolean>;
   /**
    * The notes a conversation created, for the delete confirmation: the open
-   * chat's from what is loaded, any other's from one detail fetch.
+   * chat's from what is loaded, any other's from one detail fetch. A chat on
+   * a document created nothing; the document is not its to delete.
    */
   readonly notesForChat: (chatId: number) => Promise<ChatNoteRef[]>;
-  readonly selectChat: (chatId: number | null) => void;
+  /** Open a listed conversation where it lives: on its own, or on its document. */
+  readonly selectConversation: (item: AgentChatListItem) => void;
   readonly startNewChat: () => void;
-  /** The first note of every conversation whose detail this session has loaded. */
-  readonly notesByChat: ReadonlyMap<number, ChatNoteRef>;
-  /** The active conversation's document, if it has one. */
+  /** The document the open target is about, if it has one. */
   readonly note: ChatNoteRef | null;
   /**
    * The title to show for a conversation: a rename the user just made, shown
@@ -51,17 +53,29 @@ export interface AIModeChatState extends ChatSession {
 }
 
 /**
- * Orchestration for the overlay: the sidebar's list, the open chat's session,
- * selection through the URL, renames and deletes. The session itself — the
- * chat, its draft and the send path — is `useChatSession`, shared with the
- * notebook's panel.
+ * Orchestration for the workspace: the sidebar's list, the open target's
+ * session, selection through the URL, renames and deletes. The session
+ * itself — the chat, its draft and the send path — is `useChatSession`,
+ * shared with the notebook's panel; here it runs on the assistant's
+ * transport for a conversation and on the note's for a document.
  */
 export function useAIModeChat(): AIModeChatState {
-  const { chatId, selectChat: selectChatInUrl } = useAIMode();
-  const transport = getChatTransport({ noteId: null });
+  const { target, layout, selectTarget, selectChat } = useAIMode();
+  const { chatId } = target;
+  const targetNoteId = target.kind === 'document' ? target.noteId : null;
+  const transport = getChatTransport({ noteId: targetNoteId });
 
-  const list = useAgentChatList(transport, true);
+  // The sidebar lists every conversation, whichever surface the open one is on.
+  const list = useAgentChatList(getChatTransport({ noteId: null }), true);
   const refreshList = list.refresh;
+  const listRef = useRef(list.chats);
+  listRef.current = list.chats;
+  /** The transport a listed conversation is served by. */
+  const transportFor = useCallback((id: number) => {
+    const item = listRef.current.find((chat) => chat.id === id);
+    const noteId = item?.workflow === 'notebook_chat' ? (item.note?.id ?? null) : null;
+    return getChatTransport({ noteId });
+  }, []);
 
   // ---- what the next conversation starts out knowing ----
   const [intent, setIntent] = useFundingIntent();
@@ -73,13 +87,26 @@ export function useAIModeChat(): AIModeChatState {
     return { intent: current, selectedGrantId: grant?.id ?? null };
   }, []);
 
+  const targetRef = useRef(target);
+  targetRef.current = target;
+  const layoutRef = useRef(layout);
+  layoutRef.current = layout;
   const onChatCreated = useCallback(
     (created: AgentChat) => {
+      const current = targetRef.current;
+      if (current.kind === 'document') {
+        // The chat stays on its document, in whatever layout the user had.
+        selectTarget(
+          { kind: 'document', noteId: current.noteId, chatId: created.conversation_id },
+          layoutRef.current
+        );
+        return;
+      }
       // The RFP went with the conversation it was picked for.
       setSelectedGrant(null);
-      selectChatInUrl(created.conversation_id);
+      selectChat(created.conversation_id);
     },
-    [selectChatInUrl]
+    [selectTarget, selectChat]
   );
   const session = useChatSession({
     transport,
@@ -94,11 +121,18 @@ export function useAIModeChat(): AIModeChatState {
   const clearAttachments = session.attachments.clear;
   const chatRef = useRef(chat.chat);
   chatRef.current = chat.chat;
-  const chatIdRef = useRef(chatId);
-  chatIdRef.current = chatId;
 
   // ---- selection ----
-  const selectChat = useCallback((next: number | null) => selectChatInUrl(next), [selectChatInUrl]);
+  const selectConversation = useCallback(
+    (item: AgentChatListItem) => {
+      if (item.workflow === 'notebook_chat' && item.note) {
+        selectTarget({ kind: 'document', noteId: item.note.id, chatId: item.id }, 'chat');
+      } else {
+        selectChat(item.id);
+      }
+    },
+    [selectTarget, selectChat]
+  );
   const startNewChat = useCallback(() => selectChat(null), [selectChat]);
 
   // ---- keep the listing fresh ----
@@ -114,34 +148,17 @@ export function useAIModeChat(): AIModeChatState {
     return () => clearInterval(timer);
   }, [anyTurnActive, refreshList]);
 
-  // ---- document refs for the list badges ----
-  const [notesByChat, setNotesByChat] = useState<Map<number, ChatNoteRef>>(() => new Map());
-  const firstNote = chat.chat?.notes?.[0] ?? null;
-  const firstNoteId = firstNote?.id ?? null;
-  const firstNoteTitle = firstNote?.title ?? null;
-  const loadedChatId = chat.chat?.conversation_id ?? null;
-  useEffect(() => {
-    if (loadedChatId == null || firstNoteId == null || firstNoteTitle == null) return;
-    setNotesByChat((prev) => {
-      const existing = prev.get(loadedChatId);
-      if (existing?.id === firstNoteId && existing.title === firstNoteTitle) return prev;
-      const next = new Map(prev);
-      next.set(loadedChatId, { id: firstNoteId, title: firstNoteTitle });
-      return next;
-    });
-  }, [loadedChatId, firstNoteId, firstNoteTitle]);
-
   // ---- renames, shown before the server confirms them ----
   // A rename is the user's own words; making them wait for the PATCH just
   // flashes the old title back at them. The override shows at once and is
   // dropped when the listing catches up, or rolled back if the save fails.
   const [pendingTitles, setPendingTitles] = useState<Map<number, string>>(() => new Map());
-  const setPendingTitle = useCallback((target: number, title: string | null) => {
+  const setPendingTitle = useCallback((id: number, title: string | null) => {
     setPendingTitles((prev) => {
-      if (title == null ? !prev.has(target) : prev.get(target) === title) return prev;
+      if (title == null ? !prev.has(id) : prev.get(id) === title) return prev;
       const next = new Map(prev);
-      if (title == null) next.delete(target);
-      else next.set(target, title);
+      if (title == null) next.delete(id);
+      else next.set(id, title);
       return next;
     });
   }, []);
@@ -153,69 +170,80 @@ export function useAIModeChat(): AIModeChatState {
     }
   }, [list.chats, pendingTitles, setPendingTitle]);
   const titleFor = useCallback(
-    (target: number, fallback: string | null) => pendingTitles.get(target) ?? fallback,
+    (id: number, fallback: string | null) => pendingTitles.get(id) ?? fallback,
     [pendingTitles]
   );
 
   const rename = useCallback(
-    async (target: number, title: string): Promise<boolean> => {
-      setPendingTitle(target, title);
+    async (id: number, title: string): Promise<boolean> => {
+      setPendingTitle(id, title);
       let renamed: boolean;
-      if (target === chatIdRef.current) {
+      if (id === targetRef.current.chatId) {
         // The open chat's hook keeps its own copy of the title in sync.
         renamed = await chat.rename(title);
       } else {
         try {
-          await transport.renameChat(target, title);
+          await transportFor(id).renameChat(id, title);
           renamed = true;
         } catch {
           renamed = false;
         }
       }
       if (renamed) refreshList();
-      else setPendingTitle(target, null);
+      else setPendingTitle(id, null);
       return renamed;
     },
-    [chat, transport, refreshList, setPendingTitle]
+    [chat, transportFor, refreshList, setPendingTitle]
   );
 
   const notesForChat = useCallback(
-    async (target: number): Promise<ChatNoteRef[]> => {
-      if (target === chatIdRef.current && chatRef.current?.conversation_id === target) {
+    async (id: number): Promise<ChatNoteRef[]> => {
+      const item = listRef.current.find((c) => c.id === id);
+      if (item?.workflow === 'notebook_chat') return [];
+      if (id === targetRef.current.chatId && chatRef.current?.conversation_id === id) {
         return chatRef.current.notes ?? [];
       }
       try {
-        return (await transport.getChat(target)).notes ?? [];
+        return (await transportFor(id).getChat(id)).notes ?? [];
       } catch {
         return [];
       }
     },
-    [transport]
+    [transportFor]
   );
 
   const deleteChat = useCallback(
-    async (target: number, options?: { deleteNotes?: boolean }): Promise<boolean> => {
-      if (!transport.deleteChat) return false;
+    async (id: number, options?: { deleteNotes?: boolean }): Promise<boolean> => {
       try {
-        await transport.deleteChat(target, options);
+        await transportFor(id).deleteChat(id, options);
       } catch {
         return false;
       }
-      clearAttachments(target);
-      if (chatIdRef.current === target) selectChat(null);
+      clearAttachments(id);
+      if (targetRef.current.chatId === id) selectChat(null);
       refreshList();
       return true;
     },
-    [transport, selectChat, refreshList, clearAttachments]
+    [transportFor, selectChat, refreshList, clearAttachments]
   );
 
-  const note = useMemo(() => {
-    if (chatId == null) return null;
-    return firstNote ?? notesByChat.get(chatId) ?? null;
-  }, [chatId, firstNote, notesByChat]);
+  // ---- the document the target is about ----
+  // A conversation's is the first note it created, which its own detail
+  // reports and its listing row remembers between loads; a document target's
+  // is the document itself, titled from whatever the list knows of it.
+  const firstNote = chat.chat?.notes?.[0] ?? null;
+  const note = useMemo<ChatNoteRef | null>(() => {
+    if (target.kind === 'document') {
+      const listed = list.chats.find((item) => item.note?.id === target.noteId)?.note;
+      return { id: target.noteId, title: listed?.title ?? '' };
+    }
+    if (target.chatId == null) return null;
+    return firstNote ?? list.chats.find((item) => item.id === target.chatId)?.note ?? null;
+  }, [target, firstNote, list.chats]);
 
   return {
     ...session,
+    target,
     chatId,
     list,
     intent,
@@ -225,9 +253,8 @@ export function useAIModeChat(): AIModeChatState {
     rename,
     deleteChat,
     notesForChat,
-    selectChat,
+    selectConversation,
     startNewChat,
-    notesByChat,
     note,
     titleFor,
   };
diff --git a/services/assistantChat.service.ts b/services/assistantChat.service.ts
index 8e09eedda..ab415253f 100644
--- a/services/assistantChat.service.ts
+++ b/services/assistantChat.service.ts
@@ -31,8 +31,11 @@ export interface UsageBudget {
  * adds to a chat (the documents the agent created from it).
  */
 export class AssistantChatService {
+  /** Every chat the user has, the notebook's included, each saying where it lives. */
   static async listChats(): Promise<AgentChatListItem[]> {
-    const response = await ApiClient.get<{ chats: AgentChatListItem[] }>(BASE_PATH);
+    const response = await ApiClient.get<{ chats: AgentChatListItem[] }>(
+      `${BASE_PATH}?include=notebook`
+    );
     return response.chats ?? [];
   }
 
diff --git a/services/chatTransport.ts b/services/chatTransport.ts
index ec4bc32e0..4831bb4c4 100644
--- a/services/chatTransport.ts
+++ b/services/chatTransport.ts
@@ -47,8 +47,8 @@ export interface ChatTransport {
   renameChat(chatId: ChatId, title: string): Promise<{ conversation_id: number; title: string }>;
   cancelTurn(chatId: ChatId): Promise<CancelTurnResponse>;
   socketUrl(chatId: ChatId): string;
-  /** Absent on surfaces whose backend has no delete endpoint (the notebook). */
-  deleteChat?(chatId: ChatId, options?: { deleteNotes?: boolean }): Promise<void>;
+  /** The notebook's chats keep their note: `deleteNotes` is the assistant surface's. */
+  deleteChat(chatId: ChatId, options?: { deleteNotes?: boolean }): Promise<void>;
 }
 
 const transports = new Map<string, ChatTransport>();
@@ -80,6 +80,7 @@ export function notebookChatTransport(noteId: ChatId): ChatTransport {
     renameChat: (chatId, title) => NotebookChatService.renameChat(noteId, chatId, title),
     cancelTurn: (chatId) => NotebookChatService.cancelTurn(noteId, chatId),
     socketUrl: (chatId) => WS_ROUTES.NOTEBOOK_CHAT(noteId, chatId),
+    deleteChat: (chatId) => NotebookChatService.deleteChat(noteId, chatId),
   };
 }
 
diff --git a/services/notebookChat.service.ts b/services/notebookChat.service.ts
index 055939c95..e078ac402 100644
--- a/services/notebookChat.service.ts
+++ b/services/notebookChat.service.ts
@@ -34,6 +34,10 @@ export class NotebookChatService {
     return ApiClient.post<AgentChat>(this.basePath(noteId), title ? { title } : {});
   }
 
+  static async deleteChat(noteId: ID, chatId: ID): Promise<void> {
+    await ApiClient.deleteNoContent(`${this.basePath(noteId)}${chatId}/`);
+  }
+
   static async getChat(noteId: ID, chatId: ID, options?: { live?: boolean }): Promise<AgentChat> {
     const suffix = options?.live ? '?activity=live' : '';
     return ApiClient.get<AgentChat>(`${this.basePath(noteId)}${chatId}/${suffix}`);
diff --git a/types/agentChat.ts b/types/agentChat.ts
index 9bfa95f79..9d2166252 100644
--- a/types/agentChat.ts
+++ b/types/agentChat.ts
@@ -232,6 +232,9 @@ export interface AgentChat {
   notes?: ChatNoteRef[];
 }
 
+/** The surface a chat lives on: the assistant's own, or scoped to a notebook note. */
+export type ChatWorkflow = 'assistant_chat' | 'notebook_chat';
+
 export interface AgentChatListItem {
   id: number;
   title: string | null;
@@ -241,6 +244,15 @@ export interface AgentChatListItem {
   last_message_preview: string | null;
   /** True while a turn is queued/running — show a spinner in the picker. */
   has_active_turn: boolean;
+  /** Assistant listing only: which routes serve this chat. */
+  workflow?: ChatWorkflow;
+  /**
+   * Assistant listing only: the note a notebook chat is on, or the first note
+   * an assistant chat created; null for a chat with neither.
+   */
+  note?: ChatNoteRef | null;
+  /** Assistant listing only: what the chat was opened to do; blank on older chats. */
+  intent?: string;
 }
 
 export interface SendMessageResponse {